peaks-loop 4.0.54 → 4.1.1

package/dist/services/code/mode-gate-types.js

@@ -0,0 +1,66 @@
+/**
+ * `src/services/code/mode-gate-types.ts`
+ *
+ * The declaration surface of the D5 gate: the mode alias, the gated-step
+ * vocabulary, and the commit-boundary vocabulary with its regex matchers.
+ * Extracted verbatim from `mode-gate.ts` (wave 3, file-size cap campaign) so
+ * the gate module stays under the 300 raw-line cap. Mechanical move only — no
+ * decision logic lives here. `mode-gate.ts` imports and re-exports every name
+ * below, so importers keep resolving them from `mode-gate.js` unchanged.
+ *
+ * The hard-floor vocabulary deliberately does NOT live here:
+ * `feedback-promotion` certifies a layer-C rule by reading
+ * `HardFloorCategory` and `HARD_FLOOR_CATEGORIES` out of `mode-gate.ts`
+ * itself (see `promotion-artifact-evidence.ts`).
+ */
+export const CODE_MODES = ['full-auto', 'assisted', 'strict', '24h'];
+export const GATED_STEPS = [
+    'step-0.5-openspec-opt-in',
+    'step-0.6-audit-goal',
+    'step-0.7-resume-detection',
+    'step-1-mode-select',
+    'step-2.5-session-title',
+    'phase-2-prd-confirm',
+    'phase-3-swarm-gate-b',
+    'phase-6-qa-gate-d',
+    'phase-10-txt-memory-extract',
+    'step-n+1-final-review',
+    'frontend-only-mismatch',
+    'step-0.75-checkpoint-resume',
+    'standards-preflight'
+];
+export const COMMIT_BOUNDARY_ACTIONS = [
+    'git-push',
+    'git-tag',
+    'npm-publish',
+    'npm-install-global',
+    'peaks-global-install'
+];
+/**
+ * v2.15.0 slice 002 AC-4: regex matchers the LLM-side caller uses
+ * to flag a Bash command as a commit-boundary action. Centralised
+ * here so the test seam + the CLI wiring share one source of
+ * truth. Each entry is an anchored pattern matched against the
+ * user-invoked command (after commander / shell normalisation,
+ * before execution).
+ *
+ * Patterns intentionally cover the common canonical forms:
+ *
+ *   - `git-push`            → `git push`, `git push origin main`, `git push --tags`
+ *   - `git-tag`             → `git tag v2.15.0`, `git tag -a v2.15.0 -m ...`
+ *   - `npm-publish`         → `npm publish`, `npm publish --access public`
+ *   - `npm-install-global`  → `npm install -g <pkg>`, `npm i -g <pkg>`
+ *   - `peaks-global-install`→ `npm install -g peaks-loop`, `pnpm add -g peaks-loop`
+ *
+ * These are coarse — false positives are fine (worst case: a
+ * non-actionable command gets paused for confirmation; the user
+ * can confirm in one click). False negatives are NOT fine — a
+ * missed publish would violate the full-auto boundary.
+ */
+export const COMMIT_BOUNDARY_PATTERNS = {
+    'git-push': /\bgit\s+push\b/,
+    'git-tag': /\bgit\s+tag\b/,
+    'npm-publish': /\bnpm\s+(publish|pub)\b/,
+    'npm-install-global': /\bnpm\s+(install|i|add)\s+(-g|--global)\b/,
+    'peaks-global-install': /\b(peaks-loop)\b/
+};

package/dist/services/code/mode-gate.d.ts

@@ -19,9 +19,9 @@
  * Re-uses `SkillPresenceMode` from `skill-presence-service.ts` so the
  * 4 mode values stay in lockstep with the rest of the runtime.
  */
