peaks-loop 4.0.48 → 4.0.50

package/dist/cli/commands/feedback-commands.js

@@ -5,18 +5,22 @@
  *   - `peaks feedback check-unpromoted --project <path> [--strict]`
  *
  * Companion to `sops/feedback-promotion-sop.md`. The promote command
- * generates a stub for the chosen enforcement layer (A: peaks-sop
- * gate, B: peaks-hooks PreToolUse, C: mode-gate hardFloorCategory)
- * and writes the promotion marker + sidecar + RD envelope. The
- * check-unpromoted command scans `.peaks/memory/*.md` for feedback
- * memories without a promotion marker and emits a structured list.
- * `--strict` flips exit code to non-zero when any unpromoted feedback
- * is found — used by `peaks workflow verify-pipeline` Gate H.
+ * writes the promotion marker + sidecar + RD envelope, and — for the
+ * layers whose artifact it can produce (A: a registered SOP manifest)
+ * — the enforcement artifact itself. Layers B and C live in shared
+ * files it does not own, so there it records the requirement and
+ * reports `effective: false` instead of claiming success.
+ *
+ * The check-unpromoted command scans `.peaks/memory/*.md` for feedback
+ * memories whose promotion is missing OR not backed by its layer's
+ * artifact, and emits a structured list. `--strict` flips exit code to
+ * non-zero when any is found — used by `peaks workflow verify-pipeline`
+ * Gate H.
  */
 import { resolve as resolvePath } from 'node:path';
 import { findProjectRoot } from '../../services/config/config-safety.js';
 import { getCurrentSessionId } from '../../services/skills/skill-presence-service.js';
