peaks-loop 4.0.46 → 4.0.48

package/dist/cli/commands/sub-agent/detached.js

@@ -25,15 +25,26 @@ export async function dispatch(f) {
     if (f.noThrottle) {
         warnings.push('user-overrode: --no-throttle (peak runtime may exceed performance ceiling)');
     }
-    // rid-001 fix (F1 follow-up): the vendor CLI's ChildProcess is owned by
-    // peaks-loop-internal-runtime/dispatch.dispatchDetached, which now exposes
-    // it via DispatchResult.child. When the vendor binary is not on PATH the
-    // spawn fires an async 'error' event after dispatchDetached returns; we
-    // attach a per-child handler that swallows ENOENT (expected when the user
-    // hasn't installed claude/codex/copilot) and logs anything else. This is
-    // the canonical pattern (matches codegraph-process-runner.ts) — no more
-    // process-level uncaughtException swallow.
+    // The vendor CLI's ChildProcess is owned by
+    // peaks-loop-internal-runtime/dispatch.dispatchDetached, and this handler
+    // deliberately attaches NO 'error' listener to it.
+    //
+    // The handler that used to live here — an 'error' listener attached to
+    // `r.child` after the await — could never fire. `ProcessSupervisor.spawn`
+    // attaches its own 'error' + 'spawn' listeners in the SAME synchronous turn
+    // the child is created, and `dispatchDetached` awaits the resulting `settled` promise
+    // before returning. A missing binary is emitted on the nextTick queue,
+    // which drains BEFORE the awaiting caller resumes — so by the time this
+    // function holds `r`, the event has already been consumed and turned into
+    // the typed `spawnError` value below. Attaching a listener here is not
+    // merely late; it is unreachable by construction.
     const sid = process.env.PEAKS_SESSION_ID ?? 'local';
+    // `spawnError` is optional in this annotation, not because the value is
+    // uncertain but because the type this resolves against is: the workspace
+    // package's `types` entry points at `dist/index.d.ts`, and a `dist` built
+    // before the field was added does not declare it. Reading it defensively
+    // (`?? null`, below) is correct in both worlds; requiring it here would make
+    // the handler fail to compile against a stale build.
     let r;
     r = await dispatchDetached({
         sid,
@@ -46,15 +57,17 @@ export async function dispatch(f) {
         runtimeDir: `.peaks/_runtime/${sid}/detached`,
         subAgentsDir: `.peaks/_sub_agents/${sid}`,
     });
-    r.child?.on('error', (err) => {
-        if (err && err.code === 'ENOENT')
-            return;
-        // Non-ENOENT child errors are surfaced to stderr; the dispatch envelope
-        // has already been written and the detached child is fire-and-forget.
-        console.error('[peaks sub-agent dispatch] detached child error:', err);
-    });
+    // The launch outcome is the envelope's `ok`, not a footnote. A vendor CLI
+    // that is not installed is an expected environment, and the dispatch record
+    // already says `status: 'failed'`; the envelope used to say `ok: true` with
+    // `pid: -1` and a "⏳ Spawning …" hint, so the two surfaces disagreed and the
+    // orchestrator read a launch that never happened as a running one.
+    //
+    // `?? null` covers a DispatchResult-shaped value produced by a test double
+    // that omits the field; a real `dispatchDetached` always sets it.
+    const spawnError = r.spawnError ?? null;
     return {
-        ok: true,
+        ok: spawnError === null,
         command: 'sub-agent.dispatch.detached',
         data: {
             mode: 'detached',
@@ -63,14 +76,26 @@ export async function dispatch(f) {
             dispatchRecordPath: r.dispatchRecordPath,
             maxConcurrent,
             noThrottle: f.noThrottle ?? false,
-            orchestratorVisibleHint: `⏳ Spawning detached sub-agent via ${f.vendor ?? 'claude'}: rid=${f.requestId} (ETA ~60s)`,
+            ...(spawnError === null
+                ? {
+                    orchestratorVisibleHint: `⏳ Spawning detached sub-agent via ${f.vendor ?? 'claude'}: rid=${f.requestId} (ETA ~60s)`
+                }
+                : {
+                    spawnError: { code: spawnError.code, message: spawnError.message },
+                    orchestratorVisibleHint: `❌ Could not launch detached sub-agent via ${f.vendor ?? 'claude'}: rid=${f.requestId} (${spawnError.code})`
+                }),
             expectedCompletionSeconds: 60,
         },
         warnings,
-        nextActions: [
-            'Sub-agent runs as detached OS process. Status at .peaks/_runtime/<sid>/detached/<rid>/status.json',
-            'Use `peaks sub-agent list --mode detached` to monitor.',
-            'Run `peaks sub-agent cleanup --orphan` to reap orphan processes (RL-15: user-only decision).',
-        ],
+        nextActions: spawnError === null
+            ? [
+                'Sub-agent runs as detached OS process. Status at .peaks/_runtime/<sid>/detached/<rid>/status.json',
+                'Use `peaks sub-agent list --mode detached` to monitor.',
+                'Run `peaks sub-agent cleanup --orphan` to reap orphan processes (RL-15: user-only decision).'
+            ]
+            : [
+                `The ${f.vendor ?? 'claude'} CLI is not runnable from this shell (${spawnError.code}); nothing was launched and no sub-agent is running.`,
+                'Either install the vendor CLI on PATH, or re-dispatch without --mode detached to use the in-process path.'
+            ]
     };
 }

package/dist/cli/commands/sub-agent-shutdown-commands.js

@@ -2,9 +2,20 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { fail, getErrorMessage, ok } from 'peaks-loop-shared/result';
 import { getCurrentSessionId } from '../../services/skills/skill-presence-service.js';
+import { isUnsafePathInput } from '../../shared/path-safety.js';
 import { printResult } from '../cli-helpers.js';
 const REGISTRATIONS_FILE = 'service-registrations.json';
 function registrationsPath(input) {
+    // Both id axes reach this join. `dispatchId` is `--dispatch-id` (falling back
+    // to PEAKS_DISPATCH_ID), and `sessionId` is the session binding; neither was
+    // checked, and `register` writes through this path. Guarding the whole join
+    // rather than only the flag keeps the function's contract single-stated.
+    if (isUnsafePathInput(input.dispatchId)) {
+        throw new Error(`Invalid dispatch id: ${input.dispatchId} (must be a single path segment)`);
+    }
+    if (isUnsafePathInput(input.sessionId)) {
+        throw new Error(`Invalid session id: ${input.sessionId} (must be a single path segment)`);
+    }
     return join(input.projectRoot, '.peaks', '_runtime', input.sessionId, 'dispatch', input.dispatchId, REGISTRATIONS_FILE);
 }
 function readAll(file) {

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

@@ -203,7 +203,8 @@ export function runRunner(framework, argv, projectRoot, deps = {}) {
         const proc = spawnFn(resolution.command, resolution.args, {
             cwd: projectRoot,
             env: process.env,
-            stdio: ['ignore', 'pipe', 'pipe']
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true
         });
         let stdout = '';
         let stderr = '';

package/dist/cli/commands/verdict-aggregate-command.js

@@ -4,11 +4,51 @@ import { aggregateVerdict } from '../../services/verdict/verdict-aggregator.js';
 import { parseKarpathyEnvelope, parseMutEnvelope, parseQaEnvelope, parseSecurityEnvelope, parsePerfEnvelope, envelopesToAggregatorInput } from '../../services/verdict/envelopes.js';
 import { addJsonOption, printResult } from '../cli-helpers.js';
 import { fail, ok } from 'peaks-loop-shared/result';
-const SECURITY_REL = 'audit/security.md';
-const PERF_REL = 'audit/perf.md';
-const KARPATHY_REL = 'rd/karpathy-review.md';
+import { isUnsafePathInput } from '../../shared/path-safety.js';
+import { DEFAULT_REQUEST_TYPE } from '../../services/artifacts/artifact-prerequisites.js';
+import { REQUEST_ID_PATTERN } from '../../services/artifacts/request-artifact-service.js';
+import { contractEvidencePaths } from '../../services/workflow/pipeline-verify-gate-support.js';
+// Slice `2026-09-14-audit-artifact-rid-scoping`: the audit/review evidence
+// filenames carry the rid. The ridless names are the pre-rid locations and
+// stay readable during the back-compat window. `mut/` is NOT rid-scoped —
+// see `MUT_REPORT` in `artifact-prerequisites.ts`: no producer in the repo
+// can write a rid-scoped mut report, so probing a templated name here would
+// look for a file that no writer can create.
+//
+// The candidate lists are read FROM the contract — the same
+// `contractEvidencePaths()` the verify pipeline resolves with — rather than
+// hand-written here. Hand-written lists held two of the contract's THREE
+// tiers, so a session whose security/perf evidence sits at the oldest tier
+// (`rd/security-review.md`, `rd/perf-baseline.md` — the live shape of three
+// sessions on disk) reported `block` while `peaks request transition`
+// accepted the same tree, and the hint named a legacy location it had never
+// probed. One table, one answer.
 const MUT_REL = 'mut/mut-report.json';
 const QA_REL = 'qa/test-reports';
+/**
+ * The declared tiers for one artifact name, primary first. Probed by the name
+ * this command used before the rid-scoping (the table matches it as either
+ * the primary or a legacy tier), so the lookup survives the primary moving.
+ * `verdict aggregate` is request-type-agnostic and every fanout-trigger type
+ * declares these artifacts identically, so the default type's list is the
+ * full one; a name the table does not carry falls back to itself.
+ */
+function contractRels(probeName) {
+    return contractEvidencePaths('rd', 'qa-handoff', DEFAULT_REQUEST_TYPE, probeName) ?? [probeName];
+}
+const SECURITY_RELS = contractRels('audit/security.md');
+const PERF_RELS = contractRels('audit/perf.md');
+const KARPATHY_RELS = contractRels('rd/karpathy-review.md');
+/**
+ * Sources whose absence must not read as `pass`. `mut` is excluded on
+ * purpose: `MUT_REPORT` carries `backCompat: true`, so the contract itself
+ * treats a missing mut report as a warning rather than a gate failure.
+ */
+const REQUIRED_SOURCES = [
+    { key: 'security', source: 'security-audit', rels: SECURITY_RELS },
+    { key: 'perf', source: 'perf-audit', rels: PERF_RELS },
+    { key: 'karpathy', source: 'karpathy-reviewer', rels: KARPATHY_RELS }
+];
 export function registerVerdictAggregateCommands(program, io) {
     const verdict = program.command('verdict').description('Aggregate the 5 envelope sources feeding peaks-code verdict logic');
     addJsonOption(verdict
@@ -25,6 +65,27 @@ export function registerVerdictAggregateCommands(program, io) {
             process.exitCode = 1;
             return;
         }
+        // The rid SELECTS THE FILE, so it has to be one path segment. This is the
+        // repo's own request-id guard — the one `request-artifact-service.ts`
+        // applies to every request artifact and the reason `peaks workflow
+        // verify-pipeline` refuses a hostile rid — and it was not applied to the
+        // joins below. Measured before it was: `--from-rid
+        // '../../../../../../ONLY-HERE'` read `<project>/ONLY-HERE.md`, a file
+        // outside `.peaks/`, as this slice's security AND perf evidence.
+        if (!REQUEST_ID_PATTERN.test(rid)) {
+            printResult(io, fail('verdict.aggregate', 'RID_INVALID', `Invalid request id: ${rid} (expected letters, digits, dots, underscores, or dashes)`, {}, ['Pass the rid of the slice whose evidence you want aggregated, e.g. 2026-09-14-some-slug']), options.json);
+            process.exitCode = 1;
+            return;
+        }
+        // `--sid` names the session DIRECTORY and is the same axis. Reject
+        // anything that is not one safe path segment rather than pinning a
+        // format: the default here is the deliberately non-format value
+        // `default`.
+        if (isUnsafePathInput(sid)) {
+            printResult(io, fail('verdict.aggregate', 'SID_INVALID', `Invalid session id: ${sid} (must be a single path segment)`, {}, ['Pass the session id, e.g. 2026-09-14-session-abc123']), options.json);
+            process.exitCode = 1;
+            return;
+        }
         try {
             const sources = {
                 // v2.13.3 AC-1: use the canonical markdown-aware parser from
@@ -34,9 +95,9 @@ export function registerVerdictAggregateCommands(program, io) {
                 // returned `verdict: warn, violations: []` — the aggregator
                 // then produced `reasons: []` and `verdict: 'pass'` even when
                 // the audit had flagged HIGH violations.
-                security: readAudit(projectRoot, sid, SECURITY_REL, parseSecurityEnvelope),
-                perf: readAudit(projectRoot, sid, PERF_REL, parsePerfEnvelope),
-                karpathy: readAudit(projectRoot, sid, KARPATHY_REL, (m) => parseKarpathyEnvelope(m)),
+                security: readAudit(projectRoot, sid, rid, SECURITY_RELS, parseSecurityEnvelope),
+                perf: readAudit(projectRoot, sid, rid, PERF_RELS, parsePerfEnvelope),
+                karpathy: readAudit(projectRoot, sid, rid, KARPATHY_RELS, (m) => parseKarpathyEnvelope(m)),
                 mut: await readMut(projectRoot, sid),
                 qa: readQa(projectRoot, sid, rid)
             };
@@ -55,7 +116,26 @@ export function registerVerdictAggregateCommands(program, io) {
                 mut: sources.mut !== null ? 'present' : 'missing',
                 qa: sources.qa !== null ? 'present' : 'missing'
             };
-            printResult(io, ok('verdict.aggregate', { verdict: result.verdict, reasons: result.reasons, sources: sourceFlags }, [], []), options.json);
+            // Fail closed. `aggregateVerdict()` starts its top-level verdict at
+            // `'pass'`, so a source that could not be read simply never enters the
+            // input and the run reports green. Before this slice the bare paths
+            // were the ones the writers wrote; after it the writers moved and this
+            // reader did not — so a missing security or perf audit became a `pass`
+            // for the loop evaluator (`services/loop/evaluator-dispatcher.ts`). A
+            // guard that cannot read its input must not report success.
+            const missingRequired = REQUIRED_SOURCES.filter((entry) => sources[entry.key] === null);
+            const missingReasons = missingRequired.map((entry) => ({
+                source: entry.source,
+                sources: [entry.source],
+                signal: 'block',
+                kind: 'missing-evidence',
+                hint: `${entry.rels.map((rel) => rel.replace('<rid>', rid)).join(' | ')} could not be read under .peaks/_runtime/${sid}/`
+            }));
+            printResult(io, ok('verdict.aggregate', {
+                verdict: missingReasons.length > 0 ? 'block' : result.verdict,
+                reasons: [...missingReasons, ...result.reasons],
+                sources: sourceFlags
+            }, [], []), options.json);
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -64,12 +144,14 @@ export function registerVerdictAggregateCommands(program, io) {
         }
     });
 }
-function readAudit(projectRoot, sid, rel, parse) {
-    const path = join(projectRoot, '.peaks', '_runtime', sid, rel);
-    if (!existsSync(path))
-        return null;
-    const md = readFileSync(path, 'utf8');
-    return parse(md);
+function readAudit(projectRoot, sid, rid, rels, parse) {
+    // Canonical rid-scoped location first, then the pre-rid locations.
+    for (const rel of rels) {
+        const path = join(projectRoot, '.peaks', '_runtime', sid, rel.replace('<rid>', rid));
+        if (existsSync(path))
+            return parse(readFileSync(path, 'utf8'));
+    }
+    return null;
 }
 async function readMut(projectRoot, sid) {
     const path = join(projectRoot, '.peaks', '_runtime', sid, MUT_REL);

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

@@ -59,7 +59,7 @@ function detectHypervisor(requested) {
             break;
     }
     try {
-        const v = execSync(`${binary} --version`, { stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf8' });
+        const v = execSync(`${binary} --version`, { stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf8', windowsHide: true });
         if (requested === 'kvm' && !existsSync('/dev/kvm')) {
             return { ok: false, stderr: 'KVM kernel module not loaded (/dev/kvm absent)' };
         }
@@ -87,27 +87,27 @@ function spawnVmWithHypervisor(args) {
 </domain>`;
         const xmlPath = `${args.workdir}/.peaks-vm-${args.leaseId}.xml`;
         require('node:fs').writeFileSync(xmlPath, xml, 'utf8');
-        const out = execSync(`virsh create ${xmlPath}`, { cwd: args.workdir, stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf8' });
+        const out = execSync(`virsh create ${xmlPath}`, { cwd: args.workdir, stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf8', windowsHide: true });
         return { vmId: out.trim() };
     }
     if (args.hypervisor === 'hyperkit') {
-        const out = execSync(`hvftool create --image ${args.image} --mount ${args.mount}:/work --label peaks.leaseId=${args.leaseId} --label peaks.rid=${args.rid} --entrypoint sleep -- infinity`, { cwd: args.workdir, stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf8' });
+        const out = execSync(`hvftool create --image ${args.image} --mount ${args.mount}:/work --label peaks.leaseId=${args.leaseId} --label peaks.rid=${args.rid} --entrypoint sleep -- infinity`, { cwd: args.workdir, stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf8', windowsHide: true });
         return { vmId: out.trim() };
     }
     // hyperv: the hvc shim writes a vhdx + emits the new VM id.
-    const out = execSync(`hvc create --image ${args.image} --mount ${args.mount} --label peaks.leaseId=${args.leaseId} --label peaks.rid=${args.rid}`, { cwd: args.workdir, stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf8' });
+    const out = execSync(`hvc create --image ${args.image} --mount ${args.mount} --label peaks.leaseId=${args.leaseId} --label peaks.rid=${args.rid}`, { cwd: args.workdir, stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf8', windowsHide: true });
     return { vmId: out.trim() };
 }
 function destroyVmWithHypervisor(args) {
     try {
         if (args.hypervisor === 'kvm') {
-            execSync(`virsh destroy ${args.vmId}`, { stdio: ['ignore', 'pipe', 'pipe'] });
+            execSync(`virsh destroy ${args.vmId}`, { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
         }
         else if (args.hypervisor === 'hyperkit') {
-            execSync(`hvftool stop ${args.vmId}`, { stdio: ['ignore', 'pipe', 'pipe'] });
+            execSync(`hvftool stop ${args.vmId}`, { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
         }
         else {
-            execSync(`hvc stop ${args.vmId}`, { stdio: ['ignore', 'pipe', 'pipe'] });
+            execSync(`hvc stop ${args.vmId}`, { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
         }
         return true;
     }

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

@@ -420,7 +420,7 @@ export function registerWorkflowCommands(program, io) {
     // semantics, role-based auth).
     addJsonOption(workflow
         .command('skip')
-        .description('Skip specific gates for a request (RD/QA). Use --dry-run to preview without writing. Allowed gate names: QA / RD (phase shortcuts) or specific gate names (rd-request-exists, tech-doc, code-review, security-review, qa-request-exists, test-cases, test-report, security-findings, performance-findings). Three rules apply: (1) only docs/config/chore slices can skip; (2) skip is one-time per rid; (3) script callers must also pass --i-have-reviewed.')
+        .description('Skip specific gates for a request (RD/QA). Use --dry-run to preview without writing. Allowed gate names: QA / RD (phase shortcuts) or specific gate names (rd-request-exists, prd-handoff, bug-analysis, code-review, security-review, perf-baseline, qa-request-exists, test-cases, test-report). Three rules apply: (1) only docs/config/chore slices can skip; (2) skip is one-time per rid; (3) script callers must also pass --i-have-reviewed.')
         .requiredOption('--rid <rid>', 'request identifier')
         .requiredOption('--project <path>', 'project root path')
         .requiredOption('--gates <list>', 'comma-separated gate names (e.g. "QA" or "QA,slice-check" or "code-review,security-review")')

package/dist/cli/commands/workspace/init-command.js

@@ -22,7 +22,7 @@ import { initWorkspace, InvalidSessionIdError, ConflictingSessionError, LegacyCh
 // session-id-shaped directories at the `.peaks/_runtime/` sibling
 // level.
 import { ensureSessionWithRotation } from '../../../services/session/session-manager.js';
-import { resolveCanonicalProjectRoot } from '../../../services/config/config-service.js';
+import { resolveWritableProjectRoot, UnsafeProjectRootError } from '../../../services/config/config-safety.js';
 import { applyHookInstall, readHookStatus } from '../../../services/skills/hooks-settings-service.js';
 import { clearStalePresenceOnRotation } from '../../../services/skills/skill-presence-service.js';
 import { gcStalePresenceLeases } from '../../../services/skills/presence-lease-service.js';
@@ -69,7 +69,12 @@ export function registerWorkspaceInitCommand(workspace, io) {
             // (the same regression that produced prompt-project/.peaks/ in
             // the 5/27-5/29 sessions). When startPath is not inside any
             // git repo, the helper falls through to the cwd verbatim.
-            const projectRoot = resolveCanonicalProjectRoot(options.project);
+            // `resolveWritableProjectRoot` = `resolveCanonicalProjectRoot` plus the
+            // home-directory refusal. It has to be this one, and it has to run here:
+            // `ensureSessionWithRotation` below WRITES (it mints/binds a session), so
+            // a guard placed after it would leave a `.peaks/_runtime/` tree in the
+            // user's home even though the init was refused.
+            const projectRoot = resolveWritableProjectRoot(options.project);
             // Slice 018: outer-session-mismatch auto-rotation. When the
             // user did NOT pass --session-id explicitly, run
             // `ensureSessionWithRotation` so the binding is rotated on
@@ -408,6 +413,23 @@ export function registerWorkspaceInitCommand(workspace, io) {
             }, warningsForEnvelope, nextActions), options.json);
         }
         catch (error) {
+            if (error instanceof UnsafeProjectRootError) {
+                // A typed refusal, not a crash: "you are standing in your home
+                // directory, which is not a project" is a thing the caller can fix in
+                // one step, and the envelope has to say which directory was refused and
+                // what to pass instead. `WORKSPACE_INIT_FAILED` below would have buried
+                // it as an unexplained failure.
+                printResult(io, fail('workspace.init', 'UNSAFE_PROJECT_ROOT', error.message, {
+                    resolvedProjectRoot: error.projectRoot,
+                    projectOption: options.project ?? null
+                }, [
+                    'Pass --project <path-to-your-project> instead of a path that resolves to your home directory.',
+                    'This command creates .peaks/, .gitignore, .claude/settings.local.json and a codegraph index; none of those belong in $HOME.',
+                    'If you meant to initialize the current directory, cd into a project directory first — peaks will not write into the home directory itself.'
+                ]), options.json);
+                process.exitCode = 1;
+                return;
+            }
             if (error instanceof InvalidSessionIdError) {
                 printResult(io, fail('workspace.init', error.code, error.message, { sessionId: options.sessionId }, ['Use a date-prefixed kebab slug like 2026-05-25-add-user-auth']), options.json);
                 process.exitCode = 1;

package/dist/cli/commands/worktree-lease-commands.js

@@ -91,7 +91,7 @@ export function registerWorktreeLeaseCommands(auth, io) {
             // and authorize this very `git worktree add`; for Part 1 we still
             // require a current `peaks worktree auth grant` token to remain
             // consistent with the slice-027 hard gate contract.
-            execSync(`git worktree add "${wtPath}" -b "${branch}"`, { cwd: projectRoot, stdio: 'pipe', encoding: 'utf8' });
+            execSync(`git worktree add "${wtPath}" -b "${branch}"`, { cwd: projectRoot, stdio: 'pipe', encoding: 'utf8', windowsHide: true });
             atomicWriteJson(leaseFilePath(joinPathSession(projectRoot, sessionId), leaseId), lease);
             // Part 4.A: emit spawn metric (fire-and-forget; never blocks).
             emitLeaseEvent({
@@ -167,7 +167,7 @@ export function registerWorktreeLeaseCommands(auth, io) {
             // released.
             let gitWorktreeRemoveFailed = false;
             try {
-                execSync(`git worktree remove --force "${lease.path}"`, { cwd: projectRoot, stdio: 'pipe', encoding: 'utf8' });
+                execSync(`git worktree remove --force "${lease.path}"`, { cwd: projectRoot, stdio: 'pipe', encoding: 'utf8', windowsHide: true });
             }
             catch {
                 gitWorktreeRemoveFailed = true;
@@ -379,14 +379,14 @@ export function registerWorktreeLeaseCommands(auth, io) {
                     // already gone we still mark the lease gc.
                     let gitWorktreeRemoveFailed = false;
                     try {
-                        execSync(`git worktree remove --force "${updated.path}"`, { cwd: projectRoot, stdio: 'pipe', encoding: 'utf8' });
+                        execSync(`git worktree remove --force "${updated.path}"`, { cwd: projectRoot, stdio: 'pipe', encoding: 'utf8', windowsHide: true });
                     }
                     catch {
                         gitWorktreeRemoveFailed = true;
                     }
                     // `git worktree prune` clears any stale admin entries. Best-effort.
                     try {
-                        execSync('git worktree prune', { cwd: projectRoot, stdio: 'pipe', encoding: 'utf8' });
+                        execSync('git worktree prune', { cwd: projectRoot, stdio: 'pipe', encoding: 'utf8', windowsHide: true });
                     }
                     catch {
                         // ignore — prune is idempotent

package/dist/cli/index.js

@@ -1,7 +1,7 @@
 import { CommanderError } from 'commander';
 import { createProgram } from './program.js';
 import { getErrorMessage } from 'peaks-loop-shared/result';
-import { printErrorEnvelope } from './cli-helpers.js';
+import { printErrorEnvelope, printMissingRequiredOptionEnvelope, resolveInvokedCommandPath } from './cli-helpers.js';
 const defaultIo = {
     stdout: (text) => process.stdout.write(`${text}\n`),
     stderr: (text) => process.stderr.write(`${text}\n`)
@@ -29,8 +29,8 @@ const defaultIo = {
 const argv = process.argv.slice(2);
 const hasHelp = argv.some((arg) => arg === '--help' || arg === '-h');
 const firstPositional = argv.find((arg) => !arg.startsWith('-'));
+const program = createProgram();
 if (hasHelp && firstPositional !== undefined) {
-    const program = createProgram();
     const registered = new Set(program.commands.map((c) => c.name()));
     if (!registered.has(firstPositional)) {
         // Defer the check by 0ms so Commander's own help handler runs first
@@ -41,7 +41,7 @@ if (hasHelp && firstPositional !== undefined) {
         });
     }
 }
-createProgram().parseAsync(process.argv).catch((error) => {
+program.parseAsync(process.argv).catch((error) => {
     if (error instanceof CommanderError && error.code === 'commander.version') {
         return;
     }
@@ -59,6 +59,13 @@ createProgram().parseAsync(process.argv).catch((error) => {
         if (error.code === 'commander.help' || error.code === 'commander.helpDisplayed') {
             return;
         }
+        if (error.code === 'commander.missingMandatoryOptionValue') {
+            // See `printMissingRequiredOptionEnvelope` — the same builder backs the
+            // in-process test runner, so the envelope a test asserts is the envelope
+            // a user gets.
+            printMissingRequiredOptionEnvelope(defaultIo, resolveInvokedCommandPath(program, argv), getErrorMessage(error));
+            return;
+        }
         if (error.code === 'commander.missingArgument' || error.code === 'commander.unknownCommand' || error.code === 'commander.unknownOption') {
             // Emit a `COMMAND_NOT_FOUND` JSON envelope for the unknown-command
             // path. The error text already went to stderr via Commander's

package/dist/cli/program.js

@@ -17,6 +17,7 @@ import { registerWorkspaceCommands } from './commands/workspace-commands.js';
 import { registerSopCommands } from './commands/sop-commands.js';
 import { registerSkillVisibilityCommand } from './commands/skill-visibility.js';
 import { registerPrimerCommand } from './commands/primer-command.js';
+import { registerReinjectCommand } from './commands/reinject-command.js';
 import { applyRetention, cleanupEccCache } from '../services/log/retention.js';
 import { writeLogEntry, maybeWriteStderr } from '../services/log/logger.js';
 import { printSuperCommandCatalog } from './cli-helpers.js';
@@ -217,5 +218,9 @@ Run peaks (no arguments) for a quickstart. You likely want one of:
     // `program.command('session primer')` (that registers a single
     // literal command name, not a child of the session group).
     registerPrimerCommand(program, io);
+    // rid 2026-09-13-a2-post-compact-reinject: register `peaks session reinject`
+    // as a sibling child of the same `session` group. It is the transport for
+    // the SessionStart (matcher `compact`) hook's post-compaction card.
+    registerReinjectCommand(program, io);
     return program;
 }

package/dist/hooks/pre-tool-use-sub-agent.js

@@ -59,7 +59,7 @@ export function runHookGuardSubprocess(prompt) {
         'sub-agent-dispatch-guard',
         '--prompt', prompt,
         '--json'
-    ], { encoding: 'utf8' });
+    ], { encoding: 'utf8', windowsHide: true });
     if (result.status !== 0) {
         // Fallback: allow (don't block the dispatch on a guard subprocess failure).
         return {

package/dist/services/adapter/adapter-registry.js

@@ -53,7 +53,7 @@ class ProcessVendorAdapter {
         if (args.force === true)
             argv.push('--force');
         return new Promise((resolveRun) => {
-            const proc = spawn(this.binary, argv, { stdio: ['ignore', 'pipe', 'pipe'] });
+            const proc = spawn(this.binary, argv, { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
             let stdout = '';
             let stderr = '';
             proc.stdout.on('data', (chunk) => { stdout += chunk.toString('utf8'); });

package/dist/services/artifacts/artifact-prerequisites.d.ts

@@ -29,18 +29,36 @@ export type ArtifactPrerequisite = {
      */
     headingMustContain?: ReadonlyArray<string>;
     /**
-     * Slice v2.12.0 Group B Tier 5: optional legacy path that satisfies
-     * the same gate. When `relativePath` does not resolve on disk, the
-     * resolver tries this fallback path before reporting the prereq as
-     * missing. Use this for 1-minor-release back-compat windows where
-     * an old artifact location is still accepted alongside the new one.
-     * v2.13.0 should remove all `legacyRelativePath` entries.
+     * The immediately previous location of this artifact. When
+     * `relativePath` does not resolve on disk, the resolver tries this
+     * path before reporting the prereq as missing.
+     *
+     * This field is a published surface, not just a private hint:
+     * `verify-pipeline`'s `contractEvidencePaths()`
+     * (`src/services/workflow/pipeline-verify-gate-support.ts`) reads it
+     * to build its probe list, so it must keep meaning "the one path a
+     * previous release wrote". Do not repurpose it as a general list —
+     * add older tiers to `legacyRelativePaths` instead.
      *
      * Body checks (`mustContain` / `mustContainAny` /
      * `headingMustContain`) apply to whichever path resolved — the
-     * gate does not distinguish which path served the file.
+     * gate does not distinguish which path served the file. That is
+     * deliberate: a legacy hit must keep the gate open, or existing
+     * sessions would fail the transition on upgrade.
      */
     legacyRelativePath?: string;
+    /**
+     * Further, older locations, tried **in declared order** after
+     * `legacyRelativePath`. Slice `2026-09-14-audit-artifact-rid-scoping`
+     * added this because the two audit artifacts have a two-release
+     * history behind their rid-scoped path: the pre-rid-scoping
+     * `audit/security.md` (v2.12.0) and, behind it, the v2.11.x
+     * `rd/security-review.md`. Three sessions on disk
+     * (`2026-09-06-session-a87ca4`, `2026-09-10-session-528a63`,
+     * `2026-09-12-session-e37ef0`) hold their security evidence only at
+     * the last of those, so the oldest tier still has to resolve.
+     */
+    legacyRelativePaths?: ReadonlyArray<string>;
 };
 export type PrerequisiteCheckResult = {
     ok: boolean;
@@ -75,4 +93,17 @@ export type CheckPrerequisitesOptions = {
     requestType?: RequestType;
 };
 export declare function getPrerequisitesFor(role: RequestArtifactRole, newState: RequestArtifactState, requestType?: RequestType): ReadonlyArray<ArtifactPrerequisite>;
+/**
+ * The contract's BODY checks for one prerequisite, applied to `body`. Returns
+ * one human-readable message per failed check, empty when the body satisfies
+ * the contract.
+ *
+ * Exported because this contract has a SECOND enforcer: `peaks workflow
+ * verify-pipeline` probes the same table for the paths it checks
+ * (`pipeline-verify-gate-support.ts`), and a resolver that probed only
+ * `existsSync` passed files this function rejects — a guard laxer than the
+ * contract it claims to read. Both callers now share this one implementation,
+ * so the checker cannot drift from the table again.
+ */
+export declare function prerequisiteBodyViolations(prerequisite: ArtifactPrerequisite, body: string): string[];
 export declare function checkPrerequisites(options: CheckPrerequisitesOptions): Promise<PrerequisiteCheckResult>;