-import type { SkillPresenceMode } from '../skills/skill-presence-service.js';
-export type CodeMode = SkillPresenceMode;
-export declare const CODE_MODES: readonly CodeMode[];
+import { type CodeMode, type CommitBoundaryActionId, type GatedStepId } from './mode-gate-types.js';
+export { CODE_MODES, COMMIT_BOUNDARY_ACTIONS, COMMIT_BOUNDARY_PATTERNS, GATED_STEPS } from './mode-gate-types.js';
+export type { CodeMode, CommitBoundaryActionId, GatedStepId } from './mode-gate-types.js';
 export type HardFloorCategory = 'irreversible-external-side-effect' | 'authentication-credential' | 'multi-day-investment'
 /**
  * v2.15.0 slice 002 AC-4: actions that are past the user's
@@ -34,13 +34,6 @@ export type HardFloorCategory = 'irreversible-external-side-effect' | 'authentic
  */
  | 'commit-boundary-side-effect';
 export declare const HARD_FLOOR_CATEGORIES: readonly HardFloorCategory[];
-/**
- * The 14 SKILL.md AskUserQuestion sites mapped in the D5 memory's
- * "Inventory of unconditional confirmation gates" table. Each row
- * is the bare minimum needed to gate it through `shouldPauseAtGate`.
- */
-export type GatedStepId = 'step-0.5-openspec-opt-in' | 'step-0.6-audit-goal' | 'step-0.7-resume-detection' | 'step-0.55-1x-upgrade' | 'step-1-mode-select' | 'step-2.5-session-title' | 'phase-2-prd-confirm' | 'phase-3-swarm-gate-b' | 'phase-6-qa-gate-d' | 'phase-10-txt-memory-extract' | 'step-n+1-final-review' | 'frontend-only-mismatch' | 'step-0.75-checkpoint-resume' | 'standards-preflight';
-export declare const GATED_STEPS: readonly GatedStepId[];
 /**
  * Slice 2026-06-28-code-mode-bypass-fix: the kind of gate that
  * produced this decision. The LLM-side caller (peaks-code body) reads
@@ -74,6 +67,7 @@ export interface GateDecision {
 }
 export declare function isCodeMode(value: string): value is CodeMode;
 export declare function isHardFloorCategory(value: string): value is HardFloorCategory;
+export declare function isCommitBoundaryAction(value: string): value is CommitBoundaryActionId;
 /**
  * `true` when the current mode should auto-proceed (skip the
  * AskUserQuestion round-trip). Mirrors D5.a: "recommended = chosen
@@ -84,32 +78,6 @@ export declare function isHardFloorCategory(value: string): value is HardFloorCa
  * mode); `24h` replaces it as the second auto-proceed peer.
  */
 export declare function shouldAutoProceed(mode: CodeMode): boolean;