-import { generatePromotionStub, isPromotionLayer, listUnpromotedFeedback, parseFeedbackMemory, PROMOTION_LAYER_DETAILS, PROMOTION_LAYERS, promoteFeedback } from '../../services/feedback/feedback-promotion-service.js';
+import { generatePromotionStub, isPromotionLayer, listPromotionExempt, listUnpromotedFeedback, missingArtifacts, parseFeedbackMemory, PROMOTION_LAYER_DETAILS, PROMOTION_LAYERS, promoteFeedback, promotionArtifactChecks } from '../../services/feedback/feedback-promotion-service.js';
 import { fail, ok } from 'peaks-loop-shared/result';
 import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
 export function registerFeedbackCommands(program, io) {
@@ -26,15 +30,16 @@ export function registerFeedbackCommands(program, io) {
     addJsonOption(feedback
         .command('promote <memory-file>')
         .description('Promote a feedback memory to one of the 3 enforcement layers (A=peaks-sop gate, B=peaks-hooks PreToolUse, C=mode-gate hardFloorCategory). ' +
-        'Reads `.peaks/memory/<file>.md`, generates a code stub for the chosen layer, and writes ' +
-        'the promotion marker (HTML comment + sidecar .promotion.json) + an RD envelope at ' +
-        '`.peaks/_runtime/<sid>/rd/feedback-promote-<name>.json`. ' +
+        'Reads `.peaks/memory/<file>.md` and writes the promotion marker (HTML comment + sidecar .promotion.json) + an RD envelope at ' +
+        '`.peaks/_runtime/<sid>/rd/feedback-promote-<name>.json`. Layer A additionally generates and registers the SOP manifest the ' +
+        'SOP engine reads. Layers B and C live in shared files the command does not own, so it records the requirement and exits ' +
+        'non-zero (PROMOTION_NOT_EFFECTIVE) until the registration is present. ' +
         'Without --layer, the CLI lists the 3 layer options as nextActions and exits with code 0 ' +
         '(use --layer <A|B|C> to actually promote, or pass --dry-run to preview the stub).')
         .option('--layer <A|B|C>', `enforcement layer (${PROMOTION_LAYERS.join(' | ')})`)
         .option('--project <path>', 'project root (default: cwd)')
         .option('--promoted-by <id>', 'identity string for the audit envelope (default: peaks-rd fork agent)')
-        .option('--dry-run', 'preview the stub without writing the marker / sidecar / envelope')).action((memoryFile, opts) => {
+        .option('--dry-run', 'preview the stub without writing the marker / sidecar / envelope')).action(async (memoryFile, opts) => {
         try {
             const projectRoot = opts.project ?? findProjectRoot(process.cwd()) ?? process.cwd();
             const memoryPath = memoryFile.endsWith('.md')
@@ -91,7 +96,7 @@ export function registerFeedbackCommands(program, io) {
             const layer = opts.layer;
             const sessionId = getCurrentSessionId(projectRoot) ?? 'unknown-sid';
             const promotedBy = opts.promotedBy ?? 'peaks-rd fork agent';
-            const envelope = promoteFeedback({
+            const envelope = await promoteFeedback({
                 feedbackPath: memoryPath,
                 layer,
                 promotedBy,
@@ -99,11 +104,26 @@ export function registerFeedbackCommands(program, io) {
                 projectRoot,
                 dryRun: false
             });
-            printResult(io, ok('feedback.promote', envelope, [], [
+            // rid 2026-09-14-gate-h-promotion: report what was written, not what
+            // the stub wished for. A promotion whose layer artifact is absent is
+            // recorded but NOT effective, and says so with a non-zero exit.
+            const notes = [
                 `Promoted feedback "${envelope.name}" to layer ${envelope.layer} (${envelope.layerDetail}).`,
                 `Generated files: ${envelope.generatedFiles.join(', ')}`,
                 `Envelope written to .peaks/_runtime/${sessionId}/rd/feedback-promote-${envelope.name}.json`
+            ];
+            if (envelope.effective) {
+                printResult(io, ok('feedback.promote', envelope, [], notes), opts.json);
+                return;
+            }
+            const missing = missingArtifacts(promotionArtifactChecks(envelope.name, envelope.layer), projectRoot);
+            printResult(io, fail('feedback.promote', 'PROMOTION_NOT_EFFECTIVE', `Promotion recorded but not effective — layer ${envelope.layer} is not backed by its artifact: ${missing.join('; ')}`, envelope, [
+                ...notes,
+                ...(envelope.layer === 'C'
+                    ? ['Layer C lives in source code: register the hard-floor category in src/services/code/mode-gate.ts, then re-run promote to record it.']
+                    : ['Apply the snippet to the file(s) named above, then re-run promote to record it.'])
             ]), opts.json);
+            process.exitCode = 1;
         }
         catch (err) {
             printResult(io, fail('feedback.promote', 'PROMOTE_FAILED', getErrorMessage(err), { memoryFile }, ['Verify the file is a feedback memory and re-run']), opts.json);
@@ -119,23 +139,35 @@ export function registerFeedbackCommands(program, io) {
         .option('--strict', 'exit non-zero when any unpromoted feedback is found (used by verify-pipeline Gate H)')).action((opts) => {
         try {
             const unpromoted = listUnpromotedFeedback({ projectRoot: opts.project });
+            const exempt = listPromotionExempt({ projectRoot: opts.project });
             const count = unpromoted.length;
             if (count === 0) {
-                printResult(io, ok('feedback.check-unpromoted', { count: 0, unpromoted: [] }, [], [`No unpromoted feedback found in .peaks/memory/.`]), opts.json);
+                printResult(io, ok('feedback.check-unpromoted', { count: 0, unpromoted: [], exempt }, [], [
+                    `No unpromoted feedback found in .peaks/memory/.`,
+                    ...(exempt.length === 0
+                        ? []
+                        : [`${exempt.length} memor${exempt.length === 1 ? 'y' : 'ies'} declare themselves not-to-be-promoted: ${exempt.map((e) => `${e.name} (${e.code})`).join('; ')}.`])
+                ]), opts.json);
                 return;
             }
             const message = `${count} feedback memor${count === 1 ? 'y is' : 'ies are'} not yet promoted to an enforcement layer.`;
             const nextActions = [
                 `Run \`peaks feedback promote <memory-file> --layer <A|B|C>\` for each entry above.`,
                 'A = peaks-sop gate, B = peaks-hooks PreToolUse, C = mode-gate hardFloorCategory.',
+                'A marker alone does not count: the entry above names the artifact its layer still owes.',
                 'See sops/feedback-promotion-sop.md for the SOP and the layer-choice rubric.'
             ];
             if (opts.strict === true) {
-                printResult(io, fail('feedback.check-unpromoted', 'UNPROMOTED_FEEDBACK_FOUND', message, { count, unpromoted }, nextActions), opts.json);
+                printResult(io, fail('feedback.check-unpromoted', 'UNPROMOTED_FEEDBACK_FOUND', message, { count, unpromoted, exempt }, nextActions), opts.json);
                 process.exitCode = 1;
                 return;
             }
-            printResult(io, ok('feedback.check-unpromoted', { count, unpromoted }, [message], nextActions), opts.json);
+            printResult(io, ok('feedback.check-unpromoted', { count, unpromoted, exempt }, [
+                message,
+                ...(exempt.length === 0
+                    ? []
+                    : [`${exempt.length} memor${exempt.length === 1 ? 'y' : 'ies'} declare themselves not-to-be-promoted: ${exempt.map((e) => `${e.name} (${e.code})`).join('; ')}.`])
+            ], nextActions), opts.json);
         }
         catch (err) {
             printResult(io, fail('feedback.check-unpromoted', 'CHECK_FAILED', getErrorMessage(err), { project: opts.project }, ['Verify --project path and re-run']), opts.json);

package/dist/cli/commands/final-review-commands.js

@@ -26,6 +26,7 @@
  */
 import { existsSync, statSync } from 'node:fs';
 import { join, resolve } from 'node:path';
+import { REQUEST_ID_PATTERN } from '../../services/artifacts/request-artifact-service.js';
 import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
 import { fail, ok } from 'peaks-loop-shared/result';
 import { createAnthropicRunner, LlmBindingError, LlmRequestError, resolveAnthropicConfig, } from '../../services/llm/anthropic-runner.js';
@@ -135,6 +136,17 @@ export function registerFinalReviewCommands(program, io) {
         //    in two places: the pre-flight existence check (here) and the
         //    stub-path envelope (below). The service computes it identically
         //    at `src/services/final-review/final-review-service.ts:45-52`.
+        //
+        //    Rid axis. The rid is the CLI positional and it is the FILENAME
+        //    segment below, so it is checked here, at the join. Added 2026-09-14
+        //    (repair R1): this join was a second-slot hole — the `--session-id`
+        //    validation above passed and the rid slot escaped. Found by the
+        //    widened rule D, not by a human reading the file.
+        if (!REQUEST_ID_PATTERN.test(rid)) {
+            printResult(io, fail('final-review.prepare', 'RID_INVALID', `Invalid request id: ${rid} (expected letters, digits, dots, underscores, or dashes)`, emptyFinalReviewData(rid, options.sessionId, ''), ['Pass the rid of the slice, e.g. 2026-09-14-some-slug']), options.json);
+            process.exitCode = 1;
+            return;
+        }
         const auditGoalPath = join(projectValidation.projectRoot, '.peaks', '_runtime', sessionValidation.sessionId, 'audit-goal', `${rid}.json`);
         // 4. Pre-flight: if the audit-goal file is missing, surface a 404
         //    BEFORE the stub/provider check so the caller learns the real

package/dist/cli/commands/hooks-commands.js

@@ -5,9 +5,10 @@ import { fail, ok } from 'peaks-loop-shared/result';
 import { addJsonOption, printResult, getErrorMessage } from '../cli-helpers.js';
 import { findProjectRoot } from '../../services/config/config-safety.js';
 import { applyHookInstall, planHookInstall, readHookStatus, readInstalledEntriesFromSettings, removeHookInstall, listSuperpowersDenyEntries } from '../../services/skills/hooks-settings-service.js';
+import { resolveHookEntries, resolveHookSpec } from '../../services/skills/hooks-codegate-superpowers.js';
 import { readJsonObjectFile } from '../../services/ide/shared/atomic-json.js';
 import { detectIdeFromContext } from '../../services/ide/hook-translator.js';
-import { getAdapter, resolveIdeOptionHelp } from '../../services/ide/ide-registry.js';
+import { resolveIdeOptionHelp } from '../../services/ide/ide-registry.js';
 /**
  * This module's own directory — `<root>/src/cli/commands` in the source tree,
  * `<root>/dist/cli/commands` in a build. Same reason as
@@ -50,20 +51,23 @@ function resolveIdeForCommand(options, projectRoot) {
  * service did not write.
  */
 function listExpectedEntriesForIde(ide, _skipProgress = false) {
-    const adapter = getAdapter(ide);
-    if (ide === 'trae') {
-        return [{ matcher: adapter.toolMatcher, sentinel: 'peaks hook handle' }];
-    }
-    // Slice 2026-08-06-codegate-vendor-neutral: Claude Code install
-    // also emits the Edit|Write|MultiEdit code-gate entry. The summary
-    // mirrors the install shape, NOT a hardcoded expected list. The
-    // hook source of truth is `src/services/hooks/pre-tool-code-gate.sh`
-    // (vendor-neutral); the runtime adapter is `peaks code-gate --json`
-    // registered as a PreToolUse entry.
-    return [
-        { matcher: adapter.toolMatcher, sentinel: 'peaks gate enforce' },
-        { matcher: 'Edit|Write|MultiEdit', sentinel: 'peaks code-gate' }
-    ];
+    // Derived from `resolveHookEntries(ide)` — the same function `planHookInstall`
+    // / `applyHookInstall` write from — so the summary can only ever report a
+    // shape the install actually produces. The previous version was a
+    // hand-written literal under a comment claiming it "mirrors the install
+    // shape, NOT a hardcoded expected list" (diagnosis 2026-09-15, C4); the
+    // literal had drifted from that claim in both directions: it re-typed the
+    // code-gate matcher instead of reading `HOOK_CODE_GATE_MATCHER`, and it
+    // reported 2 of the 6 entries a claude-code install writes.
+    //
+    // The filter is the tool-call event. `resolveHookEntries` also returns the
+    // once-per-session SessionStart / PostCompact entries; those are not what a
+    // per-call hook-entry summary is read for, and leaving them out is the only
+    // place this summary is narrower than the install.
+    const event = resolveHookSpec(ide).hookEnforceEvent;
+    return resolveHookEntries(ide, _skipProgress)
+        .filter((entry) => entry.event === event)
+        .map((entry) => ({ matcher: entry.matcher, sentinel: entry.sentinel }));
 }
 /**
  * Slice 2026-07-24-peaks-code-bridge-002-rootcause (G6b / G10): copy the
@@ -108,6 +112,31 @@ function readOnDiskDenyEntries(settings) {
         return [];
     return deny.filter((d) => typeof d === 'string');
 }
+/**
+ * One `nextActions` line for a hook-script copy, or `null` when there is
+ * nothing to say.
+ *
+ * Diagnosis 2026-09-15 (C7): the copy failure used to be reported as a single
+ * sentence — `'<x> hook not copied (source missing or non-global scope)'` —
+ * which merged a real build failure into the expected project-scope no-op.
+ * Only `scope === 'global'` copies these scripts at all (see the call sites),
+ * so in project scope the sentence described normal behaviour in the wording
+ * of a fault, and a healthy `peaks hooks install` read as broken.
+ *
+ * Scope is therefore what decides the sentence, and it is knowable here — the
+ * copy helper cannot tell the two cases apart because both return
+ * `copied: false`, but the caller can. Project scope emits no line: there is
+ * no action to take, and the envelope's `bridgeHookCopy` / `codeGateHookCopy`
+ * field still reports `copied: false` for anyone reading the JSON.
+ */
+function describeHookCopy(label, copy, scope, dryRun) {
+    if (scope !== 'global')
+        return null;
+    if (copy.copied) {
+        return dryRun ? `would copy ${label} from ${copy.source} to ${copy.target}` : `Copied ${label}: ${copy.target}`;
+    }
+    return `${label} NOT copied — source missing at ${copy.source}. Run the build (\`pnpm build\`) so the script ships with the package.`;
+}
 function copyBridgeHookIfPresent(userHome, dryRun = false) {
     const source = resolve(MODULE_DIR, '..', '..', 'services', 'hooks', 'pre-tool-superpowers-bridge.sh');
     const target = resolve(userHome, '.claude', 'skills', 'peaks-code', 'hooks', 'pre-tool-superpowers-bridge.sh');
@@ -202,22 +231,16 @@ export function registerHooksCommands(program, io) {
                     // committed, shared file.
                     ...plan.entryTargets.map((entry) => `would write ${entry.matcher || '(no matcher)'} → ${entry.sentinel} to ${entry.settingsPath}`),
                     `would write ${listSuperpowersDenyEntries().length} permissions.deny entries (Layer 3 worktree governance)`,
-                    bridgeCopy.copied
-                        ? `would copy bridge hook from ${bridgeCopy.source} to ${bridgeCopy.target}`
-                        : 'would not copy bridge hook (source missing or non-global scope)',
-                    codeGateCopy.copied
-                        ? `would copy code-gate hook from ${codeGateCopy.source} to ${codeGateCopy.target}`
-                        : 'would not copy code-gate hook (source missing or non-global scope)'
-                ]), options.json);
+                    describeHookCopy('bridge hook', bridgeCopy, scope, true),
+                    describeHookCopy('code-gate hook', codeGateCopy, scope, true)
+                ].filter((line) => line !== null)), options.json);
                 return;
             }
             const result = applyHookInstall(scope, projectRoot, { ide, skipProgress });
-            // Slice #3: build the per-IDE entries summary from the actual installed
-            // entries, not the slice #1 PEAKS_HOOK_ENTRIES constant (which is the
-            // claude-code default). The user's JSON envelope must reflect the IDE
-            // they targeted. Slice #014: the install only emits the gate-enforce
-            // entry; the summary mirrors the install shape, NOT a hardcoded
-            // expected list.
+            // Slice #3: build the per-IDE entries summary for the IDE the user
+            // targeted, not the slice #1 PEAKS_HOOK_ENTRIES constant (which is the
+            // claude-code default). The summary is derived from the install's own
+            // entry table — see `listExpectedEntriesForIde`.
             const installedEntries = listExpectedEntriesForIde(ide, skipProgress);
             // Slice 2026-07-24-peaks-code-bridge-002-rootcause (G6b / G10): when
             // the install targets global scope, also copy the superpowers-bridge
@@ -242,16 +265,10 @@ export function registerHooksCommands(program, io) {
                     // Slice 2026-07-29-worktree-layer3-deny: surface L3 deny
                     // write alongside the hook install — single atomic write.
                     `Layer 3 deny: wrote ${listSuperpowersDenyEntries().length} permissions.deny entries (worktree governance)`,
-                    bridgeCopy.copied
-                        ? `Copied bridge hook: ${bridgeCopy.target}`
-                        : 'Bridge hook not copied (source missing or non-global scope)',
-                    codeGateCopy.copied
-                        ? `Copied code-gate hook: ${codeGateCopy.target}`
-                        : 'Code-gate hook not copied (source missing or non-global scope)'
-                ]
-                : (bridgeCopy.copied
-                    ? [`Bridge hook copied: ${bridgeCopy.target}`]
-                    : []);
+                    describeHookCopy('bridge hook', bridgeCopy, scope, false),
+                    describeHookCopy('code-gate hook', codeGateCopy, scope, false)
+                ].filter((line) => line !== null)
+                : [describeHookCopy('bridge hook', bridgeCopy, scope, false)].filter((line) => line !== null);
             // Slice 2026-07-29-worktree-layer3-deny: emit L3 deny bookkeeping
             // in the JSON envelope so downstream automation (audit / sc) can
             // confirm Layer 3 was applied without re-reading the file. When

package/dist/cli/commands/loop-eval-commands.js

@@ -166,14 +166,25 @@ export function registerWorkflowEvalCommands(program, io) {
                     process.exitCode = 1;
                     return;
                 }
-                // Sid axis. `--session` reaches two joins below (`dir` and, through
-                // `nextEvalCaptureIndex`, the same literal), so one guard here covers
-                // the whole `--capture-score` write path.
+                // Sid axis AND rid axis — the join below takes TWO ids, not one.
+                // Corrected 2026-09-14 (repair R1): this comment used to say one guard
+                // covers "the whole `--capture-score` write path". The security audit of
+                // `2026-09-14-cli-id-escape-instrumentation` (F1b) measured that false —
+                // the `--session` guard passed and the `rid` slot escaped:
+                // `peaks loop eval '../../../../…/EVILCYC' --capture-score --session
+                // <legal>` created `<projectRoot>/../EVILCYC/cycles/cycle-1.json` under
+                // an `ok: true` envelope. The rid is the CLI positional and has no pinned
+                // format, so the segment check is the control for that axis.
                 if (isUnsafePathInput(options.session)) {
                     printResult(io, fail('loop.eval', 'INVALID_SESSION_ID', `Invalid session id: ${options.session} (must be a single path segment)`, { provided: options.session }, ['Pass a session id that is a single path segment']), options.json);
                     process.exitCode = 1;
                     return;
                 }
+                if (isUnsafePathInput(rid)) {
+                    printResult(io, fail('loop.eval', 'INVALID_REQUEST_ID', `Invalid request id: ${rid} (must be a single path segment)`, { provided: rid }, ['Pass a request id that is a single path segment']), options.json);
+                    process.exitCode = 1;
+                    return;
+                }
                 const score = envelope.degraded ? 0.25 : (envelope.gateAction === 'pass' ? 1.0 : envelope.gateAction === 'warn' ? 0.5 : 0.0);
                 const dir = join(projectRoot, '.peaks', '_runtime', options.session, 'loop', rid, 'cycles');
                 const n = nextEvalCaptureIndex(projectRoot, options.session, rid);
@@ -484,12 +495,17 @@ export function registerWorkflowEvalCommands(program, io) {
  *  writes. The run-driver also writes to the same dir; the next
  *  index = max(prior)+1, or 1. */
 function nextEvalCaptureIndex(projectRoot, sid, rid) {
-    // Sid axis: this function is the join for the capture-score cycle dir. The
-    // action guards `options.session` before calling in, but the seam is callable
-    // on its own, so the join states its own contract.
+    // BOTH id axes: this function is the join for the capture-score cycle dir.
+    // The action guards `options.session` and `rid` before calling in, but the
+    // seam is callable on its own, so the join states its own contract. The rid
+    // half was missing until 2026-09-14 (repair R1) — the same second-slot hole
+    // the action had, in the same file, one function below it.
     if (isUnsafePathInput(sid)) {
         throw new Error(`Invalid session id: ${sid} (must be a single path segment)`);
     }
+    if (isUnsafePathInput(rid)) {
+        throw new Error(`Invalid request id: ${rid} (must be a single path segment)`);
+    }
     const dir = join(projectRoot, '.peaks', '_runtime', sid, 'loop', rid, 'cycles');
     if (!existsSync(dir))
         return 1;

package/dist/cli/commands/share-commands.js

@@ -1,3 +1,4 @@
+import { realpathSync as realpathSyncNative } from 'node:fs';
 import { resolve } from 'node:path';
 import { fail, getErrorMessage, ok } from 'peaks-loop-shared/result';
 import { addJsonOption, printResult } from '../cli-helpers.js';
@@ -275,18 +276,18 @@ export function registerAwaitCommand(parent, io) {
         const adapter = getAdapter(ide);
         const dispatcher = adapter.subAgentDispatcher;
         if (typeof dispatcher.awaitBatch !== 'function') {
-            printResult(io, fail('sub-agent.await', 'IDE_NOT_SUPPORTED', `IDE ${ide} does not support awaitBatch (1.2 MVP only ships claude-code)`, { ok: false }, [
-                'Switch to claude-code, or rely on LLM-side await for non-claude-code IDEs in slice 1.3.'
+            printResult(io, fail('sub-agent.await', 'IDE_NOT_SUPPORTED', `IDE ${ide} does not support awaitBatch`, { ok: false }, [
+                'Every built-in adapter has an awaitBatch since slice 1.3; a dispatcher without one is a custom adapter registered outside the built-in set.'
             ]), asJson);
             process.exitCode = 1;
             return;
         }
-        // 1.2 MVP: we don't keep a separate record path index for DAG-dispatched
-        // batches yet; the caller is expected to have a single shared record
-        // directory. We pass the empty list — the MVP runner tracks outcomes
-        // through its own contract-store writes; the dispatcher just signals
-        // "ready to await" through the awaitBatch LRU queue (slice 1.3
-        // upgrades to cross-process heartbeat polling).
+        // No record-path index is kept for DAG-dispatched batches yet; the caller
+        // is expected to have a single shared record directory. We pass the empty
+        // list — the runner tracks outcomes through its own contract-store writes,
+        // so the dispatcher reaches no slot and reports no results (see the
+        // `recordPaths: []` case in tests/unit/services/dispatch/
+        // sub-agent-dispatchers.test.ts, which pins that empty shape).
         const input = {
             batchId: options.batch,
             dispatchCount: 1,
@@ -304,7 +305,14 @@ export function registerAwaitCommand(parent, io) {
                 results,
                 summary
             }, [], [
-                'For trae / trae-cn / codex / cursor, results will report status=timeout with note=`awaitByLlm: <ide> 1.2 fallback`. The calling LLM holds the real await.'
+                // Slice 2026-09-15-s9: corrected. This used to tell users that the
+                // four non-Claude IDEs would report `awaitByLlm: <ide> 1.2 fallback`,
+                // the slice-1.2 marker that slice 1.3 replaced with a real
+                // file-polling await. The text survived because nothing tested it —
+                // no adapter produces that note any more (asserted in
+                // sub-agent-dispatchers.test.ts), and the only code that still emits
+                // it, `awaitByLlmFallback`, has no callers.
+                `Each non-claude-code IDE labels its own results (see the \`note\` field), so a timed-out slot is attributable to the adapter it came from.`
             ]), asJson);
         }
         catch (error) {
@@ -325,6 +333,24 @@ function awaitErrorNextActions(code) {
     }
     return 'See error message; check that --batch matches the dispatch envelope and --timeout is a positive integer ms.';
 }
+/**
+ * Resolve a record's on-disk path through `realpathSync` so the value returned
+ * here matches the value `writeInitialDispatchRecord` produces — which itself
+ * passes through `assertSafeDispatchRecordPath` and ends up canonicalized. On
+ * macOS, `mkdtempSync(join(tmpdir(), prefix))` returns `/var/folders/...`
+ * while `process.cwd()` after `chdir` returns `/private/var/folders/...`;
+ * without this helper the test fixture's `queuedPath` (canonical) and the
+ * envelope's `finalized[].recordPath` (raw) never compare equal. Falls back
+ * to the lexical path when the file is missing (race between scan and write).
+ */
+function safeRecordPath(p) {
+    try {
+        return realpathSyncNative(p);
+    }
+    catch {
+        return p;
+    }
+}
 export function registerFinalizeCommand(parent, io) {
     addJsonOption(parent
         .command('finalize')
@@ -418,7 +444,7 @@ export function registerFinalizeCommand(parent, io) {
                             // `--batch` branch below has always used this same filter.
                             if (!f.startsWith('dispatch-') || !f.endsWith('.json'))
                                 continue;
-                            const p = path2.join(dir, f);
+                            const p = safeRecordPath(path2.join(dir, f));
                             const r = tryReadRecord(p);
                             if (r === null || r.requestId !== options.requestId)
                                 continue;
@@ -470,7 +496,7 @@ export function registerFinalizeCommand(parent, io) {
                         for (const f of fs2.readdirSync(dir)) {
                             if (!f.startsWith('dispatch-') || !f.endsWith('.json'))
                                 continue;
-                            const p = path2.join(dir, f);
+                            const p = safeRecordPath(path2.join(dir, f));
                             const r = tryReadRecord(p);
                             if (r === null)
                                 continue;

package/dist/cli/commands/slice-integrate-commands.js

@@ -10,6 +10,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { getCurrentSessionId } from '../../services/skills/skill-presence-service.js';
 import { isUnsafePathInput } from '../../shared/path-safety.js';
+import { SLICE_ID_PATTERN } from '../../services/sc/sc-service.js';
 import { integrateSlices } from '../../services/slice/slice-integration.js';
 import { fail, ok } from 'peaks-loop-shared/result';
 import { addJsonOption, printResult } from '../cli-helpers.js';
@@ -23,6 +24,22 @@ function loadContractsForSlices(projectRoot, sessionId, sliceIds) {
         return [];
     const result = [];
     for (const sliceId of sliceIds) {
+        // Slice-id axis: the id becomes the FILENAME below, so `--slices a,../..`
+        // reads a JSON file outside the contracts dir. Guarded 2026-09-14 (repair
+        // R1, security audit F3 of `2026-09-14-cli-id-escape-instrumentation`) —
+        // the session guard above covers the other axis and this one was open.
+        // Skipped with a warning rather than thrown, matching this function's
+        // existing contract for a contract it cannot read.
+        //
+        // NOTE for the instrument: rule D in
+        // `tests/unit/runtime/no-runtime-input-guard.test.ts` does NOT see this
+        // site — its root is the local `const dir` above, not a same-file call, so
+        // it is that rule's limit (m). The guard is real; the coverage is not
+        // claimed.
+        if (!SLICE_ID_PATTERN.test(sliceId)) {
+            console.warn(`loadContractsForSlices: skipping invalid slice id ${JSON.stringify(sliceId)} (must be a single filename segment)`);
+            continue;
+        }
         const file = join(dir, `${sliceId}.json`);
         if (!existsSync(file))
             continue;

package/dist/cli/commands/web-commands.js

@@ -161,7 +161,14 @@ export async function runWebOp(io, op, args, asJson) {
             return;
         }
         const info = await ensureDaemon(projectRoot, sessionId);
-        const response = await new WebDaemonClient(info).call(op, { ...opArgs, dispatchId: dispatchId(), projectRoot, sessionId }, OP_TIMEOUT_MS);
+        // The daemon reads `projectRoot` back from `daemon.json` — the record it
+        // itself wrote — and that round-trip is the only path that survives the
+        // macOS `/var` <-> `/private/var` symlink: the writer's prefix may not
+        // match `projectRoot` resolved from `process.cwd()` (the kernel resolves
+        // symlinks on `chdir`), and the integration test asserts on that exact
+        // round-tripped value.
+        const daemonProjectRoot = info.projectRoot;
+        const response = await new WebDaemonClient(info).call(op, { ...opArgs, dispatchId: dispatchId(), projectRoot: daemonProjectRoot, sessionId }, OP_TIMEOUT_MS);
         if (!response.ok || response.data === null) {
             const code = safeDaemonCode(response.code);
             // The daemon no longer downloads (R3), so "the browser is not installed"

package/dist/cli/commands/workflow-lifecycle-commands.d.ts

@@ -60,4 +60,10 @@ export interface WorkflowTerminalizeOptions {
     readonly requireConsumed?: boolean;
     readonly json?: boolean;
 }
+/**
+ * The literal that means "no session could be resolved". Kept as a named
+ * constant because three call sites now have to ASK whether resolution
+ * failed rather than consume the value as if it were an id.
+ */
+export declare const UNKNOWN_SESSION_ID = "unknown-sid";
 export declare function registerWorkflowLifecycleCommand(parent: Command, io: ProgramIO): void;

package/dist/cli/commands/workflow-lifecycle-commands.js

@@ -9,6 +9,8 @@
 import { fail, ok, getErrorMessage } from 'peaks-loop-shared/result';
 import { addJsonOption, printResult } from '../cli-helpers.js';
 import { resolveCallerId } from '../../services/session/resolve-caller-id.js';
+import { findProjectRoot } from '../../services/config/config-safety.js';
+import { getCurrentSessionId } from '../../services/skills/skill-presence-service.js';
 import { initWorkflow, terminalizeWorkflow, } from '../../services/workflow/workflow-presence-lifecycle.js';
 import { readGraph, emptyGraph } from '../../services/workflow/workflow-graph-store.js';
 import { WORKFLOW_ID_REGEX, TERMINAL_REASONS } from '../../services/workflow/workflow-graph-types.js';
@@ -26,8 +28,62 @@ function deriveCallerId() {
 function deriveProjectRoot(options) {
     return options.project ?? process.cwd();
 }
+/**
+ * The literal that means "no session could be resolved". Kept as a named
+ * constant because three call sites now have to ASK whether resolution
+ * failed rather than consume the value as if it were an id.
+ */
+export const UNKNOWN_SESSION_ID = 'unknown-sid';
+/**
+ * Resolve the session id for every `workflow *` command.
+ *
+ * Tier order (matches the idiom every other command family in this CLI
+ * already uses — see `job-commands.ts:85`, `container-commands.ts:138`):
+ *
+ *   1. `--session-id <sid>`             — explicit wins
+ *   2. `PEAKS_SESSION_ID` env var       — scripted / sub-process callers
+ *   3. `getCurrentSessionId(projectRoot)` — this caller's OWN binding
+ *      (`callers/<callerId>.json`) falling back to the project-global
+ *      `.peaks/_runtime/session.json`, the same resolver `peaks session
+ *      info --active` and `peaks session checkpoint` use
+ *   4. `unknown-sid`                    — nothing is bound
+ *
+ * Tier 3 was MISSING until 2026-09-15 (S6), and its absence is the whole
+ * defect: `workflow init` resolved on tiers 1–2 only, so with no flag and no
+ * env var it wrote the graph into `.peaks/_runtime/unknown-sid/graphs/`
+ * regardless of what the binding file said. `peaks workflow node prepare`
+ * then ran under the CORRECT session dir and reported `PEAKS_GRAPH_NOT_FOUND`
+ * — the graph it was asking for had been written one bucket over. The bucket
+ * accumulated artifacts from at least 4 distinct caller ids between 2026-09-01
+ * and 2026-09-15, i.e. it had never worked for anyone.
+ *
+ * The same prior-art sweep (`.peaks/memory/archived/2026-06-26-unknown-sid-root-cause.md`)
+ * converted six inline `?? 'unknown-sid'` sites to this 4-tier chain;
+ * `workflow-lifecycle-commands.ts` was missed. This is that site.
+ *
+ * The project root passed to tier 3 goes through the same `findProjectRoot`
+ * walk `session info` uses, so a command run from a SUBDIRECTORY of the
+ * project resolves the project's binding instead of `cwd`'s (which has none).
+ */
 function deriveSessionId(options) {
-    return options.sessionId ?? process.env.PEAKS_SESSION_ID ?? 'unknown-sid';
+    if (typeof options.sessionId === 'string' && options.sessionId.length > 0)
+        return options.sessionId;
+    const fromEnv = process.env.PEAKS_SESSION_ID;
+    if (typeof fromEnv === 'string' && fromEnv.length > 0)
+        return fromEnv;
+    return getCurrentSessionId(findProjectRoot(options.project ?? process.cwd()) ?? (options.project ?? process.cwd())) ?? UNKNOWN_SESSION_ID;
+}
+/**
+ * Tier 3 resolving to `unknown-sid` means NO session is bound at all. A
+ * `workflow` subcommand that WRITES must fail loudly on that rather than
+ * create a bucket named after a failure — `graph list` already does (see its
+ * `PEAKS_SESSION_NOT_BOUND` guard below); `init` did not.
+ */
+function buildSessionNotBoundEnvelope(sessionId, projectRoot) {
+    return fail('workflow.init', 'PEAKS_SESSION_NOT_BOUND', `No peaks session is bound for '${projectRoot}' (derived session id '${sessionId}'): --session-id, PEAKS_SESSION_ID and the project binding are all absent.`, { workflowId: null }, [
+        'Run `peaks workspace init --project <p>` to bind a session, then re-run.',
+        'Or pass `--session-id <sid>` explicitly.',
+    ]);
 }
 export function registerWorkflowLifecycleCommand(parent, io) {
     // Reuse the existing `workflow` parent (created by `registerWorkflowCommands`)
@@ -46,8 +102,13 @@ export function registerWorkflowLifecycleCommand(parent, io) {
         const asJson = options.json === true;
         try {
             const callerId = deriveCallerId();
-            const sessionId = deriveSessionId(options);
             const projectRoot = deriveProjectRoot(options);
+            const sessionId = deriveSessionId(options);
+            if (sessionId === UNKNOWN_SESSION_ID) {
+                printResult(io, buildSessionNotBoundEnvelope(sessionId, projectRoot), asJson);
+                process.exitCode = 1;
+                return;
+            }
             const workflowId = options.workflowId ?? `wf-${Date.now().toString(36)}`;
             if (!WORKFLOW_ID_REGEX.test(workflowId)) {
                 throw new Error(`workflowId shape invalid: ${workflowId}`);
@@ -120,7 +181,7 @@ export function registerWorkflowLifecycleCommand(parent, io) {
         const asJson = options.json === true;
         try {
             const sessionId = deriveSessionId(options);
-            if (!sessionId || sessionId === 'unknown-sid') {
+            if (sessionId === UNKNOWN_SESSION_ID) {
                 throw new Error('PEAKS_SESSION_NOT_BOUND: no session id');
             }
             const result = { envelopeVersion: '4.0.8', sessionId, graphs: [] };

package/dist/services/adapter/adapter.d.ts

@@ -1,3 +1,33 @@
+/**
+ * ⚠ DEAD CODE — NOT THE LIVE VENDOR LAYER, AND NOT THE LIVE IDE LAYER.
+ *
+ * Three things in this repo are named `<Vendor>Adapter`, and only one of
+ * them is live. Read this table before importing anything from here:
+ *
+ *   1. `src/services/runtime/vendors/<vendor>.ts`
+ *      → `class CodexAdapter implements VendorAdapter` (runtime detect +
+ *        compact). LIVE — wired by `RuntimeService`'s built-in list. This is
+ *        the one a reader looking for "the codex adapter" wants.
+ *   2. `packages/peaks-loop-internal-runtime/src/vendor/<vendor>-adapter.ts`
+ *      → a second `CodexAdapter`, different surface (binary / headlessArgs /
+ *        parseStatusLine / detectInstalled) for the dispatched-sub-agent
+ *        runtime. LIVE — exported by that package's public index.
+ *   3. THIS FILE'S SIBLINGS — `claude-adapter.ts` / `codex-adapter.ts` /
+ *        `copilot-adapter.ts` + `auto-adapter.ts`.
+ *      → **UNREFERENCED.** Zero importers in `src/`, `tests/`, `packages/`
+ *        or `scripts/`. Every method throws `ADAPTER_NOT_IMPLEMENTED`; the
+ *        one exception, `detect()` on the codex/copilot pair, is a hardcoded
+ *        `return false`. `peaks skill adapter list` (the only CLI surface
+ *        that names these) does not read them — it returns a literal array.
+ *
+ * The three layers diverged from a single planned skill-adapter surface and
+ * were never reconciled. These placeholder files are kept because they mark
+ * intent for unimplemented work; they are NOT kept because anything uses
+ * them. If you are here to implement them, the decision you actually need is
+ * which of layers 1–3 survives — see
+ * `tests/unit/runtime/vendor-adapter-layer.test.ts`, which pins which layer
+ * is live and fails the moment that stops being true.
+ */
 export interface AdapterSegment {
     name: string;
     skillMd: string;