peaks-loop 4.0.46 → 4.0.48

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

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { isUnsafePathInput } from '../../shared/path-safety.js';
 import { resolveWorkflow, planWorkflow, planWorkflowRun } from '../../services/workflow/workflow-loader.js';
 import { dispatchEvaluator } from '../../services/loop/evaluator-dispatcher.js';
 import { DEFAULT_MONOTONIC_THRESHOLD } from '../../services/loop/monotonic-guard.js';
@@ -165,6 +166,14 @@ 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.
+                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;
+                }
                 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);
@@ -475,6 +484,12 @@ 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.
+    if (isUnsafePathInput(sid)) {
+        throw new Error(`Invalid session id: ${sid} (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/perf-audit-commands.js

@@ -46,6 +46,7 @@ export function registerPerfAuditCommands(program, io) {
         .option('--project <path>', 'project root (default: cwd)')).action((options) => {
         const projectRoot = options.project ?? process.cwd();
         const sid = options.sid;
+        const rid = options.rid;
         if (sid === undefined || sid.length === 0) {
             printResult(io, fail('perf-audit.detect', 'SID_REQUIRED', 'session id (--sid) is required for perf-audit.detect', { state: 'sid-missing' }, ['Pass --sid <session-id> (e.g. 2026-06-27-session-...)', 'Run `peaks session info --active --json` to find the active sid.']), options.json);
             process.exitCode = 1;
@@ -55,6 +56,7 @@ export function registerPerfAuditCommands(program, io) {
             const detect = detectPerfAudit({
                 projectRoot,
                 sessionId: sid,
+                ...(rid !== undefined ? { requestId: rid } : {}),
             });
             const envelope = detect.state === 'ready'
                 ? ok('perf-audit.detect', detect, [...detect.warnings], [...detect.nextActions])

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

@@ -33,6 +33,7 @@ import { spawn } from 'node:child_process';
 import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, unlinkSync } from 'node:fs';
 import { join, dirname, resolve } from 'node:path';
 import { resolveCanonicalProjectRoot } from '../../services/config/config-service.js';
+import { isUnsafePathInput } from '../../shared/path-safety.js';
 import { getErrorMessage } from '../cli-helpers.js';
 import { runBrowserAction } from '../../services/qa/browser-wrapper-service.js';
 export const DEFAULT_PORT = 8931;
@@ -43,6 +44,17 @@ export function playwrightSessionsDir(projectRoot) {
     return join(projectRoot, '.peaks', '_runtime', PLAYWRIGHT_SESSIONS_DIR);
 }
 export function sessionFilePath(projectRoot, terminalId) {
+    // Terminal-id axis. The derived id is already sanitised (`deriveTerminalId`),
+    // but `--terminal` is caller-supplied and reaches this join unsanitised.
+    // Measured (repair cycle 1, item 1): `playwright stop --terminal ../../../../X`
+    // read a session record planted OUTSIDE the project root, sent SIGTERM to the
+    // pid it named, unlinked that file, and returned `ok: true` — arbitrary
+    // process termination plus an arbitrary file delete, one flag away. This is
+    // the join every reader/writer of a session record goes through, so this is
+    // where the invariant lives.
+    if (isUnsafePathInput(terminalId)) {
+        throw new Error(`Invalid terminal id: ${terminalId} (must be a single path segment)`);
+    }
     return join(playwrightSessionsDir(projectRoot), `${terminalId}.json`);
 }
 /**
@@ -144,7 +156,8 @@ export function spawnPlaywrightMcp(port, browser, userDataDir, projectRoot) {
         cwd: projectRoot,
         env: process.env,
         stdio: 'ignore',
-        detached: true
+        detached: true,
+        windowsHide: true
     });
     return { pid: child.pid, child };
 }

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

@@ -44,7 +44,7 @@ export function registerPrdCommands(program, io) {
     // peaks prd handoff init
     addJsonOption(handoff
         .command('init')
-        .description('Initialize an immutable handoff: sha256(body) → frontmatter → write to .peaks/_runtime/<sid>/prd/handoff.md')
+        .description('Initialize an immutable handoff: sha256(body) → frontmatter → write to .peaks/_runtime/<sid>/prd/handoff-<rid>.md')
         .requiredOption('--rid <request-id>', 'request id (e.g. 001-v2-11-cc-group-b)')
         .requiredOption('--sid <session-id>', 'session id (e.g. 2026-06-26-session-a28d69)')
         .requiredOption('--body <body>', 'handoff body markdown, or @<file> to read from disk')

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

@@ -29,6 +29,7 @@ import { join, resolve } from 'node:path';
 import { addJsonOption, printResult } from '../cli-helpers.js';
 import { fail, ok } from 'peaks-loop-shared/result';
 import { archiveScreenshots } from '../../services/qa/screenshot-archive-service.js';
+import { isUnsafePathInput } from '../../shared/path-safety.js';
 import { getSessionId } from '../../services/session/session-manager.js';
 import { BrowserRestartDetector } from '../../services/qa/browser-restart-detector.js';
 import { BrowserEventLogger } from '../../services/qa/browser-event-logger.js';
@@ -68,6 +69,12 @@ async function ensureContextForQa(goal, project, sid) {
 }
 export const DEFAULT_MAX_BROWSER_RESTARTS = 3;
 export function runQaSlice(input) {
+    // Sid axis: this is the join for `qa/browser-events.jsonl`. The `qa gate run`
+    // action guards before calling in, but the function is exported for tests and
+    // states its own contract at the join.
+    if (isUnsafePathInput(input.sessionId)) {
+        throw new Error(`Invalid session id: ${input.sessionId} (must be a single path segment)`);
+    }
     const detector = new BrowserRestartDetector({
         maxRestarts: input.maxRestarts,
         enabled: input.detectorEnabled
@@ -221,6 +228,15 @@ export function registerQaCommands(program, io) {
             // when the user did not supply one.
             const qaProject = options.project;
             const qaSid = options.sessionId ?? 'ad-hoc';
+            // Sid axis. `--session-id` reaches three consumers below — the context
+            // pre-build, `loadMutReport`, and `runQaSlice`'s
+            // `qa/browser-events.jsonl` join — so one guard at resolution covers all
+            // three. (`peaks qa archive-screenshots` has its own, separate join.)
+            if (isUnsafePathInput(qaSid)) {
+                printResult(io, fail('qa.gate', 'INVALID_SESSION_ID', `Invalid session id: ${qaSid} (must be a single path segment)`, { provided: qaSid }, ['Pass a session id that is a single path segment']), options.json);
+                process.exitCode = 1;
+                return;
+            }
             await ensureContextForQa('qa gate run', qaProject, qaSid);
             // Plan 2 / Task 8 — load peaks-mut's report (MUT.sig) if present.
             // Returns null when peaks-mut was not run; the gate treats that
@@ -289,6 +305,12 @@ export function registerQaCommands(program, io) {
         try {
             const projectRoot = resolve(options.project);
             const sid = options.sessionId?.trim() || getSessionId(projectRoot) || 'ad-hoc';
+            // Sid axis. Guarded after resolution so the flag value and the session
+            // binding are both covered. `archiveScreenshots` cannot do this itself:
+            // it only ever sees a fully-resolved `targetDir`.
+            if (isUnsafePathInput(sid)) {
+                throw new Error(`Invalid session id: ${sid} (must be a single path segment)`);
+            }
             const targetDir = join(projectRoot, '.peaks', '_runtime', sid, 'qa', 'screenshots');
             const envelope = archiveScreenshots({ sourceDir: options.source, targetDir });
             printResult(io, ok('qa.archive-screenshots', envelope, [], envelope.moved.length === 0

package/dist/cli/commands/reinject-command.d.ts

@@ -0,0 +1,72 @@
+/**
+ * rid `2026-09-13-a2-post-compact-reinject` —
+ * `peaks session reinject --project <path>`.
+ *
+ * The transport for `buildPostCompactReinjectionCard`. A Claude Code
+ * `SessionStart` hook (installed by `peaks hooks install`, matcher `compact`)
+ * runs this and Claude Code adds its stdout to the context — which is the
+ * whole mechanism by which the engineering state comes back after a
+ * compaction. See `src/services/context/post-compact-reinjection.ts` for what
+ * the card says and why it has a byte budget.
+ *
+ * THE ONE THING THIS FILE HAS TO GET RIGHT
+ *
+ * stdout IS context here. Every other peaks command treats stdout as a
+ * channel for a human or a JSON consumer; this one's stdout is pasted in
+ * front of the model as though it were something peaks-loop meant to say.
+ * Two consequences, and both are the reason the code below looks the way it
+ * does:
+ *
+ *   1. The card is printed VERBATIM — no `printResult`, no envelope, no
+ *      `next:` lines, no JSON on the card path. Anything else would be
+ *      injected too, and a `{"ok":true,...}` blob in the context is noise the
+ *      model then has to interpret.
+ *   2. A FAILURE PRINTS NOTHING. Not an error, not a warning, not a hint. An
+ *      error message on stdout would be injected into the context as a fact,
+ *      and a model that reads `REINJECT_FAILED: project root must be
+ *      canonical` in its own context has been handed a false problem to solve
+ *      mid-slice. So every failure path exits 0 with empty stdout, and the
+ *      reason is reported only through `--json` (which the hook never passes).
+ *      This is `failure-soft` for a SessionStart hook: the session must start
+ *      whether or not there is any state to re-inject.
+ *
+ * `--json` exists for the human/diagnostic path — `peaks session reinject
+ * --json` is how you inspect what the hook would inject without reading a
+ * transcript. It is deliberately NOT what the hook runs.
+ */
+import type { Command } from 'commander';
+import type { ProgramIO } from '../cli-helpers.js';
+import { buildPostCompactReinjectionCard } from '../../services/context/post-compact-reinjection.js';
+export type ReinjectOptions = {
+    project: string;
+    json?: boolean;
+    budgetBytes?: string;
+};
+/** Why no card was produced. Reported through `--json` only. */
+export type ReinjectSkipReason = 'empty-project' | 'invalid-project-root' | 'unreadable-project-root';
+export type ReinjectResult = {
+    readonly ok: true;
+    readonly card: ReturnType<typeof buildPostCompactReinjectionCard>;
+} | {
+    readonly ok: false;
+    readonly reason: ReinjectSkipReason;
+    readonly message: string;
+};
+/**
+ * Pure-ish action body, exported so tests can drive it with inputs Commander
+ * would mangle (trailing NUL bytes, whitespace-only paths). Never throws and
+ * never writes to stdout itself — `runReinjectAction` is the IO edge.
+ */
+export declare function buildReinjectResult(opts: ReinjectOptions): ReinjectResult;
+/**
+ * The IO edge. Returns the process exit code so callers (CLI path or test
+ * path) apply it uniformly. NEVER calls `process.exit`.
+ *
+ * Both branches return 0 on the failure path — see this file's header. The
+ * only way a caller sees `exitCode: 1` is a bug in the `--json` serializer
+ * itself, and even that is caught.
+ */
+export declare function runReinjectAction(opts: ReinjectOptions, io: ProgramIO): {
+    exitCode: 0 | 1;
+};
+export declare function registerReinjectCommand(program: Command, io: ProgramIO): void;

package/dist/cli/commands/reinject-command.js

@@ -0,0 +1,174 @@
+/**
+ * rid `2026-09-13-a2-post-compact-reinject` —
+ * `peaks session reinject --project <path>`.
+ *
+ * The transport for `buildPostCompactReinjectionCard`. A Claude Code
+ * `SessionStart` hook (installed by `peaks hooks install`, matcher `compact`)
+ * runs this and Claude Code adds its stdout to the context — which is the
+ * whole mechanism by which the engineering state comes back after a
+ * compaction. See `src/services/context/post-compact-reinjection.ts` for what
+ * the card says and why it has a byte budget.
+ *
+ * THE ONE THING THIS FILE HAS TO GET RIGHT
+ *
+ * stdout IS context here. Every other peaks command treats stdout as a
+ * channel for a human or a JSON consumer; this one's stdout is pasted in
+ * front of the model as though it were something peaks-loop meant to say.
+ * Two consequences, and both are the reason the code below looks the way it
+ * does:
+ *
+ *   1. The card is printed VERBATIM — no `printResult`, no envelope, no
+ *      `next:` lines, no JSON on the card path. Anything else would be
+ *      injected too, and a `{"ok":true,...}` blob in the context is noise the
+ *      model then has to interpret.
+ *   2. A FAILURE PRINTS NOTHING. Not an error, not a warning, not a hint. An
+ *      error message on stdout would be injected into the context as a fact,
+ *      and a model that reads `REINJECT_FAILED: project root must be
+ *      canonical` in its own context has been handed a false problem to solve
+ *      mid-slice. So every failure path exits 0 with empty stdout, and the
+ *      reason is reported only through `--json` (which the hook never passes).
+ *      This is `failure-soft` for a SessionStart hook: the session must start
+ *      whether or not there is any state to re-inject.
+ *
+ * `--json` exists for the human/diagnostic path — `peaks session reinject
+ * --json` is how you inspect what the hook would inject without reading a
+ * transcript. It is deliberately NOT what the hook runs.
+ */
+import { printResult } from '../cli-helpers.js';
+import { fail, ok } from 'peaks-loop-shared/result';
+import { resolveCanonicalProjectRootStrict, InvalidProjectRootError } from '../../services/config/config-safety.js';
+import { POST_COMPACT_REINJECTION_BYTE_BUDGET, buildPostCompactReinjectionCard } from '../../services/context/post-compact-reinjection.js';
+/**
+ * Parse `--budget-bytes`. Diagnostic only — the production ceiling is the
+ * constant. A value that is not a non-negative integer is REFUSED rather than
+ * coerced, because a coerced budget would silently change what the card
+ * proves (`--budget-bytes 4KiB` becoming `NaN` and then the default would
+ * report a full card while the caller believed they had constrained it).
+ */
+function parseBudget(raw) {
+    if (raw === undefined)
+        return { ok: true, value: null };
+    const parsed = Number(raw);
+    if (!Number.isInteger(parsed) || parsed < 0)
+        return { ok: false };
+    return { ok: true, value: parsed };
+}
+/**
+ * Pure-ish action body, exported so tests can drive it with inputs Commander
+ * would mangle (trailing NUL bytes, whitespace-only paths). Never throws and
+ * never writes to stdout itself — `runReinjectAction` is the IO edge.
+ */
+export function buildReinjectResult(opts) {
+    if (!opts.project || opts.project.trim() === '') {
+        return {
+            ok: false,
+            reason: 'empty-project',
+            message: '--project <path> is required and must be non-empty'
+        };
+    }
+    let projectRoot;
+    try {
+        projectRoot = resolveCanonicalProjectRootStrict(opts.project);
+    }
+    catch (error) {
+        if (error instanceof InvalidProjectRootError) {
+            return {
+                ok: false,
+                reason: 'invalid-project-root',
+                message: `--project is not a usable project root (${error.reason})`
+            };
+        }
+        return {
+            ok: false,
+            reason: 'unreadable-project-root',
+            message: error instanceof Error ? error.message : String(error)
+        };
+    }
+    const budget = parseBudget(opts.budgetBytes);
+    if (!budget.ok) {
+        return {
+            ok: false,
+            reason: 'invalid-project-root',
+            message: `--budget-bytes must be a non-negative integer, got ${String(opts.budgetBytes)}`
+        };
+    }
+    const card = buildPostCompactReinjectionCard({
+        projectRoot,
+        ...(budget.value !== null ? { budgetBytes: budget.value } : {})
+    });
+    return { ok: true, card };
+}
+/**
+ * The IO edge. Returns the process exit code so callers (CLI path or test
+ * path) apply it uniformly. NEVER calls `process.exit`.
+ *
+ * Both branches return 0 on the failure path — see this file's header. The
+ * only way a caller sees `exitCode: 1` is a bug in the `--json` serializer
+ * itself, and even that is caught.
+ */
+export function runReinjectAction(opts, io) {
+    let result;
+    try {
+        result = buildReinjectResult(opts);
+    }
+    catch (error) {
+        result = {
+            ok: false,
+            reason: 'unreadable-project-root',
+            message: error instanceof Error ? error.message : String(error)
+        };
+    }
+    if (opts.json === true) {
+        if (!result.ok) {
+            printResult(io, fail('session.reinject', `REINJECT_SKIPPED_${result.reason.replace(/-/g, '_').toUpperCase()}`, result.message, {
+                project: opts.project
+            }, []), true);
+            // A skipped card is a legitimate answer, not a failed command: the hook
+            // that runs this must never report a non-zero exit to the harness.
+            return { exitCode: 0 };
+        }
+        const card = result.card;
+        printResult(io, ok('session.reinject', {
+            sessionId: card.sessionId,
+            budgetBytes: card.budgetBytes,
+            bytes: card.bytes,
+            emittedRanks: card.emittedRanks,
+            droppedRanks: card.droppedRanks,
+            unresolved: card.unresolved,
+            // The payload itself, so a caller can read it without re-running.
+            card: card.text
+        }), true);
+        return { exitCode: 0 };
+    }
+    // The card path — the one the hook uses. Verbatim, and nothing on failure.
+    if (!result.ok)
+        return { exitCode: 0 };
+    if (result.card.text.length > 0)
+        io.stdout(result.card.text);
+    return { exitCode: 0 };
+}
+export function registerReinjectCommand(program, io) {
+    // Reuse the `session` commander group registered by the auto-registration
+    // pass, exactly as `registerPrimerCommand` does — `program.command('session
+    // reinject')` would register a single literal command name instead of a
+    // child of the group, and creating a second `session` group throws.
+    const session = program.commands.find((c) => c.name() === 'session');
+    if (!session) {
+        throw new Error('registerReinjectCommand: session group not registered; ' +
+            'autoRegisterAllCommands must run before registerReinjectCommand');
+    }
+    session
+        .command('reinject')
+        .description('Print the post-compact engineering-state card to stdout. ' +
+        'Run by the SessionStart hook (matcher: compact) so Claude Code re-injects it ' +
+        'as context after a compaction. Read-only; prints nothing (exit 0) when there is ' +
+        'no state to re-inject.')
+        .requiredOption('--project <path>', 'Project root (must be a non-empty canonical path)')
+        .option('--budget-bytes <n>', `Diagnostic override for the card's byte ceiling (default ${POST_COMPACT_REINJECTION_BYTE_BUDGET})`)
+        .option('--json', 'emit a JSON envelope { ok, data } to stdout instead of the card')
+        .action((opts) => {
+        const { exitCode } = runReinjectAction(opts, io);
+        if (exitCode !== 0)
+            process.exitCode = exitCode;
+    });
+}

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

@@ -10,6 +10,7 @@ import { fail, ok } from 'peaks-loop-shared/result';
 import { triggerBestPracticeScan } from '../../services/prd/best-practice-auto-trigger.js';
 import { refreshCodegraphAfterSlice, } from '../../services/codegraph/codegraph-autorefresh.js';
 import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
+import { isUnsafePathInput } from '../../shared/path-safety.js';
 /**
  * Slice 2026-09-10-context-audit-and-discipline (Slice B): bounded view of
  * `request list`. `count` is the true total; `names` carries
@@ -189,6 +190,13 @@ export function registerRequestCommands(program, io) {
             // non-existent .peaks/default/ dir and crashes with ENOENT, so when
             // --session-id is omitted we look the artifact up to find its session.
             let resolvedSessionId = options.sessionId;
+            // Sid axis: either arm of `resolvedSessionId` can be a caller-supplied
+            // `--session-id`, and it is joined into the bypass-counter root below.
+            if (resolvedSessionId !== undefined && isUnsafePathInput(resolvedSessionId)) {
+                printResult(io, fail('request.transition', 'INVALID_SESSION_ID', `Invalid session id: ${resolvedSessionId} (must be a single path segment)`, { provided: resolvedSessionId }, ['Pass a session id that is a single path segment']), options.json);
+                process.exitCode = 1;
+                return;
+            }
             if (resolvedSessionId === undefined) {
                 const { showRequestArtifact: showForSession } = await import('../../services/artifacts/request-artifact-service.js');
                 const located = await showForSession({ projectRoot: options.project, role, requestId });
@@ -277,9 +285,12 @@ export function registerRequestCommands(program, io) {
             // 0.85–0.95 pre-compact zone, write a checkpoint BEFORE the
             // transition completes and attach `preCompactCheckpoint: true` to
             // the response envelope. The LLM remains the decision-maker; this
-            // hook only surfaces the signal. The 0.95 red-line behaviour is
-            // unchanged — the existing auto-compact orchestrator continues to
-            // refuse dispatch at ratio ≥ 0.95.
+            // hook only surfaces the signal. At ratio ≥ 0.95 the auto-compact
+            // orchestrator ASKS the harness to compact and reports that it is
+            // waiting; it does not refuse anything, because peaks-loop has no
+            // executor for a running session and a refusal it cannot enforce only
+            // deadlocked the runner (slice
+            // 2026-09-13-auto-compact-trigger-ownership).
             let preCompact = null;
             // 2026-09-03-codegraph-autorefresh: auto codegraph re-index on the
             // RD → QA slice-complete boundary. Set only for rd:qa-handoff; null

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

@@ -408,7 +408,7 @@ export function registerScanCommands(program, io) {
             });
             const nextActions = [];
             if (report.gateAction === 'block') {
-                nextActions.push('Karpathy review file missing under scope=all. Per karpathy §1 Think Before Coding, create rd/karpathy-review.md before requesting qa-handoff.');
+                nextActions.push('Karpathy review file missing under scope=all. Per karpathy §1 Think Before Coding, the rd:qa-handoff gate wants rd/karpathy-review-<rid>.md; this scanner has no rid and reads only the back-compat name rd/karpathy-review.md, so it cannot go green on the rid-scoped name alone. `peaks request transition --state qa-handoff` is the authoritative gate.');
             }
             else if (report.gateAction === 'warn') {
                 nextActions.push(`Karpathy review emitted ${report.totalViolations} violation(s). Review the warnings and re-run after cleanup (karpathy §3 Surgical Changes).`);

package/dist/cli/commands/security-audit-commands.js

@@ -46,6 +46,7 @@ export function registerSecurityAuditCommands(program, io) {
         .option('--project <path>', 'project root (default: cwd)')).action((options) => {
         const projectRoot = options.project ?? process.cwd();
         const sid = options.sid;
+        const rid = options.rid;
         if (sid === undefined || sid.length === 0) {
             printResult(io, fail('security-audit.detect', 'SID_REQUIRED', 'session id (--sid) is required for security-audit.detect', { state: 'sid-missing' }, ['Pass --sid <session-id> (e.g. 2026-06-27-session-...)', 'Run `peaks session info --active --json` to find the active sid.']), options.json);
             process.exitCode = 1;
@@ -55,6 +56,7 @@ export function registerSecurityAuditCommands(program, io) {
             const detect = detectSecurityAudit({
                 projectRoot,
                 sessionId: sid,
+                ...(rid !== undefined ? { requestId: rid } : {}),
             });
             const envelope = detect.state === 'ready'
                 ? ok('security-audit.detect', detect, [...detect.warnings], [...detect.nextActions])

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

@@ -46,6 +46,7 @@ export function runShadcnInit(options) {
     const result = spawnSync(invocation.command, [...invocation.args], {
         cwd: options.cwd,
         encoding: 'utf8',
+        windowsHide: true,
         timeout: options.timeoutMs ?? 300_000,
         maxBuffer: 32 * 1024 * 1024,
         env: invocation.baseEnv

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

@@ -9,10 +9,15 @@
 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 { integrateSlices } from '../../services/slice/slice-integration.js';
 import { fail, ok } from 'peaks-loop-shared/result';
 import { addJsonOption, printResult } from '../cli-helpers.js';
 function loadContractsForSlices(projectRoot, sessionId, sliceIds) {
+    // Sid axis: `--session-id` reaches this join unmodified.
+    if (isUnsafePathInput(sessionId)) {
+        throw new Error(`Invalid session id: ${sessionId} (must be a single path segment)`);
+    }
     const dir = resolve(projectRoot, '.peaks', '_runtime', sessionId, 'dispatch', 'contracts');
     if (!existsSync(dir))
         return [];

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

@@ -6,11 +6,39 @@ import { renderStatusLine, resolveStatusLineCapability, } from '../../services/s
 import { applyStatusLineInstall, planStatusLineInstall, removeStatusLineInstall } from '../../services/skills/statusline-settings-service.js';
 import { readHookStatus as readSettingsStatus } from '../../services/skills/hooks-settings-service.js';
 import { detectIdeFromContext } from '../../services/ide/hook-translator.js';
+import { resolveIdeOptionHelp } from '../../services/ide/ide-registry.js';
 import { decideCompactStatusline, renderCompactStatusline, } from '../../services/compact-statusline/compact-statusline-service.js';
 import { getSessionIdCanonical } from '../../services/session/session-manager.js';
+import { writeHarnessWitness } from '../../services/context/harness-context-witness.js';
 const STDIN_READ_TIMEOUT_MS = 250;
-/** Read piped stdin if present; resolve quickly with '' when attached to a TTY. */
+/**
+ * Read piped stdin if present; resolve quickly with '' when attached to a TTY.
+ *
+ * `PEAKS_STATUSLINE_STDIN` is a test seam (same shape as the `PEAKS_HOOK_STDIN`
+ * seam in `gate-commands.ts`): the harness payload is the only channel that
+ * carries the harness's own context numbers, and a test that cannot supply one
+ * cannot verify the capture at all.
+ *
+ * WHY THIS SEAM IS ACCEPTABLE ON A DIFFERENT ARGUMENT (repair cycle 3). The
+ * precedent does not transfer by itself: `PEAKS_HOOK_STDIN` is defended in
+ * `.peaks/memory/peaks-hook-stdin-test-seam-pattern.md` because its payload
+ * still routes through the `enforceBashCommand` SOP gate. This payload is
+ * routed through no gate — it is PERSISTED verbatim as the record the witness
+ * guard then reads. So the compensating control is different, not absent: the
+ * record is observation-only and one-way. It reaches only `data` and the
+ * `warnings` / `nextActions` arrays of `peaks code context-now`; the compact
+ * `action` there is computed from `probe.ratio` alone, before and independently
+ * of the witness. A forged payload can therefore make the instrument lie —
+ * measured: a hand-written record yields a confident false `agree`, or a
+ * self-contradictory false `disagree` — and can do nothing else. What it cannot
+ * do is fire, block or delay a compact. Unconditional rather than NODE_ENV-
+ * gated, for the reason already recorded for the sibling seam.
+ */
 function readStdin() {
+    const override = process.env['PEAKS_STATUSLINE_STDIN'];
+    if (override !== undefined) {
+        return Promise.resolve(override);
+    }
     return new Promise((resolve) => {
         if (process.stdin.isTTY) {
             resolve('');
@@ -82,6 +110,18 @@ export async function runDefaultStatuslineRender(options, io) {
     // subprocess sat descheduled. Production callers omit the flag.
     const now = options.now !== undefined ? Number(options.now) : Date.now();
     const model = buildStatusLineModel(seeded, now);
+    // Slice 2026-09-13-statusline-window-witness (AC1): capture the harness's OWN
+    // context numbers from the payload it just piped in. The project root and the
+    // canonical session id are taken from the model that was JUST built, so the
+    // witness lands under the same session this render already resolved — a second
+    // resolution here could disagree with it. Never throws; never changes the
+    // rendered line.
+    writeHarnessWitness({
+        projectRoot: model.projectRoot,
+        sessionId: model.sessionId,
+        stdin,
+        nowMs: now,
+    });
     const capability = resolveStatusLineCapability({
         env: process.env,
         isTTY: Boolean(process.stdout.isTTY),
@@ -136,7 +176,7 @@ export function registerStatusLineCommands(program, io) {
         .description("Install the Peaks status line into the adapter's settings.json (project scope by default).")
         .option('--global', 'install into the user-level ~/.claude/settings.json instead of the project')
         .option('--project <path>', 'project root path (auto-detected from cwd when omitted)')
-        .option('--ide <id>', 'target adapter id (claude-code | trae); default: auto-detect from env/cwd')
+        .option('--ide <id>', resolveIdeOptionHelp())
         .option('--force', 'overwrite an existing non-Peaks statusLine entry')
         .option('--dry-run', 'show what would change without writing')).action((options) => {
         const scope = resolveScope(options);
@@ -173,7 +213,7 @@ export function registerStatusLineCommands(program, io) {
         .description("Remove the Peaks status line from the adapter's settings.json.")
         .option('--global', 'remove from the user-level ~/.claude/settings.json instead of the project')
         .option('--project <path>', 'project root path (auto-detected from cwd when omitted)')
-        .option('--ide <id>', 'target adapter id (claude-code | trae); default: auto-detect from env/cwd')).action((options) => {
+        .option('--ide <id>', resolveIdeOptionHelp())).action((options) => {
         const scope = resolveScope(options);
         const projectRoot = scope === 'project'
             ? (options.project ?? findProjectRoot(process.cwd()) ?? process.cwd())
@@ -194,7 +234,7 @@ export function registerStatusLineCommands(program, io) {
         .description('Report whether the Peaks status line is installed in the adapter settings.json.')
         .option('--global', 'inspect the user-level ~/.claude/settings.json instead of the project')
         .option('--project <path>', 'project root path (auto-detected from cwd when omitted)')
-        .option('--ide <id>', 'target adapter id (claude-code | trae); default: auto-detect from env/cwd')).action((options) => {
+        .option('--ide <id>', resolveIdeOptionHelp())).action((options) => {
         const scope = resolveScope(options);
         const projectRoot = scope === 'project'
             ? (options.project ?? findProjectRoot(process.cwd()) ?? process.cwd())

package/dist/cli/commands/sub-agent/detached.d.ts

@@ -15,14 +15,27 @@ export declare function dispatch(f: DispatchFlags): Promise<{
     ok: boolean;
     command: string;
     data: {
+        expectedCompletionSeconds: number;
+        orchestratorVisibleHint: string;
         mode: string;
         vendor: "claude" | "codex" | "copilot" | undefined;
         pid: number;
         dispatchRecordPath: string;
         maxConcurrent: number;
         noThrottle: boolean;
-        orchestratorVisibleHint: string;
+    } | {
         expectedCompletionSeconds: number;
+        spawnError: {
+            code: string | undefined;
+            message: string;
+        };
+        orchestratorVisibleHint: string;
+        mode: string;
+        vendor: "claude" | "codex" | "copilot" | undefined;
+        pid: number;
+        dispatchRecordPath: string;
+        maxConcurrent: number;
+        noThrottle: boolean;
     };
     warnings: string[];
     nextActions: string[];