-/**
- * Should the LLM emit an AskUserQuestion at `step` given `mode`?
- * Pure function: no IO, no LLM call. The LLM-side caller passes the
- * mode it loaded from skill presence, and the step it is about to
- * execute; this function returns a `GateDecision` with the rationale.
- *
- * The hard-floor categories always win — even full-auto pauses for
- * irreversible external side effects, auth/credential usage,
- * multi-day investment decisions (D5.b), and commit-boundary side
- * effects (v2.15.0 slice 002 AC-4: push, tag, publish, global install).
- *
- * `hardFloorCategory` is optional on the `GateDecision` so callers can
- * stamp the override into the auto-decisions log without a second
- * switch.
- */
-/**
- * v2.15.0 slice 002 AC-4: the 5 action identifiers that qualify as
- * commit-boundary side effects. Matched by the LLM-side caller
- * (peaks-code body / peaks-rd fork agent) when it is about to run a
- * Bash command that maps to one of these. Set `commitBoundaryAction:
- * true` on the `shouldPauseAtGate` call to trigger the hard-floor
- * override.
- */
-export type CommitBoundaryActionId = 'git-push' | 'git-tag' | 'npm-publish' | 'npm-install-global' | 'peaks-global-install';
-export declare const COMMIT_BOUNDARY_ACTIONS: readonly CommitBoundaryActionId[];
-export declare function isCommitBoundaryAction(value: string): value is CommitBoundaryActionId;
 export declare function shouldPauseAtGate(opts: {
     mode: CodeMode;
     step: GatedStepId;
@@ -134,28 +102,6 @@ export declare function formatAutoProceedLogLine(opts: {
     recommendedOption: string;
     hardFloorCategory?: HardFloorCategory | undefined;
 }): string;
-/**
- * v2.15.0 slice 002 AC-4: regex matchers the LLM-side caller uses
- * to flag a Bash command as a commit-boundary action. Centralised
- * here so the test seam + the CLI wiring share one source of
- * truth. Each entry is an anchored pattern matched against the
- * user-invoked command (after commander / shell normalisation,
- * before execution).
- *
- * Patterns intentionally cover the common canonical forms:
- *
- *   - `git-push`            → `git push`, `git push origin main`, `git push --tags`
- *   - `git-tag`             → `git tag v2.15.0`, `git tag -a v2.15.0 -m ...`
- *   - `npm-publish`         → `npm publish`, `npm publish --access public`
- *   - `npm-install-global`  → `npm install -g <pkg>`, `npm i -g <pkg>`
- *   - `peaks-global-install`→ `npm install -g peaks-loop`, `pnpm add -g peaks-loop`
- *
- * These are coarse — false positives are fine (worst case: a
- * non-actionable command gets paused for confirmation; the user
- * can confirm in one click). False negatives are NOT fine — a
- * missed publish would violate the full-auto boundary.
- */
-export declare const COMMIT_BOUNDARY_PATTERNS: Readonly<Record<CommitBoundaryActionId, RegExp>>;
 /**
  * v2.15.0 slice 002 AC-4: detect whether a Bash command matches any
  * commit-boundary action pattern. Returns the action id of the

package/dist/services/code/mode-gate.js

@@ -19,40 +19,27 @@
  * Re-uses `SkillPresenceMode` from `skill-presence-service.ts` so the
  * 4 mode values stay in lockstep with the rest of the runtime.
  */
-export const CODE_MODES = [
-    'full-auto',
-    'assisted',
-    'strict',
-    '24h'
-];
+import { CODE_MODES, COMMIT_BOUNDARY_ACTIONS, COMMIT_BOUNDARY_PATTERNS } from './mode-gate-types.js';
+// The mode alias, the gated-step vocabulary and the commit-boundary vocabulary
+// live in `mode-gate-types.ts` (wave-3 file-size cap split; declarations moved
+// verbatim). Re-exported here so every importer keeps resolving them from
+// `mode-gate.js` unchanged.
+export { CODE_MODES, COMMIT_BOUNDARY_ACTIONS, COMMIT_BOUNDARY_PATTERNS, GATED_STEPS } from './mode-gate-types.js';
 export const HARD_FLOOR_CATEGORIES = [
     'irreversible-external-side-effect',
     'authentication-credential',
     'multi-day-investment',
     'commit-boundary-side-effect'
 ];
-export const GATED_STEPS = [
-    'step-0.5-openspec-opt-in',
-    'step-0.6-audit-goal',
-    'step-0.7-resume-detection',
-    'step-0.55-1x-upgrade',
-    'step-1-mode-select',
-    'step-2.5-session-title',
-    'phase-2-prd-confirm',
-    'phase-3-swarm-gate-b',
-    'phase-6-qa-gate-d',
-    'phase-10-txt-memory-extract',
-    'step-n+1-final-review',
-    'frontend-only-mismatch',
-    'step-0.75-checkpoint-resume',
-    'standards-preflight'
-];
 export function isCodeMode(value) {
     return CODE_MODES.includes(value);
 }
 export function isHardFloorCategory(value) {
     return HARD_FLOOR_CATEGORIES.includes(value);
 }
+export function isCommitBoundaryAction(value) {
+    return COMMIT_BOUNDARY_ACTIONS.includes(value);
+}
 /**
  * `true` when the current mode should auto-proceed (skip the
  * AskUserQuestion round-trip). Mirrors D5.a: "recommended = chosen
@@ -65,16 +52,21 @@ export function isHardFloorCategory(value) {
 export function shouldAutoProceed(mode) {
     return mode === 'full-auto' || mode === '24h';
 }
-export const COMMIT_BOUNDARY_ACTIONS = [
-    'git-push',
-    'git-tag',
-    'npm-publish',
-    'npm-install-global',
-    'peaks-global-install'
-];
-export function isCommitBoundaryAction(value) {
-    return COMMIT_BOUNDARY_ACTIONS.includes(value);
-}
+/**
+ * Should the LLM emit an AskUserQuestion at `step` given `mode`?
+ * Pure function: no IO, no LLM call. The LLM-side caller passes the
+ * mode it loaded from skill presence, and the step it is about to
+ * execute; this function returns a `GateDecision` with the rationale.
+ *
+ * The hard-floor categories always win — even full-auto pauses for
+ * irreversible external side effects, auth/credential usage,
+ * multi-day investment decisions (D5.b), and commit-boundary side
+ * effects (v2.15.0 slice 002 AC-4: push, tag, publish, global install).
+ *
+ * `hardFloorCategory` is optional on the `GateDecision` so callers can
+ * stamp the override into the auto-decisions log without a second
+ * switch.
+ */
 /**
  * Hard-pause steps: these pause regardless of mode. They are the gates
  * whose decision *creates* or *recreates* the mode/state under which
@@ -82,19 +74,11 @@ export function isCommitBoundaryAction(value) {
  * without user consent (defect #1: new Code session skipped Step 1
  * AskUserQuestion because `full-auto` mode triggered `shouldAutoProceed`
  * on `step-1-mode-select` itself).
- *
- * v2.18.4 slice 002-fix-first-run-step-gates: added
- * `step-0.55-1x-upgrade`. The 1.x → 2.0 upgrade is an irreversible
- * external side effect (migration rewrites config files and the
- * on-disk cache shape) — it must always pause, even in full-auto.
- * Without this, `full-auto` mode auto-proceeds and silently
- * downgrades a 1.x install to 2.0 without user consent.
  */
 const HARD_PAUSE_STEPS = new Set([
     'step-1-mode-select',
     'step-0.5-openspec-opt-in',
-    'step-0.7-resume-detection',
-    'step-0.55-1x-upgrade'
+    'step-0.7-resume-detection'
 ]);
 export function shouldPauseAtGate(opts) {
     if (opts.hardFloorCategory !== undefined && isHardFloorCategory(opts.hardFloorCategory)) {
@@ -154,34 +138,6 @@ export function formatAutoProceedLogLine(opts) {
     }
     return `auto-proceed (${opts.mode}): ${opts.step} → ${opts.recommendedOption}`;
 }
-/**
- * v2.15.0 slice 002 AC-4: regex matchers the LLM-side caller uses
- * to flag a Bash command as a commit-boundary action. Centralised
- * here so the test seam + the CLI wiring share one source of
- * truth. Each entry is an anchored pattern matched against the
- * user-invoked command (after commander / shell normalisation,
- * before execution).
- *
- * Patterns intentionally cover the common canonical forms:
- *
- *   - `git-push`            → `git push`, `git push origin main`, `git push --tags`
- *   - `git-tag`             → `git tag v2.15.0`, `git tag -a v2.15.0 -m ...`
- *   - `npm-publish`         → `npm publish`, `npm publish --access public`
- *   - `npm-install-global`  → `npm install -g <pkg>`, `npm i -g <pkg>`
- *   - `peaks-global-install`→ `npm install -g peaks-loop`, `pnpm add -g peaks-loop`
- *
- * These are coarse — false positives are fine (worst case: a
- * non-actionable command gets paused for confirmation; the user
- * can confirm in one click). False negatives are NOT fine — a
- * missed publish would violate the full-auto boundary.
- */
-export const COMMIT_BOUNDARY_PATTERNS = {
-    'git-push': /\bgit\s+push\b/,
-    'git-tag': /\bgit\s+tag\b/,
-    'npm-publish': /\bnpm\s+(publish|pub)\b/,
-    'npm-install-global': /\bnpm\s+(install|i|add)\s+(-g|--global)\b/,
-    'peaks-global-install': /\b(peaks-loop)\b/
-};
 /**
  * v2.15.0 slice 002 AC-4: detect whether a Bash command matches any
  * commit-boundary action pattern. Returns the action id of the

package/dist/services/code/orchestrator-can-do-advisories.d.ts

@@ -0,0 +1,30 @@
+/**
+ * orchestrator-can-do-advisories.js — the pure message side of
+ * `buildOrchestratorCanDoResult` (see `./orchestrator-can-do.ts`).
+ *
+ * Hoisted out of that module by slice c2w1 of `strict-remediation-abc` without
+ * touching one predicate, one branch order, or one byte of message text: the
+ * strings below are the probe's wire contract, consumed by skill prose and by
+ * the `pre-tool-code-gate` hook contract.
+ */
+/** Slice 2026-08-05-orchestrator-can-do-probe: red-line threshold. */
+export declare const ORCHESTRATOR_REDLINE_RATIO = 0.95;
+/** Slice 2026-08-05-orchestrator-can-do-probe: pre-compact threshold. */
+export declare const ORCHESTRATOR_PRECOMPACT_RATIO = 0.85;
+/** The four Q signals that produce blockers / warnings / suggestions here. */
+export interface BoundarySignals {
+    readonly q1HardBlockedPath: boolean;
+    readonly q2SubAgentAvailable: boolean;
+    readonly q3RequiresUserDecision: boolean;
+    readonly q4ContextRatio: number;
+}
+export interface BoundaryAdvisories {
+    readonly blockers: readonly string[];
+    readonly warnings: readonly string[];
+    readonly suggestions: readonly string[];
+}
+/**
+ * Build the blockers / warnings / suggestions carried by Q1 (hard), Q2, Q4 and
+ * Q3, in exactly the order `buildOrchestratorCanDoResult` used to push them.
+ */
+export declare function boundaryAdvisories(signals: BoundarySignals): BoundaryAdvisories;

package/dist/services/code/orchestrator-can-do-advisories.js

@@ -0,0 +1,81 @@
+/**
+ * orchestrator-can-do-advisories.js — the pure message side of
+ * `buildOrchestratorCanDoResult` (see `./orchestrator-can-do.ts`).
+ *
+ * Hoisted out of that module by slice c2w1 of `strict-remediation-abc` without
+ * touching one predicate, one branch order, or one byte of message text: the
+ * strings below are the probe's wire contract, consumed by skill prose and by
+ * the `pre-tool-code-gate` hook contract.
+ */
+/** Slice 2026-08-05-orchestrator-can-do-probe: red-line threshold. */
+export const ORCHESTRATOR_REDLINE_RATIO = 0.95;
+/** Slice 2026-08-05-orchestrator-can-do-probe: pre-compact threshold. */
+export const ORCHESTRATOR_PRECOMPACT_RATIO = 0.85;
+/**
+ * Build the blockers / warnings / suggestions carried by Q1 (hard), Q2, Q4 and
+ * Q3, in exactly the order `buildOrchestratorCanDoResult` used to push them.
+ */
+export function boundaryAdvisories(signals) {
+    const blockers = [];
+    const warnings = [];
+    const suggestions = [];
+    // Slice 2026-08-06-codegate-vendor-neutral — Q1 HARD BLOCKER. When
+    // the slice-spec mentions any hard-blocked path family
+    // (src/, tests/unit/, tests/integration/, config/, bin/, scripts/),
+    // the orchestrator MUST refuse direct execution and force sub-agent
+    // dispatch. This is the LLM-side complement to the
+    // `pre-tool-code-gate.sh` PreToolUse hook.
+    if (signals.q1HardBlockedPath) {
+        blockers.push('requires-sub-agent-dispatch: slice-spec mentions a hard-blocked path family ' +
+            '(src/, tests/unit/, tests/integration/, config/, bin/, scripts/); ' +
+            'orchestrator MUST NOT Edit/Write these directly. Use peaks sub-agent dispatch rd.');
+    }
+    // Q2 — sub-agent availability is a hard precondition.
+    if (!signals.q2SubAgentAvailable) {
+        blockers.push('sub-agent dispatch unavailable (peaks sub-agent dispatch --help failed)');
+        suggestions.push('verify peaks CLI is on PATH; check `peaks --version`');
+    }
+    // Q4 — context ratio. ≥0.95 → red-line; ≥0.85 → pre-compact. A WARNING, not
+    // a blocker, and the difference is deliberate (E3, rid 2026-09-13-defects-e).
+    //
+    // Why this is not a blocker any more, and why it is not an oversight:
+    //
+    //   The peak this answers is "can this slice run in the current session".
+    //   Context ratio cannot answer "no" to it. The reason is the one the
+    //   T3 slice (2026-09-13-auto-compact-trigger-ownership) landed on the
+    //   OTHER face of this same threshold: peaks-loop has no executor for a
+    //   running session, so it cannot compact its way out of a high ratio —
+    //   `evaluateCompactTrigger` therefore says of the red line "peaks-loop has
+    //   asked the harness to compact and is WAITING for it — sub-agent dispatch
+    //   is NOT blocked; carry on and re-probe". A probe that returned
+    //   `canDoInSession: false` here would contradict that sentence for the same
+    //   0.95 on the same number, and its only programmatic consumer
+    //   (`code-orchestrator-can-do.ts`) turns the false into exit code 1 — i.e.
+    //   it would re-open, at the CLI layer, exactly the deadlock T3 deleted.
+    //
+    //   Nor does the pre-compact zone (0.85–0.95) earn a blocker: the trigger's
+    //   message there is "peaks-loop already fired the auto-compact pathway; the
+    //   LLM does not need to act", which is the opposite of "you may not proceed".
+    //
+    //   What a blocker would still need to be true: THE ORCHESTRATOR itself
+    //   cannot continue. It can — the slice's edits are delegated to a sub-agent
+    //   (Q1), and the orchestrator's own context is only spent co-ordinating.
+    //
+    //   So the ratio is reported, warned about, and given a next action; the
+    //   verdict is left to the blockers that really are un-survivable (a
+    //   hard-blocked path family, an unreachable sub-agent dispatcher).
+    if (signals.q4ContextRatio >= ORCHESTRATOR_REDLINE_RATIO) {
+        warnings.push(`context red-line (ratio=${signals.q4ContextRatio.toFixed(2)} ≥ ${ORCHESTRATOR_REDLINE_RATIO}): peaks-loop has asked the harness to compact and is waiting for it; dispatch is NOT blocked — carry on and re-probe with \`peaks code context-now\``);
+        suggestions.push('peaks code auto-compact');
+    }
+    else if (signals.q4ContextRatio >= ORCHESTRATOR_PRECOMPACT_RATIO) {
+        warnings.push(`context near limit (ratio=${signals.q4ContextRatio.toFixed(2)} ≥ ${ORCHESTRATOR_PRECOMPACT_RATIO}): in the pre-compact band; peaks-loop fires the auto-compact pathway itself and dispatch is NOT blocked`);
+        suggestions.push('peaks code auto-compact');
+    }
+    // Q3 — user-decision keywords → soft warning, NOT a blocker. The
+    // LLM should AskUserQuestion, which is cheap.
+    if (signals.q3RequiresUserDecision) {
+        warnings.push('slice-spec contains decision keywords; AskUserQuestion before proceeding');
+    }
+    return { blockers, warnings, suggestions };
+}

package/dist/services/code/orchestrator-can-do-probes.d.ts

@@ -0,0 +1,30 @@
+/**
+ * orchestrator-can-do-probes.js — the Q2/Q4 subprocess probes behind
+ * `peaks code orchestrator-can-do`.
+ *
+ * Hoisted verbatim out of `./orchestrator-can-do.ts` (slice c2w1 of
+ * `strict-remediation-abc`) so that module keeps only the pure decision side.
+ * The names leave this file ONLY through that module's re-export: the CLI shim
+ * (`src/cli/commands/code-orchestrator-can-do.ts`) reaches them via
+ * `await import('../../services/code/orchestrator-can-do.js')`, and the unit
+ * tests import them from the same path, so the surface below must stay
+ * reachable from there.
+ */
+export interface ContextProbe {
+    /** 0.0–1.0; ≥0.85 = pre-compact; ≥0.95 = red-line. */
+    readonly ratio: number;
+    /** Source tag from `peaks code context-now`. */
+    readonly source: string;
+}
+/**
+ * Q2: probe `peaks sub-agent dispatch --role rd --help`. Returns
+ * true when the subprocess exits 0. Resolves to false on spawn
+ * failure or non-zero exit.
+ */
+export declare function probeSubAgentAvailable(projectRoot: string, peaksBin?: string): Promise<boolean>;
+/**
+ * Q4: probe `peaks code context-now --json`. Parses the data.ratio
+ * field. Falls back to {ratio: 0, source: 'unavailable'} when the
+ * subprocess fails or returns malformed JSON.
+ */
+export declare function probeContextRatio(projectRoot: string, peaksBin?: string): Promise<ContextProbe>;

package/dist/services/code/orchestrator-can-do-probes.js

@@ -0,0 +1,77 @@
+/**
+ * orchestrator-can-do-probes.js — the Q2/Q4 subprocess probes behind
+ * `peaks code orchestrator-can-do`.
+ *
+ * Hoisted verbatim out of `./orchestrator-can-do.ts` (slice c2w1 of
+ * `strict-remediation-abc`) so that module keeps only the pure decision side.
+ * The names leave this file ONLY through that module's re-export: the CLI shim
+ * (`src/cli/commands/code-orchestrator-can-do.ts`) reaches them via
+ * `await import('../../services/code/orchestrator-can-do.js')`, and the unit
+ * tests import them from the same path, so the surface below must stay
+ * reachable from there.
+ */
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+// 2026-09-10 D1: both probes used to spawn a bare `peaks`. On Windows that name
+// resolves to a `.cmd` shim, which `execFile` cannot run: it does not apply
+// PATHEXT, and Node >= 20 refuses to spawn `.cmd`/`.bat` at all without
+// `shell: true` (CVE-2024-27980). So Q2 reported "sub-agent dispatch
+// unavailable" and Q4 reported ratio 0 for every slice-spec on Windows —
+// phantom blockers produced by the spawn, not by the CLI. Running this tree's
+// own CLI entry through `process.execPath` needs no shell and no shim.
+import { cliEntryPath, interpreterArgs } from '../web/daemon-supervisor.js';
+const execFileAsync = promisify(execFile);
+/** Sentinel: no explicit binary was injected, so resolve this tree's own CLI. */
+const DEFAULT_PEAKS_BIN = 'peaks';
+/**
+ * Spawn argv for the peaks CLI. An explicitly injected `peaksBin` (the
+ * `--peaks-bin` test seam) is spawned verbatim; the default sentinel resolves
+ * to this tree's own CLI entry, interpreted by the running Node.
+ */
+function peaksSpawn(peaksBin) {
+    if (peaksBin !== DEFAULT_PEAKS_BIN) {
+        return { command: peaksBin, args: [] };
+    }
+    return { command: process.execPath, args: interpreterArgs(cliEntryPath()) };
+}
+/**
+ * Q2: probe `peaks sub-agent dispatch --role rd --help`. Returns
+ * true when the subprocess exits 0. Resolves to false on spawn
+ * failure or non-zero exit.
+ */
+export async function probeSubAgentAvailable(projectRoot, peaksBin = DEFAULT_PEAKS_BIN) {
+    try {
+        const { command, args } = peaksSpawn(peaksBin);
+        await execFileAsync(command, [...args, 'sub-agent', 'dispatch', '--role', 'rd', '--help'], {
+            cwd: projectRoot,
+            timeout: 5000,
+            windowsHide: true
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Q4: probe `peaks code context-now --json`. Parses the data.ratio
+ * field. Falls back to {ratio: 0, source: 'unavailable'} when the
+ * subprocess fails or returns malformed JSON.
+ */
+export async function probeContextRatio(projectRoot, peaksBin = DEFAULT_PEAKS_BIN) {
+    try {
+        const { command, args } = peaksSpawn(peaksBin);
+        const { stdout } = await execFileAsync(command, [...args, 'code', 'context-now', '--project', projectRoot, '--json'], {
+            cwd: projectRoot,
+            timeout: 10000,
+            windowsHide: true
+        });
+        const parsed = JSON.parse(stdout);
+        const ratio = typeof parsed.data?.ratio === 'number' ? parsed.data.ratio : 0;
+        const source = typeof parsed.data?.source === 'string' ? parsed.data.source : 'unavailable';
+        return { ratio, source };
+    }
+    catch {
+        return { ratio: 0, source: 'unavailable' };
+    }
+}

package/dist/services/code/orchestrator-can-do.d.ts

@@ -33,11 +33,18 @@
  *
  * Pure-function module. The CLI shim (code-orchestrator-can-do.ts)
  * adapts the envelope into the program's `ResultEnvelope<T>` shape.
+ *
+ * Slice c2w1 (strict-remediation-abc) hoisted two cohesive halves out of this
+ * file into siblings, both re-exported here so nothing else moved:
+ * `./orchestrator-can-do-probes.js` (the Q2/Q4 subprocess probes) and
+ * `./orchestrator-can-do-advisories.js` (the Q1/Q2/Q3/Q4 message builders,
+ * incl. the 0.95 / 0.85 thresholds).
  */
-/** Slice 2026-08-05-orchestrator-can-do-probe: red-line threshold. */
-export declare const ORCHESTRATOR_REDLINE_RATIO = 0.95;
-/** Slice 2026-08-05-orchestrator-can-do-probe: pre-compact threshold. */
-export declare const ORCHESTRATOR_PRECOMPACT_RATIO = 0.85;
+import { probeContextRatio, probeSubAgentAvailable, type ContextProbe } from './orchestrator-can-do-probes.js';
+import { ORCHESTRATOR_PRECOMPACT_RATIO, ORCHESTRATOR_REDLINE_RATIO } from './orchestrator-can-do-advisories.js';
+export { probeContextRatio, probeSubAgentAvailable };
+export { ORCHESTRATOR_PRECOMPACT_RATIO, ORCHESTRATOR_REDLINE_RATIO };
+export type { ContextProbe };
 /** Source-code keywords that signal "do NOT Edit/Write directly". */
 export declare const SOURCE_CODE_KEYWORDS: readonly string[];
 /**
@@ -55,12 +62,6 @@ export declare const SOURCE_CODE_KEYWORDS: readonly string[];
 export declare const HARD_BLOCKED_PATH_FAMILIES: readonly string[];
 /** Decision-marker keywords that signal "needs user AskUserQuestion". */
 export declare const DECISION_KEYWORDS: readonly string[];
-export interface ContextProbe {
-    /** 0.0–1.0; ≥0.85 = pre-compact; ≥0.95 = red-line. */
-    readonly ratio: number;
-    /** Source tag from `peaks code context-now`. */
-    readonly source: string;
-}
 export interface OrchestratorCanDoInput {
     readonly sliceSpec: string;
     readonly projectRoot: string;
@@ -110,18 +111,6 @@ export declare function detectHardBlockedPath(sliceSpec: string): boolean;
  * over the slice-spec string.
  */
 export declare function detectRequiresUserDecision(sliceSpec: string): boolean;
-/**
- * Q2: probe `peaks sub-agent dispatch --role rd --help`. Returns
- * true when the subprocess exits 0. Resolves to false on spawn
- * failure or non-zero exit.
- */
-export declare function probeSubAgentAvailable(projectRoot: string, peaksBin?: string): Promise<boolean>;
-/**
- * Q4: probe `peaks code context-now --json`. Parses the data.ratio
- * field. Falls back to {ratio: 0, source: 'unavailable'} when the
- * subprocess fails or returns malformed JSON.
- */
-export declare function probeContextRatio(projectRoot: string, peaksBin?: string): Promise<ContextProbe>;
 /**
  * Build the structured OrchestratorCanDoResult. Pure over the 4 Q
  * signals + sliceSpec. Decision rule is: canDoInSession === !blockers.