feat(claude-ops): lanes skill — scripted background loop-lane launcher (#508)

README.md

@@ -113,7 +113,7 @@ user opts in with `/plugin enable`; an existing install is never flipped by cata
 - [`playbooks`](plugins/playbooks) — Doctrine and knowledge playbooks as on-demand skills, plus a maintainer-facing update skill. boris — Boris Cherny's Claude Code workflow tips (howborisusesclaudecode.com); skill-authoring — Anthropic's internal skill-authoring playbook; fable-5 — Claude Fable 5's operating doctrine (self-authored, no upstream). The boris and skill-authoring packs vendor a verbatim upstream baseline; /playbooks:update drift-checks and syncs those baselines centrally (maintainers).
 - [`claude-config`](plugins/claude-config) — Three audit skills for a repo's Claude Code configuration: audit (settings.json / .mcp.json / hooks / plugins / permissions drift), audit-automation-gaps (evidence-gated verdicts on automation gaps), and audit-permission-grants (allow-rule / allowed-tools grants for auto-mode durability and portability).
 - [`claude-memory`](plugins/claude-memory) — Audits the Claude Code instruction/memory layer — CLAUDE.md, CLAUDE.local.md, .claude/rules/, and auto-memory — against a checklist derived from official Claude Code documentation. A deterministic script-backed spine (MEMORY.md index integrity, orphan always-loaded rules) yields identical findings on identical repo state; judgment-tier checks apply fixed criteria with model reading. Actions: audit (default), fix (per-item approval), update (refresh criteria from current docs), report.
-- [`claude-ops`](plugins/claude-ops) — Claude Code operations toolkit. Six skills: observability (read locally captured telemetry — OTEL store, collector, hook-event JSONL, ccusage — with trend reports and store pruning), known-issues (search known Claude product GitHub bugs, check service health, maintain a persistent tracked-issue registry), changelog (ingest Claude Code changelog entries and integrate them into the current repo), plugins (bring a machine's plugin fleet current on demand — marketplace refresh, effective-scope updates including in-repo project/local installs, new-plugin install per policy, scope-divergence detection and explicit convergence), morning-brief (read-only gh-based operator morning view — queue-label counts, merge-ready PRs, parked decisions with their RECOMMENDED lines, and loop-lane telemetry freshness), and a re-runnable setup action that settles where the known-issues registry lives. Plus a family of seven advisory *-audit telemetry-emitter hooks (API errors, config changes, instruction loads, permission denials, pre-compaction, skill usage, tool failures) that emit the shared hook-telemetry envelope, and a reference sink that maps envelopes into the hook-events.jsonl the observability skill reads.
+- [`claude-ops`](plugins/claude-ops) — Claude Code operations toolkit. Seven skills: observability (read locally captured telemetry — OTEL store, collector, hook-event JSONL, ccusage — with trend reports and store pruning), known-issues (search known Claude product GitHub bugs, check service health, maintain a persistent tracked-issue registry), changelog (ingest Claude Code changelog entries and integrate them into the current repo), plugins (bring a machine's plugin fleet current on demand — marketplace refresh, effective-scope updates including in-repo project/local installs, new-plugin install per policy, scope-divergence detection and explicit convergence), morning-brief (read-only gh-based operator morning view — queue-label counts, merge-ready PRs, parked decisions with their RECOMMENDED lines, and loop-lane telemetry freshness), lanes (start/restart/stop/status loop lanes as named background Claude Code sessions seeded from canonical prompt files, with per-lane model/effort and a repo-pull + marketplace-refresh launch step), and a re-runnable setup action that settles where the known-issues registry lives. Plus a family of seven advisory *-audit telemetry-emitter hooks (API errors, config changes, instruction loads, permission denials, pre-compaction, skill usage, tool failures) that emit the shared hook-telemetry envelope, and a reference sink that maps envelopes into the hook-events.jsonl the observability skill reads.
 - [`skill-quality`](plugins/skill-quality) — Skill-authoring QA tooling: a static contract checker that runs seventeen deterministic checks over a Claude Code skill (frontmatter, listing-budget cap, trigger-keyword preservation, line caps, broken internal refs, markdownlint, gotchas surface, evals presence) and a bundled evals.json schema for validation. Runs against any repo's skills directory via the convention-resolution ladder — no baked layout.
 
 ### Autonomy

plugins/claude-ops/.claude-plugin/plugin.json

@@ -1,8 +1,8 @@
 {
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "claude-ops",
-  "version": "0.14.0",
-  "description": "Claude Code operations toolkit. Six skills: observability (read locally captured telemetry — OTEL store, collector, hook-event JSONL, ccusage — with trend reports and store pruning), known-issues (search known Claude product GitHub bugs, check service health, maintain a persistent tracked-issue registry), changelog (ingest Claude Code changelog entries and integrate them into the current repo), plugins (bring a machine's plugin fleet current on demand — marketplace refresh, effective-scope updates including in-repo project/local installs, new-plugin install per policy, scope-divergence detection and explicit convergence), morning-brief (read-only gh-based operator morning view — queue-label counts, merge-ready PRs, parked decisions with their RECOMMENDED lines, and loop-lane telemetry freshness), and a re-runnable setup action that settles where the known-issues registry lives. Plus a family of seven advisory *-audit telemetry-emitter hooks (API errors, config changes, instruction loads, permission denials, pre-compaction, skill usage, tool failures) that emit the shared hook-telemetry envelope, and a reference sink that maps envelopes into the hook-events.jsonl the observability skill reads.",
+  "version": "0.15.0",
+  "description": "Claude Code operations toolkit. Seven skills: observability (read locally captured telemetry — OTEL store, collector, hook-event JSONL, ccusage — with trend reports and store pruning), known-issues (search known Claude product GitHub bugs, check service health, maintain a persistent tracked-issue registry), changelog (ingest Claude Code changelog entries and integrate them into the current repo), plugins (bring a machine's plugin fleet current on demand — marketplace refresh, effective-scope updates including in-repo project/local installs, new-plugin install per policy, scope-divergence detection and explicit convergence), morning-brief (read-only gh-based operator morning view — queue-label counts, merge-ready PRs, parked decisions with their RECOMMENDED lines, and loop-lane telemetry freshness), lanes (start/restart/stop/status loop lanes as named background Claude Code sessions seeded from canonical prompt files, with per-lane model/effort and a repo-pull + marketplace-refresh launch step), and a re-runnable setup action that settles where the known-issues registry lives. Plus a family of seven advisory *-audit telemetry-emitter hooks (API errors, config changes, instruction loads, permission denials, pre-compaction, skill usage, tool failures) that emit the shared hook-telemetry envelope, and a reference sink that maps envelopes into the hook-events.jsonl the observability skill reads.",
   "author": {
     "name": "Melodic Software",
     "email": "info@melodicsoftware.com"

plugins/claude-ops/CHANGELOG.md

@@ -3,6 +3,27 @@
 All notable changes to the `claude-ops` plugin are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning.
 
+## [0.15.0]
+
+### Added
+
+- **`lanes` skill** — a scripted launcher that starts, restarts, stops, and
+  reports loop lanes as **named background Claude Code sessions** seeded from
+  canonical prompt files, replacing the manual morning refresh (cancel loop,
+  clear, re-paste the canonical prompt) across N lanes. `start` (default) and
+  `restart` first `git pull --ff-only` and `claude plugin marketplace update`,
+  then launch each configured lane with `claude --bg -n <lane>` mirroring the
+  lane's `model`/`effort`; `status` prints a per-lane running/stopped table with
+  the live sessionId; `stop` ends a lane via `claude stop <sessionId>` (resolved
+  from `claude agents --json` — there is no `claude agents stop` verb). Acts on a
+  session **only** when its name is a configured lane, so a hand-started session
+  is never touched. Lanes come from a JSON config (`--config`, else
+  `$CLAUDE_OPS_LANES_CONFIG`, else `<repo>/.work/lanes.json`); `--dry-run`,
+  `--no-pull`, `--no-update`, and `--agents-json` support previewing and offline
+  reuse. Prompt files are read from a session-local `.work` dir today via the
+  single `prompt_dir`/`resolve_prompt_dir` seam, which composes with #480
+  (loop-prompt authoring skill) when durable prompt storage lands.
+
 ## [0.14.0]
 
 ### Added

plugins/claude-ops/README.md

@@ -1,11 +1,12 @@
 # claude-ops
 
 A Claude Code plugin for running Claude Code well over time — one cohesive
-capability across six skills and a family of telemetry-emitter hooks.
+capability across seven skills and a family of telemetry-emitter hooks.
 Observability reads what your sessions actually did, known-issues tracks what
 upstream has broken, changelog integration keeps your repo current with what
 upstream has shipped, the plugins skill keeps your own plugin fleet current,
-morning-brief prints your read-only operator morning view, a
+morning-brief prints your read-only operator morning view, lanes launches and
+manages your loop lanes as background sessions, a
 re-runnable `setup` action settles where the known-issues registry lives,
 and the `*-audit` hooks feed observability with per-hook execution telemetry
 Claude Code's native OTEL cannot see.
@@ -19,6 +20,7 @@ Claude Code's native OTEL cannot see.
 | `/claude-ops:changelog` | Ingests Claude Code changelog entries and integrates them into the current repo: `fetch` (read-only display), `diff` (impact triage, no edits), `status` (applied versions from git history), and `apply` (full explore → research → interview → implement pipeline, explicit user intent only). |
 | `/claude-ops:plugins` | Brings a machine's plugin fleet current on demand: marketplace refresh, updates for the plugins that actually load (including in-repo project/local-scope installs), new-catalog-plugin install per policy, and scope-divergence detection. Actions: `sync` (default, CLI-mediated mutations only), `audit` (read-only dry run), `converge` (the one action that can touch a committed `.claude/settings.json` — previews and confirms per plugin first). |
 | `/claude-ops:morning-brief` | Prints the read-only, `gh`-based operator morning view for the current repo in one pass: open counts per queue label (`priority: needs-triage`, `status: ready`, `status: needs-decision`, `needs-human`), the gh-native merge-ready PR list (non-draft + `mergeStateStatus=CLEAN`), parked `status: needs-decision` issues with their RECOMMENDED lines, and loop-lane telemetry freshness (per-lane `last-cycle` age + `flags:`). Never mutates anything; the authoritative PR merge gate stays `/source-control:babysit-prs`. |
+| `/claude-ops:lanes` | Starts, restarts, stops, and reports loop lanes as named background Claude Code sessions seeded from canonical prompt files. `start` (default) / `restart` pull the repo and refresh the plugin marketplace, then launch each configured lane (`claude --bg -n <lane>`) with its per-lane `model`/`effort`; `status` shows per-lane running state and live sessionId; `stop` ends a lane via `claude stop`. Acts only on sessions whose name is a configured lane. Lanes come from a JSON config (`--config`, else `$CLAUDE_OPS_LANES_CONFIG`, else `<repo>/.work/lanes.json`); prompt storage is session-local `.work` today and composes with #480 for a durable home. |
 | `/claude-ops:setup` | `check` (default) reports the effective known-issues-registry and skill-usage-log destinations, their defaults, and path containment; `apply` routes personal option changes through Claude Code's plugin configuration prompt. |
 
 ## The audit hooks

plugins/claude-ops/skills/lanes/SKILL.md

@@ -0,0 +1,112 @@
+---
+name: lanes
+description: "Start, restart, stop, and check loop lanes as named background Claude Code sessions seeded from canonical prompt files — the scripted replacement for the manual morning refresh (cancel loop, clear, re-paste the canonical prompt) across N lanes on a machine. `start`/`restart` first pull the repo and refresh the plugin marketplace, then launch each configured lane with its per-lane model/effort. Use when: 'launch my lanes', 'restart the loop lanes', 'start the work lanes', 'morning lane refresh', 'stop a lane', 'which lanes are running', 'lane status'. Mutating and operator-initiated; never touches a session whose name is not a configured lane."
+argument-hint: "[start|restart|status|stop] [lane...] — start (default); restart/stop accept lane names; --config, --repo, --dry-run, --no-pull, --no-update"
+user-invocable: true
+disable-model-invocation: true
+---
+
+## Pre-computed context
+
+claude CLI: !`command -v claude >/dev/null 2>&1 && echo "present ($(claude --version 2>/dev/null))" || echo "MISSING (required)"`
+jq: !`command -v jq >/dev/null 2>&1 && echo "present" || echo "MISSING (required)"`
+Repo root: !`git rev-parse --show-toplevel 2>/dev/null || echo "unknown (pass --repo)"`
+Lane config: !`c="${CLAUDE_OPS_LANES_CONFIG:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)/.work/lanes.json}"; [[ -f "$c" ]] && echo "$c ($(jq -r '(.lanes//[])|length' "$c" 2>/dev/null) lanes)" || echo "absent ($c) — author one (see context/config.md)"`
+
+## Variables
+
+Arguments: `$ARGUMENTS`
+
+## Purpose
+
+Running N loop lanes on a machine means a daily ritual: for each lane, cancel its
+loop, clear, and re-paste its canonical prompt. This skill collapses that to one
+command. `start`/`restart` pull the repo and refresh the plugin marketplace once,
+then launch each configured lane as a **named background session** seeded from the
+lane's canonical prompt file, mirroring that lane's model/effort onto the launch.
+`status`/`stop` read and manage those sessions through the CLI's own
+background-session surface.
+
+**Owns only its own lanes.** `stop`/`restart` act on a session **only** when its
+name is a lane in the resolved config — a hand-started session (e.g. an interactive
+`work` window, or an unrelated `PR Babysit`) is never stopped by this skill.
+
+## Run it
+
+```bash
+bash "${CLAUDE_PLUGIN_ROOT}/skills/lanes/scripts/lane-launcher.sh" $ARGUMENTS
+```
+
+Print the script's output verbatim — it is the deliverable. Preview any mutating
+run first with `--dry-run` (prints the exact `claude`/`git` commands, seeds
+nothing, kills nothing).
+
+## Action Router
+
+Parse `$ARGUMENTS` for the action (first token); remaining tokens are lane names
+(targets for `restart`/`stop`; an unknown name is rejected).
+
+| Action | Mutates | Description |
+|---|---|---|
+| `start` (default) | Yes | Pull + marketplace update, then launch every configured lane **not already running** |
+| `restart [lane...]` | Yes | Pull + marketplace update, then stop-and-relaunch each target lane (all, or named) |
+| `status` | No | Per-lane table: model, effort, running/stopped, and the live sessionId |
+| `stop [lane...]` | Yes | Stop each running target lane (all, or named) via `claude stop <sessionId>` |
+
+Options: `--config FILE`, `--repo DIR`, `--no-pull`, `--no-update`, `--dry-run`,
+`--agents-json FILE` (read the session list from a file instead of the live CLI —
+offline/scripted reuse). Exit codes: `0` ok · `3` bad argument/config · `4`
+prerequisite missing or repo/config unresolved.
+
+## Lane config
+
+Lanes are defined in a JSON config, resolved first-hit-wins:
+`--config FILE` → `$CLAUDE_OPS_LANES_CONFIG` → `<repo>/.work/lanes.json`. Each lane
+carries a `name`, a `prompt` file path, and optional `model`/`effort`. The full
+schema, resolution rules, and the prompt-storage seam live in
+[context/config.md](context/config.md) — read it before authoring a config.
+
+**Prompt storage is provisional (composes with #480).** Today prompt files live in
+a session-local `.work` dir (`prompt_dir`, default `.work`). Issue #480 (loop-prompt
+authoring skill) is slated to own durable prompt storage. When it lands, repoint
+`prompt_dir` at that home; the launcher resolves the prompt dir in exactly one place
+(`resolve_prompt_dir` in the script), which is the single seam to update.
+
+## Verified CLI surface
+
+The launcher shells out only to primitives confirmed on this machine's `claude`
+(`--help` / real invocation): `claude --bg -n <name> [--model M] [--effort E]
+"<prompt>"` (launch a named background session, return immediately),
+`claude agents --json` (list active sessions: pid, cwd, kind, startedAt,
+sessionId, name, status),
+`claude stop <sessionId>` (stop one session; conversation kept, resumable with
+`claude attach`), and `claude plugin marketplace update`. There is no
+`claude agents stop` verb — stop resolves the sessionId from `agents --json` and
+only for a configured lane name.
+
+## Gotchas
+
+- **No durable prompt home yet.** `.work` is session-local; a fresh machine/session
+  has no prompts until they are authored there (or `prompt_dir` is pointed at a
+  committed dir). This is the #480 dependency, not a bug.
+- **Name is the identity.** Lanes are matched by session `name` **and** `kind:
+  background` — every lane is launched with `--bg`, so an interactive window sharing
+  a lane name is never matched or stopped. Two lanes must not share a name; a
+  hand-started *background* session sharing a lane name would still be treated as
+  that lane, so keep lane names distinct from ad-hoc background session names.
+- **`start` is idempotent-ish, `restart` is not.** `start` skips a lane already
+  running; `restart` always stops-and-relaunches (discarding the running lane's
+  in-flight conversation). Use `start` for "bring up whatever is down".
+- **A missing/empty prompt file skips that lane** (with an error) rather than
+  launching an empty session. `status` flags `[prompt MISSING]`.
+
+## Cross-references
+
+- `/claude-ops:plugins` — the authoritative, richer plugin-fleet sync (scope
+  divergence, new-catalog installs). This skill's marketplace refresh is the light
+  `claude plugin marketplace update` step of a launch, not a substitute.
+- `/claude-ops:morning-brief` — reads the loop-lane **telemetry** (per-lane
+  last-cycle freshness). This skill starts/stops the lanes that emit it.
+- #480 (loop-prompt authoring skill) — forward dependency that will own durable
+  prompt storage. #496 (context economy / restart discipline) — why lanes get
+  restarted. #502 (telemetry) — the per-lane telemetry the running lanes feed.