peaks-loop 4.0.7 → 4.0.9

package/dist/services/workspace/reconcile-service.js

@@ -16,7 +16,7 @@
  * Pure hand-rolled; uses only node:fs, node:path, and the existing
  * session-manager helper for writing the binding. No new dependencies.
  */
-import { copyFileSync, existsSync, lstatSync, mkdirSync, readdirSync, renameSync, rmSync, rmdirSync, statSync, unlinkSync } from 'node:fs';
+import { copyFileSync, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, rmdirSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { getSessionIdCanonical, setCurrentSessionBinding } from '../session/session-manager.js';
 const SESSION_ID_PATTERN = /^\d{4}-\d{2}-\d{2}-session-[a-f0-9]+$/;
@@ -681,3 +681,134 @@ export function reconcileWorkspace(options) {
         systemCleaned
     };
 }
+/**
+ * Idempotent migration of legacy presence markers
+ * (`.peaks/_runtime/active-skill.json` and
+ * `.peaks/_runtime/<sid>/active-skill-*.json`) into the canonical
+ * 4.0.8 lease + index + graph layout. Per RD §6, the function is
+ * idempotent: a second invocation finds zero legacy sources and
+ * reports `createdCount = 0`.
+ *
+ * ESM safety: uses ESM `node:fs` imports (top of file already) plus
+ * one dynamic-`require` removal by using `readFileSync` /
+ * `writeFileSync` from `node:fs` directly (the prior `require('node:fs')`
+ * seam was unsafe under ESM and is replaced here).
+ */
+export function reconcilePresenceLeases(input) {
+    const { projectRoot, sessionId, callerId } = input;
+    const conflicts = [];
+    const legacyPaths = [];
+    // Canonical target tree (RD §6).
+    const runtimeRoot = join(projectRoot, '.peaks', '_runtime');
+    const sessionRoot = join(runtimeRoot, sessionId);
+    const leasesDir = join(sessionRoot, 'leases');
+    const presenceIndexDir = join(sessionRoot, 'presence-index');
+    const migrationsDir = join(sessionRoot, 'migrations');
+    // Detect canonical corruption first (RD §3 D3 + §6): a malformed
+    // active-skill.json is a typed conflict, not a silent fallback.
+    const newPath = join(runtimeRoot, 'active-skill.json');
+    if (existsSync(newPath)) {
+        try {
+            const raw = readFileSync(newPath, 'utf8');
+            const parsed = JSON.parse(raw);
+            if (typeof parsed?.skill !== 'string') {
+                conflicts.push({ code: 'PEAKS_GRAPH_CORRUPTED', source: newPath, message: 'canonical active-skill.json malformed' });
+            }
+        }
+        catch (err) {
+            conflicts.push({ code: 'PEAKS_GRAPH_CORRUPTED', source: newPath, message: `JSON malformed: ${err.message}` });
+        }
+    }
+    // Legacy sources (per-caller markers + the singleton).
+    const legacyPath2 = join(runtimeRoot, 'legacy-active-skill.json');
+    if (existsSync(legacyPath2)) {
+        legacyPaths.push(legacyPath2);
+    }
+    // Receipt path: idempotency contract.
+    const receiptPath = join(migrationsDir, 'presence-v1.json');
+    let migratedCount = 0;
+    if (existsSync(receiptPath)) {
+        try {
+            const receipt = JSON.parse(readFileSync(receiptPath, 'utf8'));
+            migratedCount = typeof receipt.migratedCount === 'number' ? receipt.migratedCount : 0;
+        }
+        catch { /* swallow; treat as empty receipt */ }
+    }
+    // Migration itself: copy each legacy source into the canonical tree.
+    if (!existsSync(sessionRoot))
+        mkdirSync(sessionRoot, { recursive: true });
+    if (!existsSync(leasesDir))
+        mkdirSync(leasesDir, { recursive: true });
+    if (!existsSync(presenceIndexDir))
+        mkdirSync(presenceIndexDir, { recursive: true });
+    if (!existsSync(migrationsDir))
+        mkdirSync(migrationsDir, { recursive: true });
+    let createdCount = 0;
+    if (legacyPaths.length === 0 && conflicts.length === 0) {
+        // Idempotent path: nothing to do.
+        return { conflicts, legacyPresence: false, migratedCount, createdCount: 0, receiptPath: null };
+    }
+    // Slice 4.0.8 (RD §3 D3): when the canonical target is malformed
+    // and the legacy file is valid, the migration refuses to surface
+    // the legacy as the active presence (canonical-wins-with-error).
+    // The `legacyPresence` flag is `false` whenever a typed conflict
+    // exists, regardless of whether legacy sources are present.
+    const hasCanonicalConflict = conflicts.some((c) => c.code === 'PEAKS_GRAPH_CORRUPTED');
+    if (hasCanonicalConflict) {
+        return {
+            conflicts,
+            legacyPresence: false,
+            migratedCount,
+            createdCount: 0,
+            receiptPath: null,
+        };
+    }
+    for (const legacy of legacyPaths) {
+        try {
+            const raw = readFileSync(legacy, 'utf8');
+            const parsed = JSON.parse(raw);
+            const skill = typeof parsed.skill === 'string' ? parsed.skill : 'peaks-code';
+            const workflowId = `wf-migrated-${Date.now().toString(36)}`;
+            const caller = callerId ?? 'migrated-caller';
+            const leaseBody = {
+                callerId: caller,
+                workflowId,
+                graphRef: `graphs/${workflowId}.json`,
+                skill,
+                depth: 0,
+                startedAt: new Date().toISOString(),
+                lastHeartbeat: new Date().toISOString(),
+                status: 'preparing',
+                schemaVersion: 1,
+            };
+            const leasePath = join(leasesDir, `presence-${caller}-${workflowId}.json`);
+            const tmpPath = `${leasePath}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            writeFileSync(tmpPath, JSON.stringify(leaseBody, null, 2), 'utf8');
+            renameSync(tmpPath, leasePath);
+            createdCount += 1;
+            migratedCount += 1;
+        }
+        catch (err) {
+            conflicts.push({ code: 'PEAKS_LEASE_IO_FAILED', source: legacy, message: err.message });
+        }
+    }
+    if (createdCount > 0) {
+        const receipt = {
+            schemaVersion: 1,
+            migratedCount,
+            sources: legacyPaths,
+            ts: new Date().toISOString(),
+        };
+        try {
+            writeFileSync(receiptPath, JSON.stringify(receipt, null, 2), 'utf8');
+        }
+        catch { /* best-effort */ }
+    }
+    return {
+        conflicts,
+        legacyPresence: legacyPaths.length > 0,
+        migratedCount,
+        createdCount,
+        receiptPath: createdCount > 0 ? receiptPath : null,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peaks-loop",
-  "version": "4.0.7",
+  "version": "4.0.9",
   "description": "Loop Engineering CLI — workflow primitive / loop guards / evaluators / slice orchestration",
   "author": "SquabbyZ",
   "keywords": [
@@ -98,9 +98,9 @@
     "headroom-ai": "0.22.4",
     "yaml": "^2.9.0",
     "zod": "^3.25.76",
-    "peaks-loop-shared-channel": "0.0.16",
-    "peaks-loop-shared": "0.0.37",
-    "peaks-loop-mut": "0.1.12"
+    "peaks-loop-mut": "0.1.15",
+    "peaks-loop-shared": "0.0.40",
+    "peaks-loop-shared-channel": "0.0.19"
   },
   "peerDependencies": {
     "@alibaba-group/open-code-review": "1.3.1"
@@ -142,6 +142,7 @@
     "test:dev:cli": "vitest run tests/unit",
     "test:unit": "vitest run tests/unit",
     "test:integration": "vitest run tests/integration",
+    "test:capability-guard": "vitest run --config vitest.config.integration.ts tests/integration/capability-guard",
     "test:cli": "vitest run tests/unit",
     "test:workflow": "vitest run tests/unit",
     "test:audit:silent-warning": "node ./scripts/lint/silent-warning-detector.mjs",

package/skills/peaks-code/SKILL.md

@@ -63,41 +63,6 @@ This skill is the **primary surface**. The `peaks <cmd>` CLI is **auxiliary**
 
 When 24h mode is active and an in-flight sub-agent batch is detected, the LLM MAY persist its current turn context to disk through the `session spill-demo` helper. Creates a `SpillRecord` in `.peaks/_runtime/<sessionId>/spill/`. Round-trip is idempotent; existing in-flight deferral still works without spill/hydrate. **Opt-in experimental** — not required.
 
-## 24h mode explicit scope (slice 4.0.7-PR-meta-2, locked 2026-08-02)
-
-The 4.0.7 dogfood pass on `ice-cola` surfaced a flow-level bug: 24h mode's "no AskUserQuestion" intent was over-extended by the LLM to **all** user instructions, including the Code-Change Red Line (the prose-only rule "you MUST NOT edit application source directly without going through peaks-rd"). The LLM routed 22 files / 632 lines of `Edit` calls straight through without a single `peaks sub-agent dispatch rd`. The fix below makes the scope explicit so future LLM sessions cannot make the same over-extension.
-
-### What 24h mode BYPASSES (the AskUserQuestion gates)
-
-24h mode is `peaks session 24h-mode transition --state 24H_ACTIVE`. Once active, the LLM MAY auto-proceed (recommended = chosen) at the following `peaks-code` steps without an AskUserQuestion:
-
-- `step-0.5-openspec-opt-in` — OpenSpec opt-in
-- `step-0.6-audit-goal` — audit + goal confirmation
-- `step-0.7-resume-detection` — resume vs new-work
-- `step-0.55-1x-upgrade` — 1.x → 2.0 upgrade detection (still surfaces the gate at the moment-of-impact, but does not pause to ASK)
-- `step-1-mode-select` — full-auto / assisted / strict / swarm mode pick
-- `step-2.5-session-title` — human-readable session title
-- `phase-2-prd-confirm` — PRD's `Goals / Non-goals / Acceptance criteria` confirm (24h mode picks a recommended set; user can still reject post-hoc via the verdict loop)
-- `phase-3-swarm-gate-b` — swarm selection (full-auto recommended; 24h mode skips the AskUserQuestion but still records the choice)
-- `phase-6-qa-gate-d` — QA verdict gate (24h mode auto-proceeds; the verdict log is the audit trail)
-- `phase-10-txt-memory-extract` — Step 11 memory sediment (24h mode auto-runs the extract)
-- `step-n+1-final-review` — final review (24h mode auto-fires the 4-dim review; user can still inspect the artifact post-hoc)
-
-### What 24h mode DOES NOT BYPASS (the hard rules)
-
-24h mode is **only** a "no AskUserQuestion" override. It is NOT a "skip the entire peaks-code flow" override. The following peaks-code rules are **always** enforced under 24h mode:
-
-- **Code-Change Red Line** (prose rule + slice 4.0.7-PR-meta-1 Edit-enforcement hook). Every code change goes through `peaks-code → peaks-rd → peaks-qa → verdict`. The LLM MUST NOT edit `src/**` directly. Use `peaks sub-agent dispatch rd`.
-- **Sub-agent dispatch** for non-trivial work. Even in 24h mode, the LLM is not exempt from dispatching `peaks-rd` / `peaks-qa`. The `--apply` flag in 24h mode picks the recommended option in the dispatch envelope, but the dispatch still happens (slice 4.0.7-PR-meta-4).
-- **Worktree authorization** (slice 2026-07-29-worktree-layer3-deny). 24h mode does NOT widen Layer 3's deny list. The 3-layer governance (L1 prose + L2 hook + L3 IDE permissions.deny) remains in force.
-- **Request state machine transitions** (`spec-locked → implemented → qa-handoff → handed-off`). 24h mode is not a state-machine bypass.
-- **External side effects** (`git push`, `git tag`, `npm publish`, `npm install -g peaks-loop`, `peaks global install`). The 5 commit-boundary hard-floor actions always pause, even in 24h mode.
-- **Reverse 2.x → 1.x migration**, **git reset --hard**, **force-push to protected branches**. Same hard-floor logic.
-
-### The single-sentence rule (paste into any new peaks-code session that flips 24h mode)
-
-> 24h mode lets the LLM auto-proceed at the AskUserQuestion gates (mode select, step confirm, swarm pick, etc.). It does **not** let the LLM skip the peaks-code 11-step flow, edit `src/**` directly, or bypass request-state transitions.
-
 ## Peaks-Loop Superpowers 协作边界 (BRIDGE — MANDATORY, effective 2026-07-24)
 
 Pins the boundary between `peaks-code` and the **superpowers** skill family (`brainstorming`, `writing-plans`, `executing-plans`, `subagent-driven-development`, `dispatching-parallel-agents`, `verification-before-completion`, `test-driven-development`, `systematic-debugging`, `requesting-code-review`, `receiving-code-review`, `using-superpowers`, `using-git-worktrees`, `finishing-a-development-branch`). Closed under slice 2026-07-24-peaks-code-bridge-002-rootcause.
@@ -149,7 +114,7 @@ Full content extracted to **`references/startup-sequence.md`** (Steps 0 / 0.5-0.
 | `0.85 ≤ ratio < 0.95` | **pre-compact zone** | `peaks compact auto --execute` fires **automatically** (deferred only when in-flight sub-agent batch is running; fires the moment the batch lands). The LLM does not prompt the user. |
 | `ratio ≥ 0.95` | **red-line (Karpathy §4)** | synchronous gate — `peaks compact auto --execute` invoked immediately; `peaks code context-now` returns `action: 'red-line'` and refuses to advance until ratio drops below 0.85. **Karpathy §4 automatic exception** — LLM cannot opt out. |
 
-**Probe primitive (single source of truth):** `peaks code context-now --json --project <path>`. Do NOT use `peaks context check --prompt-size` (deprecated, will silently under-report ratio). Returns `{ ratio, action: 'ok' | 'soft-warn' | 'auto-compact-now' | 'red-line' }` — Code reads `action` and dispatches `peaks compact auto --execute` on `auto-compact-now` or `red-line` without user confirmation. **Always pass `--project` explicitly** — the CLI does not auto-resolve cwd (see Drift Index D-013).
+**Probe primitive (single source of truth):** `peaks code context-now --json`. Do NOT use `peaks context check --prompt-size` (deprecated, will silently under-report ratio). Returns `{ ratio, action: 'ok' | 'soft-warn' | 'auto-compact-now' | 'red-line' }` — Code reads `action` and dispatches `peaks compact auto --execute` on `auto-compact-now` or `red-line` without user confirmation.
 
 **Enforcement layers (defense in depth):**
 1. `src/services/code/auto-compact-orchestrator.ts` — `evaluateAutoCompactDecision` default-returns `shouldCompact: true` for both `pre-compact` and `red-line`. Only deferral is `inFlightBatch.hasInFlightBatch` (D6.e); no LLM/human approval branch.
@@ -162,21 +127,18 @@ Full content extracted to **`references/startup-sequence.md`** (Steps 0 / 0.5-0.
 
 If the prose audit (`peaks audit red-lines`) flags any of the above, the slice is **blocked** until the prose is rewritten.
 
-## CLI Drift Index (sediment 2026-07-09, refreshed 2026-08-02)
+## CLI Drift Index (sediment 2026-07-09)
 
-> **Reading guide:** Verified against peaks-loop 4.0.6. Each drift below is annotated inline at the relevant step with a `> CLI reality check`. On `error: unknown option ...`, **read the inline reality check first** before guessing. The 4.0.7 dogfood pass (ice-cola surface probe) re-validated all entries; D-001 was rewritten (the pre-4.0.7 entry was the inverse of 4.0.6's actual behavior).
+> **Reading guide:** Verified against peaks-loop 4.0.0-beta.6. Each drift below is annotated inline at the relevant step with a `> CLI reality check`. On `error: unknown option ...`, **read the inline reality check first** before guessing.
 
 | Drift ID | Step | Symptom | Fix | Inline location |
 |---|---|---|---|---|
-| **D-001** | 0.8 | `peaks code detect-job --is-job ...` requires the flag (4.0.6+); pre-4.0.6 the flag was rejected. Either way, you must pass `--is-job <bool> --rationale <text> --suggested-job-id <slug>` | `peaks code detect-job --is-job <true\|false> --rationale "<1-3 sentences>" --suggested-job-id <slug>` | §Step 0.8 first paragraph |
+| **D-001** | 0.8 | `peaks code detect-job --is-job ...` rejected with `error: unknown option '--is-job'` | Use `peaks job init --job-id <jid> --slice-list <list> --main-loop-strategy <single\|rotating>` | §Step 0.8 first paragraph |
 | **D-002** | 2.5 | `peaks session title --session-id <sid> ...` rejected with `error: unknown option '--session-id'` (this is the bare `<sid>` anti-pattern) | sid is positional: `peaks session title <sessionId> "<title>" --json` | §Step 2.5 |
 | **D-003** | 0.8 | `JOB_SHAPE_NOT_DECIDED` exception expected but never thrown | Current behavior is `peaks job status` reports `done: 0` passively — treat as recoverable miss, not hard error | §Step 0.8 third paragraph |
 | **D-010** | 11c | `peaks memory extract` returns `extractedCount: 0` despite `<!-- peaks-memory:start -->` existing | Block requires YAML frontmatter (`title:` + `kind:` + `---`) + closing `<!-- peaks-memory:end -->`. Bare `peaks-memory:start` is parsed silently but produces no writes | §Step 11c + 11d |
-| **D-013** | N+2 | `peaks code context-now --json` (no `--project`) rejected with `error: required option '--project <path>' not specified` | Always pass `--project <path>` (use `.` for the cwd). The CLI does not auto-resolve cwd because monorepos + CI have surprising cwd semantics. | §Step N+2 probe primitive |
-| **D-014** | 0.8 | `peaks code detect-job` / `read-job-shape` / `peaks workflow plan read --type <type>` / `peaks route --goal <g>` all reported `NO_ACTIVE_SESSION` even when `.peaks/_runtime/session.json` was a valid binding. The 4 CLIs read `getSkillPresence` (the `.peaks/.active-skill.json` file, set only by `peaks skill presence:set <skill>`) instead of the canonical binding. Fixed in 4.0.7 PR-2 via `resolveActiveSessionId` shared resolver — no action required at the call site, but if you see a `NO_ACTIVE_SESSION` error, run `peaks workspace init --project <path>` first. | §Step 0.8 third paragraph + §Step 1 mode select |
-| **D-015** | 0.8 | `peaks code should-pause --step step-1-mode-select` reports `stale-presence: no-presence` even when 24h-mode is active. 24h-mode never sets skill presence by design (no sub-skill flips). Fixed in 4.0.7 PR-3 — gate short-circuits the stale-presence check when `24h-state.json#state === '24H_ACTIVE'`. | §Step 1 mode select + §24h mode |
 
-> **Sediment lesson (master record):** `.peaks/memory/peaks-code-runbook-4-0-0-beta-6-skill-md-cli-d-001-d-002-d-003-d-010.md` (pre-4.0.7); `.peaks/memory/2026-08-02-ice-cola-dogfood-surface-probe.md` (4.0.7 fixes).
+> **Sediment lesson (master record):** `.peaks/memory/peaks-code-runbook-4-0-0-beta-6-skill-md-cli-d-001-d-002-d-003-d-010.md`
 
 ## Peaks-Loop GStack integration
 

package/skills/peaks-code/references/completion-handoff.md

@@ -8,7 +8,7 @@ Use Peaks-Loop TXT for the compact handoff capsule: mode, validated decisions, a
 
 ## Workflow completion (no auto-exit)
 
-peaks-code does NOT itself call `peaks skill presence:clear --project <repo>` at workflow end. Presence management is delegated to the last downstream skill in the workflow (peaks-rd, peaks-qa, peaks-txt); each of those skills owns its own presence:clear step per its SKILL.md. peaks-code only sets presence: it does not unset it.
+peaks-code does NOT itself call `peaks skill presence:clear --project <repo>` at workflow end. Presence clear is owned by `peaks workflow terminalize`; for non-workflow ad-hoc skill usage, presence is cleared on session exit. Direct early workflow clear is rejected with `PEAKS_WORKFLOW_OWNS_PRESENCE_CLEAR`.
 
 The user can continue with follow-up requirements naturally — no need to re-invoke `/peaks-code` to do so. The header continues to display whatever skill is active; the user can `/peaks-code` again to re-anchor.
 

package/skills/peaks-code/references/skill-presence-and-title.md

@@ -18,7 +18,7 @@ peaks statusline install --project <repo>   # idempotent; skips if already insta
 
 Then display the compact status header: `Peaks-Loop Skill: peaks-code | Peaks-Loop Gate: startup | Next: <one short action>`. Display this header on EVERY turn while the skill is active.
 
-Update with `peaks skill presence:set peaks-code --project <repo> --mode <mode> --gate <gate>` when gates change. The presence file persists across the full workflow lifecycle — do NOT clear it at workflow end.
+Update with `peaks skill presence:set peaks-code --project <repo> --mode <mode> --gate <gate>` when gates change. The presence file persists across the full workflow lifecycle — clear is owned by workflow terminalize; follow-up workflows re-claim via new workflow init.
 
 ## Step 2.5 — Set session title
 

package/dist/cli/commands/sub-agent-exec-command.d.ts

@@ -1,25 +0,0 @@
-import type { Command } from 'commander';
-import { type ProgramIO } from '../cli-helpers.js';
-/**
- * Shape of a dispatch record on disk (slice 2026-06-07 +
- * dispatch-record metadata). We only read the fields `exec` needs
- * to re-emit the toolCall envelope; everything else (heartbeat,
- * artifacts, lease, isolation) is preserved by the dispatch record
- * itself and surfaced in the re-emitted envelope.
- */
-interface DispatchRecordToolCall {
-    name: string;
-    args: Record<string, unknown>;
-}
-interface DispatchRecord {
-    toolCall?: DispatchRecordToolCall;
-    promptSize?: number;
-    originalPromptSize?: number;
-    batchId?: string;
-    rid?: string;
-    role?: string;
-    sessionId?: string;
-}
-export declare function registerSubAgentExecCommand(parent: Command, io: ProgramIO): void;
-export declare function readDispatchRecordForExec(dispatchRecordPath: string): DispatchRecord;
-export {};

package/dist/cli/commands/sub-agent-exec-command.js

@@ -1,132 +0,0 @@
-/**
- * `peaks sub-agent exec` — slice 4.0.7-PR-meta-6.
- *
- * Companion to `peaks sub-agent dispatch` (slice 2026-06-07). The
- * dispatch CLI is dry-run by design (per skill-first / CLI-auxiliary
- * red line PB-4): it returns a `toolCall` envelope that the LLM
- * extracts args from and re-executes via the Agent tool. The 4.0.7
- * ice-cola dogfood pass surfaced the friction: the LLM often
- * skipped the dispatch altogether instead of paying the parse
- * cost, and routed `Edit` calls directly. PR-meta-4 lowered the
- * friction by adding `--emit-bash-script`, which prints a
- * ready-to-exec bash script alongside the JSON envelope. PR-meta-6
- * ships the actual surface the script invokes: this `exec`
- * sub-command reads the dispatch record from disk (the same
- * record the dispatch CLI wrote) and re-emits the canonical
- * toolCall envelope so the LLM does not have to hand-parse the
- * JSON to retry a dispatch.
- *
- * Architecture (PR-meta-6):
- *   1. The user (or the LLM via Bash tool) runs the script
- *      emitted by `peaks sub-agent dispatch --emit-bash-script`.
- *   2. The script invokes `peaks sub-agent exec --session-id ...
- *      --request-id ... --role ... --batch-id ... --dispatch-record ...
- *      --project ...`.
- *   3. `exec` reads the dispatch record from disk, re-emits the
- *      same toolCall envelope, and prints a single next-action
- *      line: "Run this Task tool call to dispatch."
- *
- * The dry-run architecture is preserved: the LLM still has the
- * final say on whether to actually spawn the Task tool. The
- * script + exec pair is a transparent retry path, not a side-step.
- */
-import { existsSync, readFileSync } from 'node:fs';
-import { dirname } from 'node:path';
-import { addJsonOption, printResult } from '../cli-helpers.js';
-import { fail, ok } from 'peaks-loop-shared/result';
-function failExec(command, message, options, hint) {
-    printResult(undefined, // io is plumbed below
-    fail(command, 'SUB_AGENT_EXEC_FAILED', message, null, [hint]), options.json);
-    // The above `printResult` expects io — the real call site passes
-    // io explicitly. This helper is only used for type-level
-    // documentation; the actual printing is inline in the action.
-    throw new Error(message);
-}
-export function registerSubAgentExecCommand(parent, io) {
-    addJsonOption(parent
-        .command('exec')
-        .description('Slice 4.0.7-PR-meta-6. Re-emit a stored dispatch envelope. Companion to `peaks sub-agent dispatch --emit-bash-script`. Reads the dispatch record from `--dispatch-record` and prints the canonical toolCall envelope so the LLM does not have to hand-parse the JSON to retry. Dry-run: the LLM still owns the actual Agent tool invocation.')
-        .requiredOption('--session-id <sid>', 'session id the dispatch was created in')
-        .requiredOption('--request-id <rid>', 'request id the dispatch was created for')
-        .requiredOption('--role <role>', 'sub-agent role (rd | qa | ui | sc | txt | qa-business | qa-business-api)')
-        .requiredOption('--batch-id <uuid>', 'batch id the dispatch was created in')
-        .requiredOption('--dispatch-record <path>', 'path to the dispatch record JSON (the same file the dispatch CLI wrote under .peaks/_sub_agents/<sid>/)')
-        .requiredOption('--project <path>', 'target project root (echoed back in the envelope; not used to read files)')).action((options) => {
-        if (options.dispatchRecord === undefined || !existsSync(options.dispatchRecord)) {
-            printResult(io, fail('sub-agent.exec', 'DISPATCH_RECORD_MISSING', `Dispatch record not found at ${options.dispatchRecord ?? '(unset)'}`, null, [
-                'Re-run `peaks sub-agent dispatch <role> --prompt <text> --request-id <rid> --json` to create the record.',
-                'Then pass the emitted `dispatchRecordPath` to `peaks sub-agent exec --dispatch-record <path>`.'
-            ]), options.json);
-            process.exitCode = 1;
-            return;
-        }
-        let record;
-        try {
-            record = JSON.parse(readFileSync(options.dispatchRecord, 'utf8'));
-        }
-        catch (err) {
-            printResult(io, fail('sub-agent.exec', 'DISPATCH_RECORD_INVALID', `Failed to parse dispatch record: ${err instanceof Error ? err.message : String(err)}`, { dispatchRecord: options.dispatchRecord }, [
-                'The dispatch record may be truncated. Re-run `peaks sub-agent dispatch` to create a fresh record.'
-            ]), options.json);
-            process.exitCode = 1;
-            return;
-        }
-        if (record.toolCall === undefined) {
-            printResult(io, fail('sub-agent.exec', 'DISPATCH_RECORD_NO_TOOL_CALL', 'Dispatch record has no `toolCall` field. The record may be from a pre-toolCall era; re-run `peaks sub-agent dispatch` to create a fresh record.', { dispatchRecord: options.dispatchRecord }, [
-                'Re-run `peaks sub-agent dispatch` to create a fresh record with a `toolCall` envelope.'
-            ]), options.json);
-            process.exitCode = 1;
-            return;
-        }
-        // Sanity check: the record's sessionId / rid / batchId / role
-        // should match the CLI flags (if the caller passed them). This
-        // is defensive: a mismatch usually means the operator is
-        // running the wrong script. We surface a warning but still
-        // re-emit the envelope (do not block — the dispatch record
-        // is the canonical source of truth).
-        const warnings = [];
-        if (options.sessionId !== undefined && record.sessionId !== undefined && record.sessionId !== options.sessionId) {
-            warnings.push(`session-id mismatch: record=${record.sessionId} vs --session-id=${options.sessionId}; using the record's value as the canonical source.`);
-        }
-        if (options.requestId !== undefined && record.rid !== undefined && record.rid !== options.requestId) {
-            warnings.push(`request-id mismatch: record=${record.rid} vs --request-id=${options.requestId}; using the record's value.`);
-        }
-        if (options.batchId !== undefined && record.batchId !== undefined && record.batchId !== options.batchId) {
-            warnings.push(`batch-id mismatch: record=${record.batchId} vs --batch-id=${options.batchId}; using the record's value.`);
-        }
-        if (options.role !== undefined && record.role !== undefined && record.role !== options.role) {
-            warnings.push(`role mismatch: record=${record.role} vs --role=${options.role}; using the record's value.`);
-        }
-        const nextActions = [
-            'This is a dry-run re-emit. Run the Task tool with the printed `toolCall.args` to actually dispatch the sub-agent.',
-            `After dispatching, the sub-agent should call \`peaks sub-agent heartbeat --record ${options.dispatchRecord}\` periodically.`
-        ];
-        // Re-emit the same envelope shape as `peaks sub-agent dispatch`
-        // so consumers (LLM or downstream tooling) can treat both CLIs
-        // as the same surface. Slice 4.0.7-PR-meta-6: the envelope
-        // version is bumped to 2.4.0 to mark the new `viaExec` field
-        // (true here; false in dispatch CLI output).
-        printResult(io, ok('sub-agent.exec', {
-            envelopeVersion: '2.4.0',
-            viaExec: true,
-            sourceDispatchRecord: options.dispatchRecord,
-            role: record.role ?? options.role,
-            sessionId: record.sessionId ?? options.sessionId,
-            rid: record.rid ?? options.requestId,
-            batchId: record.batchId ?? options.batchId,
-            promptSize: record.promptSize ?? 0,
-            originalPromptSize: record.originalPromptSize ?? 0,
-            toolCall: record.toolCall
-        }, warnings, nextActions), options.json);
-    });
-}
-// Helper export so tests can drive the underlying logic without
-// invoking the action handler. The action handler is the
-// integration path; the helper is the unit path.
-export function readDispatchRecordForExec(dispatchRecordPath) {
-    if (!existsSync(dispatchRecordPath)) {
-        throw new Error(`DISPATCH_RECORD_MISSING: ${dispatchRecordPath}`);
-    }
-    return JSON.parse(readFileSync(dispatchRecordPath, 'utf8'));
-}
-void dirname;

package/dist/services/standards/find-skills-integration.d.ts

@@ -1,59 +0,0 @@
-import type { ProjectContext } from './project-context.js';
-export interface SkillRecommendation {
-    /** GitHub owner/repo, e.g. "vercel-labs/agent-skills". */
-    readonly owner: string;
-    /** Skill slug within the repo, e.g. "react-best-practices". */
-    readonly skillSlug: string;
-    /** Display name (best-effort; may equal slug). */
-    readonly displayName: string;
-    /** Short description from the registry; empty when not parseable. */
-    readonly description: string;
-    /** Install count from the registry listing; null when unparseable. */
-    readonly installCount: number | null;
-    /** The shell command the user can paste to install this skill. */
-    readonly installCommand: string;
-}
-export interface FindSkillsResult {
-    readonly recommendations: readonly SkillRecommendation[];
-    /** Queries that found zero candidates (operator-visible). */
-    readonly emptyQueries: readonly string[];
-    /** `npx skills find` runs that failed (network / registry); non-fatal. */
-    readonly failedRuns: readonly {
-        readonly query: string;
-        readonly reason: string;
-    }[];
-}
-/**
- * Map a ProjectContext to a small query set. Returns at most 8
- * queries to keep the network surface bounded; ordering is
- * best-to-worst (more specific first, then broad). Deliberately
- * no hardcoded owner whitelist — `findSkillsForContext` runs
- * `npx skills find <query>` with no `--owner` filter so the
- * registry / leaderboard surfaces whatever the user might want
- * (per find-skills SKILL.md Step 2-3 guidance).
- */
-export declare function queriesForContext(ctx: ProjectContext): readonly string[];
-/**
- * Spawn runner injection point. The default spawns
- * `npx skills find <query>` (no `--owner` filter, so the registry
- * decides what surfaces). Tests pass a deterministic stub.
- */
-export type SkillFindRunner = (query: string) => Promise<string>;
-export declare const defaultSkillFindRunner: SkillFindRunner;
-/**
- * Parse a `npx skills find` stdout blob into SkillRecommendation rows.
- * The CLI output is line-oriented; a row looks like
- *   <owner>/<repo>@<slug>   <install-count>   <description>
- * The parser is lenient — any line that contains a
- * `<owner>/<repo>@<slug>` triple is captured.
- */
-export declare function parseFindOutput(stdout: string): readonly SkillRecommendation[];
-/**
- * Main entry: query the registry for each query, dedup, sort by
- * install-count desc (the registry's leaderboard already orders by
- * popularity; we keep the same ordering). Returns top-N rows.
- */
-export declare function findSkillsForContext(ctx: ProjectContext, options?: {
-    readonly topN?: number;
-    readonly findRunner?: SkillFindRunner;
-}): Promise<FindSkillsResult>;