peaks-loop 4.0.54 → 4.1.1

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

@@ -33,36 +33,22 @@
  *
  * 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).
  */
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
 import { randomUUID } from 'node:crypto';
-// 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()) };
-}
-/** 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;
+import { probeContextRatio, probeSubAgentAvailable } from './orchestrator-can-do-probes.js';
+import { boundaryAdvisories, ORCHESTRATOR_PRECOMPACT_RATIO, ORCHESTRATOR_REDLINE_RATIO } from './orchestrator-can-do-advisories.js';
+// The probes, the thresholds and `ContextProbe` keep THIS module path as their
+// public surface: the CLI shim reaches the two probes through
+// `await import('../../services/code/orchestrator-can-do.js')`, so the
+// re-export below is load-bearing, not cosmetic.
+export { probeContextRatio, probeSubAgentAvailable };
+export { ORCHESTRATOR_PRECOMPACT_RATIO, ORCHESTRATOR_REDLINE_RATIO };
 /** Source-code keywords that signal "do NOT Edit/Write directly". */
 export const SOURCE_CODE_KEYWORDS = [
     'src/',
@@ -76,7 +62,7 @@ export const SOURCE_CODE_KEYWORDS = [
     'workflows/',
     '.py',
     '.go',
-    '.rs',
+    '.rs'
 ];
 /**
  * Slice 2026-08-06-codegate-vendor-neutral — hard-blocked path families.
@@ -96,7 +82,7 @@ export const HARD_BLOCKED_PATH_FAMILIES = [
     'tests/integration/',
     'config/',
     'bin/',
-    'scripts/',
+    'scripts/'
 ];
 /** Decision-marker keywords that signal "needs user AskUserQuestion". */
 export const DECISION_KEYWORDS = [
@@ -107,7 +93,7 @@ export const DECISION_KEYWORDS = [
     '选择',
     '决定',
     'design decision',
-    'user choice',
+    'user choice'
 ];
 export class OrchestratorCanDoError extends Error {
     code;
@@ -144,46 +130,16 @@ export function detectRequiresUserDecision(sliceSpec) {
     const lower = sliceSpec.toLowerCase();
     return DECISION_KEYWORDS.some((kw) => lower.includes(kw.toLowerCase()));
 }
+/** Suggestion surfaced when canDoInSession=true and no source code is touched. */
+const NON_SOURCE_CODE_SLICE_SUGGESTION = 'non-source-code slice; orchestrator may handle in-session (e.g. via Write/Edit tools or directly)';
 /**
- * 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.
+ * The concrete delegation verb for a source-code slice, with a fresh
+ * `--request-id` and `--batch-id` on every call (as before).
  */
-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' };
-    }
+function subAgentDispatchSuggestion(projectRoot) {
+    const batchId = randomUUID();
+    const rid = 'rid-' + Date.now().toString(36);
+    return `peaks sub-agent dispatch rd --prompt "<slice-spec>" --request-id ${rid} --project ${projectRoot} --batch-id ${batchId}`;
 }
 /**
  * Build the structured OrchestratorCanDoResult. Pure over the 4 Q
@@ -193,77 +149,24 @@ export function buildOrchestratorCanDoResult(input, 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');
-    }
+    // Q1 (hard) / Q2 / Q4 / Q3 — the messages, in the order they were always
+    // pushed. The reasoning that keeps the context ratio a WARNING and never a
+    // blocker rides along in `boundaryAdvisories` (orchestrator-can-do-advisories).
+    const boundary = boundaryAdvisories(signals);
+    blockers.push(...boundary.blockers);
+    warnings.push(...boundary.warnings);
+    suggestions.push(...boundary.suggestions);
     // Q1 (soft) — source-code touched is a sub-agent-dispatch hint. When
     // not already hard-blocked (above), surface the dispatch verb. When
     // already hard-blocked the blocker line carries the same instruction.
     if (signals.q1SourceCodeTouched && signals.q2SubAgentAvailable) {
-        const batchId = randomUUID();
-        const rid = 'rid-' + Date.now().toString(36);
-        suggestions.push(`peaks sub-agent dispatch rd --prompt "<slice-spec>" --request-id ${rid} --project ${input.projectRoot} --batch-id ${batchId}`);
+        suggestions.push(subAgentDispatchSuggestion(input.projectRoot));
     }
     // When canDoInSession=true and there's no source code touched,
     // surface a generic "do it" suggestion.
     const canDoInSession = blockers.length === 0;
     if (canDoInSession && !signals.q1SourceCodeTouched) {
-        suggestions.push(`non-source-code slice; orchestrator may handle in-session (e.g. via Write/Edit tools or directly)`);
+        suggestions.push(NON_SOURCE_CODE_SLICE_SUGGESTION);
     }
     return {
         canDoInSession,
@@ -276,7 +179,7 @@ export function buildOrchestratorCanDoResult(input, signals) {
         q1HardBlockedPath: signals.q1HardBlockedPath,
         q2SubAgentAvailable: signals.q2SubAgentAvailable,
         q3RequiresUserDecision: signals.q3RequiresUserDecision,
-        q4ContextRatio: signals.q4ContextRatio,
+        q4ContextRatio: signals.q4ContextRatio
     };
 }
 /**
@@ -292,15 +195,12 @@ export async function evaluateOrchestratorCanDo(input) {
     const q3RequiresUserDecision = detectRequiresUserDecision(input.sliceSpec);
     const probeSubAgent = input.probeSubAgentAvailable ?? (() => probeSubAgentAvailable(input.projectRoot));
     const probeContext = input.probeContextRatio ?? (() => probeContextRatio(input.projectRoot));
-    const [subAgentAvailable, ctxProbe] = await Promise.all([
-        probeSubAgent(),
-        probeContext(),
-    ]);
+    const [subAgentAvailable, ctxProbe] = await Promise.all([probeSubAgent(), probeContext()]);
     return buildOrchestratorCanDoResult(input, {
         q1SourceCodeTouched,
         q1HardBlockedPath,
         q2SubAgentAvailable: subAgentAvailable,
         q3RequiresUserDecision,
-        q4ContextRatio: ctxProbe.ratio,
+        q4ContextRatio: ctxProbe.ratio
     });
 }

package/dist/services/code/post-compact-checkpoint.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `src/services/code/post-compact-checkpoint.ts`
+ *
+ * The checkpoint read layer behind the post-compact auto-resume detector
+ * (`post-compact-detector.ts`): the two directory/name constants, the
+ * checkpoint record shapes, the same-day test, and the defensive single-file
+ * read. Moved verbatim (wave 3, file-size cap campaign) so the detector stays
+ * under the 300 raw-line cap — no detection decision lives here. These names
+ * were module-private to the detector before the move and stay private to it
+ * in effect: the detector imports them and does not re-export them, so the
+ * module's public surface is unchanged.
+ */
+export declare const CHECKPOINTS_DIR = "checkpoints";
+export declare const CHECKPOINT_EXT = ".json";
+export interface CheckpointFile {
+    readonly path: string;
+    readonly mtime: Date;
+    readonly content: CheckpointContent;
+}
+interface CheckpointContent {
+    readonly currentPlan?: string;
+    readonly openQuestions?: readonly string[];
+    readonly recentDecisions?: readonly string[];
+    readonly mode?: string;
+}
+export declare function isToday(d: Date, now: Date): boolean;
+export declare function safeReadCheckpoint(absPath: string): CheckpointFile | null;
+export {};

package/dist/services/code/post-compact-checkpoint.js

@@ -0,0 +1,57 @@
+/**
+ * `src/services/code/post-compact-checkpoint.ts`
+ *
+ * The checkpoint read layer behind the post-compact auto-resume detector
+ * (`post-compact-detector.ts`): the two directory/name constants, the
+ * checkpoint record shapes, the same-day test, and the defensive single-file
+ * read. Moved verbatim (wave 3, file-size cap campaign) so the detector stays
+ * under the 300 raw-line cap — no detection decision lives here. These names
+ * were module-private to the detector before the move and stay private to it
+ * in effect: the detector imports them and does not re-export them, so the
+ * module's public surface is unchanged.
+ */
+import { readFileSync, statSync } from 'node:fs';
+import { isExpectedFsMiss } from '../../shared/fs-utils.js';
+export const CHECKPOINTS_DIR = 'checkpoints';
+export const CHECKPOINT_EXT = '.json';
+export function isToday(d, now) {
+    return (d.getUTCFullYear() === now.getUTCFullYear() &&
+        d.getUTCMonth() === now.getUTCMonth() &&
+        d.getUTCDate() === now.getUTCDate());
+}
+export function safeReadCheckpoint(absPath) {
+    try {
+        const stat = statSync(absPath);
+        const raw = readFileSync(absPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        const mutable = {};
+        if (typeof parsed['currentPlan'] === 'string') {
+            mutable.currentPlan = parsed['currentPlan'];
+        }
+        if (Array.isArray(parsed['openQuestions'])) {
+            mutable.openQuestions = parsed['openQuestions'].filter((q) => typeof q === 'string');
+        }
+        if (Array.isArray(parsed['recentDecisions'])) {
+            mutable.recentDecisions = parsed['recentDecisions'].filter((d) => typeof d === 'string');
+        }
+        if (typeof parsed['mode'] === 'string') {
+            mutable.mode = parsed['mode'];
+        }
+        const content = mutable;
+        return { path: absPath, mtime: stat.mtime, content };
+    }
+    catch (err) {
+        // P1 site (S6, 2026-09-15). The TODO(g2) marker this replaces said the
+        // catch "narrows to IO errors only" — it did not. It rethrew the two JS
+        // error classes it happened to name and swallowed everything else,
+        // including the ReferenceError an ESM `require()` bug produces on the one
+        // platform this file's whole defence exists for. Corrupt JSON stays loud
+        // (we cannot read a checkpoint we cannot parse); every non-fs-miss error
+        // now propagates. See `isExpectedFsMiss`.
+        if (err instanceof SyntaxError)
+            throw err;
+        if (!isExpectedFsMiss(err))
+            throw err;
+        return null;
+    }
+}

package/dist/services/code/post-compact-detector.js

@@ -21,11 +21,12 @@
  * IO: readdir + readFile on `.peaks/_runtime/<sid>/checkpoints/`.
  * No writes (caller logs the decision via the auto-decisions channel).
  */
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { existsSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { getSkillPresence } from '../skills/skill-presence-service.js';
 import { isExpectedFsMiss } from '../../shared/fs-utils.js';
 import { emitObservabilityEvent } from '../observability/observability-service.js';
+import { CHECKPOINT_EXT, CHECKPOINTS_DIR, isToday, safeReadCheckpoint } from './post-compact-checkpoint.js';
 import { isCodeMode } from './mode-gate.js';
 export const POST_COMPACT_RESUME_REASONS = [
     'post-compact-match',
@@ -38,49 +39,6 @@ export const POST_COMPACT_RESUME_REASONS = [
     'active-skill-mismatch',
     'checkpoint-read-failed'
 ];
-const CHECKPOINTS_DIR = 'checkpoints';
-const CHECKPOINT_EXT = '.json';
-function isToday(d, now) {
-    return (d.getUTCFullYear() === now.getUTCFullYear() &&
-        d.getUTCMonth() === now.getUTCMonth() &&
-        d.getUTCDate() === now.getUTCDate());
-}
-function safeReadCheckpoint(absPath) {
-    try {
-        const stat = statSync(absPath);
-        const raw = readFileSync(absPath, 'utf8');
-        const parsed = JSON.parse(raw);
-        const mutable = {};
-        if (typeof parsed['currentPlan'] === 'string') {
-            mutable.currentPlan = parsed['currentPlan'];
-        }
-        if (Array.isArray(parsed['openQuestions'])) {
-            mutable.openQuestions = parsed['openQuestions'].filter((q) => typeof q === 'string');
-        }
-        if (Array.isArray(parsed['recentDecisions'])) {
-            mutable.recentDecisions = parsed['recentDecisions'].filter((d) => typeof d === 'string');
-        }
-        if (typeof parsed['mode'] === 'string') {
-            mutable.mode = parsed['mode'];
-        }
-        const content = mutable;
-        return { path: absPath, mtime: stat.mtime, content };
-    }
-    catch (err) {
-        // P1 site (S6, 2026-09-15). The TODO(g2) marker this replaces said the
-        // catch "narrows to IO errors only" — it did not. It rethrew the two JS
-        // error classes it happened to name and swallowed everything else,
-        // including the ReferenceError an ESM `require()` bug produces on the one
-        // platform this file's whole defence exists for. Corrupt JSON stays loud
-        // (we cannot read a checkpoint we cannot parse); every non-fs-miss error
-        // now propagates. See `isExpectedFsMiss`.
-        if (err instanceof SyntaxError)
-            throw err;
-        if (!isExpectedFsMiss(err))
-            throw err;
-        return null;
-    }
-}
 function readLatestTodayCheckpoint(runtimeDir, now) {
     const dir = join(runtimeDir, CHECKPOINTS_DIR);
     if (!existsSync(dir)) {
@@ -206,11 +164,19 @@ export async function detectPostCompactResume(opts) {
         checkpointPath: file.path,
         checkpointMtime: file.mtime.toISOString(),
         ...(file.content.currentPlan !== undefined ? { task: file.content.currentPlan } : {}),
-        ...(file.content.openQuestions !== undefined ? { openQuestions: file.content.openQuestions } : {}),
-        ...(file.content.recentDecisions !== undefined ? { recentDecisions: file.content.recentDecisions } : {}),
+        ...(file.content.openQuestions !== undefined
+            ? { openQuestions: file.content.openQuestions }
+            : {}),
+        ...(file.content.recentDecisions !== undefined
+            ? { recentDecisions: file.content.recentDecisions }
+            : {}),
         warnings
     };
-    emitPostCompactEvent({ projectRoot: opts.projectRoot, sessionId: opts.sessionId, probe: successProbe });
+    emitPostCompactEvent({
+        projectRoot: opts.projectRoot,
+        sessionId: opts.sessionId,
+        probe: successProbe
+    });
     return successProbe;
 }
 // Slice C of v2.11.1 — observability hook #6/7. Fire-and-forget per
@@ -226,7 +192,9 @@ function emitPostCompactEvent(opts) {
             shouldAutoResume: opts.probe.shouldAutoResume,
             reason: opts.probe.reason,
             ...(opts.probe.mode !== undefined ? { mode: opts.probe.mode } : {}),
-            ...(opts.probe.checkpointPath !== undefined ? { checkpointPath: opts.probe.checkpointPath } : {})
+            ...(opts.probe.checkpointPath !== undefined
+                ? { checkpointPath: opts.probe.checkpointPath }
+                : {})
         }
     }, { projectRoot: opts.projectRoot });
 }

package/dist/services/code/step-08-gate.d.ts

@@ -13,9 +13,10 @@
  *
  *   1. `job-shape.json` exists with `decision.isJob === true`.
  *      → allow, print `{ ok, allow, mode: 'job', decision }`. When a
- *        matching `job/<jid>/progress.json` exists, also print
- *        `Next: slice #<N+1> of <M> (<currentSlice>)` so the LLM sees
- *        its resume context BEFORE any Bash call lands.
+ *        matching `job/<jid>/progress.json` exists, also print the
+ *        next-slice sentence from `describeNextSlice` — `Next: slice #N of M
+ *        (<label>)` while a slice is pending, the `add-slice` remedy when none is
+ *        — so the LLM sees its resume context BEFORE any Bash call lands.
  *   2. `job-shape.json` exists with `decision.isJob === false`.
  *      → allow, print `{ ok, allow, mode: 'single' }`.
  *   3. `job-shape.json` is MISSING — fail-closed guard. The LLM is the

package/dist/services/code/step-08-gate.js

@@ -13,9 +13,10 @@
  *
  *   1. `job-shape.json` exists with `decision.isJob === true`.
  *      → allow, print `{ ok, allow, mode: 'job', decision }`. When a
- *        matching `job/<jid>/progress.json` exists, also print
- *        `Next: slice #<N+1> of <M> (<currentSlice>)` so the LLM sees
- *        its resume context BEFORE any Bash call lands.
+ *        matching `job/<jid>/progress.json` exists, also print the
+ *        next-slice sentence from `describeNextSlice` — `Next: slice #N of M
+ *        (<label>)` while a slice is pending, the `add-slice` remedy when none is
+ *        — so the LLM sees its resume context BEFORE any Bash call lands.
  *   2. `job-shape.json` exists with `decision.isJob === false`.
  *      → allow, print `{ ok, allow, mode: 'single' }`.
  *   3. `job-shape.json` is MISSING — fail-closed guard. The LLM is the
@@ -35,6 +36,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { readJobShapeDecision, JobShapeDecisionError, JOB_SHAPE_NOT_DECIDED } from './job-shape-decision.js';
+import { describeNextSlice } from '../job/job-progress-store.js';
 import { isExpectedFsMiss } from '../../shared/fs-utils.js';
 export const STEP_08_GATE_FILE_NAME = 'job-shape.json';
 export const STEP_08_PROGRESS_FILE_NAME = 'progress.json';
@@ -129,9 +131,7 @@ export function evaluateStep08(input) {
         const record = readJobShapeDecision(input.projectRoot, input.sessionId);
         if (record.decision.isJob) {
             const progress = readProgressIfAny(input.projectRoot, input.sessionId, record.decision.suggestedJobId);
-            const nextSliceLine = progress !== null
-                ? `Next: slice #${progress.done + 1} of ${progress.total} (${progress.currentSlice})`
-                : null;
+            const nextSliceLine = progress !== null ? `Next: ${describeNextSlice(progress, progress.jobId)}` : null;
             return {
                 allow: true,
                 verdict: { kind: 'allow-job', decision: record.decision, progress },
@@ -144,11 +144,23 @@ export function evaluateStep08(input) {
         if (err instanceof JobShapeDecisionError && err.code === JOB_SHAPE_NOT_DECIDED) {
             const promptText = input.prompt ?? readPromptFromLastPromptFile(input.projectRoot, input.sessionId);
             const hit = promptText.length > 0 && STEP_08_BACKUP_REGEX.test(promptText);
-            const source = input.prompt !== undefined ? 'flag' : promptText.length > 0 ? 'last-prompt-file' : 'stdin-empty';
+            const source = input.prompt !== undefined
+                ? 'flag'
+                : promptText.length > 0
+                    ? 'last-prompt-file'
+                    : 'stdin-empty';
             if (hit) {
-                return { allow: false, verdict: { kind: 'block-missing-decision', promptHit: true, promptSource: source }, nextSliceLine: null };
+                return {
+                    allow: false,
+                    verdict: { kind: 'block-missing-decision', promptHit: true, promptSource: source },
+                    nextSliceLine: null
+                };
             }
-            return { allow: true, verdict: { kind: 'block-missing-decision', promptHit: false, promptSource: source }, nextSliceLine: null };
+            return {
+                allow: true,
+                verdict: { kind: 'block-missing-decision', promptHit: false, promptSource: source },
+                nextSliceLine: null
+            };
         }
         throw err;
     }

package/dist/services/code/user-touchpoint-classifier.js

@@ -42,13 +42,6 @@ const RAW_CLASSIFICATION = [
         fullAutoCanProceed: false,
         userShouldReview: 'always'
     },
-    {
-        step: 'step-0.55-1x-upgrade',
-        kind: 'commit-floor',
-        description: '1.x → 2.0 升级检测。不可逆外部副作用(改写 config + cache schema),所有 mode 都必须 AskUserQuestion。full-auto 也暂停。',
-        fullAutoCanProceed: false,
-        userShouldReview: 'always'
-    },
     {
         step: 'step-0.75-checkpoint-resume',
         kind: 'tech',

package/dist/services/code-review/ecc-bridge.d.ts

@@ -21,12 +21,12 @@
  *
  * === Why no `peaksConfig.ecc.*` block ===
  *
- * ECC is shipped via the `everything-claude-code` plugin, not as a
- * separate npm package. The user installs the plugin (a one-time
- * marketplace step); peaks-loop does not write or read any LLM
- * endpoint config for ECC. If a future ECC release needs user-
- * managed config (URL / token / model), add a `peaksConfig.ecc.*`
- * block then — not speculatively now.
+ * ECC ships as the `ecc-universal` npm package — the same repository as
+ * github.com/affaan-m/ECC — and peaks-loop depends on it, so the agents are read
+ * from that dependency, not downloaded. ECC may ALSO be present as the
+ * `everything-claude-code` Claude Code plugin, the native path `detectEcc`
+ * prefers. Either way peaks-loop writes and reads no LLM endpoint config for ECC;
+ * add a `peaksConfig.ecc.*` block only when a release actually needs one.
  *
  * === Source: peaks-rd/references/parallel-review-fanout.md ===
  *

package/dist/services/code-review/ecc-bridge.js

@@ -89,6 +89,20 @@ function countByKind(violations) {
     }
     return counts;
 }
+function renderRequiredFixes(env) {
+    return env.violations.length === 0
+        ? ''
+        : [
+            '## Required Fixes',
+            '',
+            ...env.violations.map((v, i) => {
+                const safeSnippet = escapeMarkdownCell(v.snippet);
+                const safeHint = escapeMarkdownCell(v.hint);
+                return `- [${v.kind} @ line ${v.line}] ${safeHint} (snippet: \`${safeSnippet}\`)`;
+            }),
+            ''
+        ].join('\n');
+}
 /**
  * Render an ECC envelope to the canonical `rd/code-review.md` shape.
  * Verdict → sections:
@@ -113,18 +127,7 @@ export function adaptEccEnvelopeToRdCodeReview(env, opts) {
         ''
     ].join('\n');
     const findingsSection = renderFindings(env.violations);
-    const requiredFixesSection = env.violations.length === 0
-        ? ''
-        : [
-            '## Required Fixes',
-            '',
-            ...env.violations.map((v, i) => {
-                const safeSnippet = escapeMarkdownCell(v.snippet);
-                const safeHint = escapeMarkdownCell(v.hint);
-                return `- [${v.kind} @ line ${v.line}] ${safeHint} (snippet: \`${safeSnippet}\`)`;
-            }),
-            ''
-        ].join('\n');
+    const requiredFixesSection = renderRequiredFixes(env);
     const recommendedSection = env.gateAction === 'pass'
         ? ''
         : [
@@ -145,13 +148,9 @@ export function adaptEccEnvelopeToRdCodeReview(env, opts) {
         `CRITICAL: ${criticalCount}`,
         ''
     ].join('\n');
-    const body = [
-        summary,
-        findingsSection,
-        requiredFixesSection,
-        recommendedSection,
-        verdictBlock
-    ].filter((s) => s.length > 0).join('\n');
+    const body = [summary, findingsSection, requiredFixesSection, recommendedSection, verdictBlock]
+        .filter((s) => s.length > 0)
+        .join('\n');
     return {
         body,
         verdict: env.gateAction,
@@ -244,9 +243,7 @@ export function detectEcc(input) {
             state: 'agent-missing',
             pluginInstalled: true,
             agentAvailable: false,
-            warnings: [
-                '`ecc` is installed but its `code-reviewer` agent is not registered.'
-            ],
+            warnings: ['`ecc` is installed but its `code-reviewer` agent is not registered.'],
             nextActions: [
                 'Verify the plugin is enabled in your Claude Code settings (MCP servers / agent registry).',
                 `If your registry still exposes the old \`everything-claude-code\` plugin id, pin the native agent id explicitly (\`${DEFAULT_NATIVE_ECC_AGENT_ID}\`) instead of relying on detection.`,
@@ -311,7 +308,10 @@ export function runEccCodeReview(input) {
     // A dispatchable state implies input.envelope passed isEccEnvelope; the runtime
     // type is therefore EccEnvelope, not `unknown`. Cast is justified by detect's contract.
     const env = input.envelope;
-    return { detect, doc: adaptEccEnvelopeToRdCodeReview(env, { rid: input.rid, generatedAt: input.generatedAt }) };
+    return {
+        detect,
+        doc: adaptEccEnvelopeToRdCodeReview(env, { rid: input.rid, generatedAt: input.generatedAt })
+    };
 }
 /**
  * The exact JSON shape the generic (cache-backed) sub-agent MUST return.