peaks-loop 4.0.53 → 4.1.0

package/dist/services/ide/ide-types.d.ts

@@ -12,7 +12,13 @@
  * 其他全部归一化到 peaks 内部模型(见 hook-protocol.ts)。
  */
 import type { SubAgentDispatcher } from '../dispatch/sub-agent-dispatcher.js';
-import type { ContextPercentProbe } from '../context/auto-compact-types.js';
+import type { ContextPercentFallbackInput, IdeCompactProfile } from './ide-compact-types.js';
+/**
+ * Re-exported so every importer of `./ide-types.js` keeps seeing the whole
+ * adapter type surface from the original path (b1 file-size campaign: the two
+ * declarations now live in `./ide-compact-types.js`).
+ */
+export type { ContextPercentFallbackInput, IdeCompactProfile };
 export type IdeId = 'claude-code' | 'trae' | 'codex' | 'cursor' | 'qoder' | 'tongyi-lingma' | 'hermes' | 'openclaw' | 'zcode';
 export interface IdeCapabilities {
     /** peaks gate enforce 是否适用该 IDE(必备) */
@@ -177,150 +183,6 @@ export interface IdeAdapter {
      */
     readonly resolveCallerId: (env?: NodeJS.ProcessEnv) => string;
 }
-/**
- * Per-IDE auto-compact capability descriptor. See `IdeAdapter.compact`
- * for the protocol contract. The `MvpCompactPathway` string union
- * keeps the field exhaustive — adding a new pathway requires updating
- * every adapter that opts in.
- */
-export interface IdeCompactProfile {
-    /** Env-var name the IDE writes per turn to expose context-fill %. */
-    readonly envVarForContextPercent: string;
-    /**
-     * Slash command or shell-call to invoke compact. The orchestrator
-     * spawns this via `child_process.spawn` (shell-exec pathway) or
-     * writes it to an IDE hook file (ide-native pathway).
-     *
-     * ZERO EXECUTOR as of slice 2026-09-13-auto-compact-trigger-ownership: every
-     * `shell-exec` branch now only REPORTS that it will not spawn (see
-     * `auto-compact-dispatcher.ts`), and the `ide-native` branch registers a
-     * harness-side trigger instead. The field is retained because the sibling
-     * work (A2, harness-side state re-injection) still needs it; nothing in this
-     * slice deletes it. Do not read it as a capability peaks-loop has.
-     */
-    readonly compactCommand: string;
-    /**
-     * `shell-exec` — peaks-loop spawns the command via child_process
-     *                (works for any IDE that accepts a slash command
-     *                via a shell-spawnable entry point).
-     * `ide-native` — peaks-loop writes to an IDE-specific hook file;
-     *                used when the IDE requires a registered hook
-     *                rather than a runtime command.
-     * `llm-self-compress` — peaks-loop prompts the LLM to summarize
-     *                its own context (no IDE integration required;
-     *                least precise but always available).
-     * `noop` — peaks-loop records the intent but performs no action;
-     *          used by IDEs that explicitly opt out (e.g. legacy
-     *          adapters still on the v2.11.x model).
-     */
-    readonly compactPathway: 'shell-exec' | 'ide-native' | 'llm-self-compress' | 'noop';
-    /**
-     * Optional settings key / env var the IDE reads its AUTO-COMPACT WINDOW
-     * from — i.e. the window the harness itself compacts against. When
-     * declared, peaks-loop writes the window it computes its ratio against
-     * into the adapter's machine-local settings `env` block, under this key,
-     * so both sides reference one number instead of two independent
-     * resolutions (slice 2026-09-13-auto-compact-trigger-ownership).
-     *
-     * `undefined` = this IDE exposes no such knob. peaks-loop then cannot
-     * close the drift; `peaks compact harness-window` reports that instead of
-     * pretending. Adapters that do not opt in are unchanged.
-     */
-    readonly autoCompactWindowEnvVar?: string;
-    /**
-     * Optional command the runner invokes post-compact to confirm
-     * ratio dropped (e.g. `peaks code auto-compact --json`). When omitted,
-     * the orchestrator polls `envVarForContextPercent` directly.
-     */
-    readonly postCompactDetectCommand?: string;
-    /**
-     * Optional vendor-specific fallback the generic `readContextPercent`
-     * reader calls when the primary env-var probe misses. Returns a
-     * completed `ContextPercentProbe` (e.g. `statusline-poll` /
-     * `transcript-estimate`) or `null` when the adapter has no signal —
-     * the reader then falls through to `conservative-fallback`.
-     *
-     * Keeps IDE-specific filesystem / env knowledge (Claude Code's
-     * `~/.claude/statusline-state.json` + `~/.claude/projects` transcript
-     * layout, etc.) inside the adapter, not the generic reader. Adapters
-     * that do not opt in simply omit the field; new IDEs are addable
-     * without touching the generic reader.
-     *
-     * Added in slice 2026-09-02-vendor-neutral-context-probe.
-     */
-    readonly readContextPercentFallback?: (input: ContextPercentFallbackInput) => ContextPercentProbe | null;
-    /**
-     * Optional locator for the IDE's per-session transcript file (jsonl),
-     * keyed by the OUTER (harness) session id. `peaks code context-audit`
-     * (slice 2026-09-10-context-audit-and-discipline, Slice A) uses it to
-     * group the session's tool results by tool + short input key, so the
-     * generic audit service never learns any vendor's on-disk layout.
-     *
-     * Returns the absolute path, or `null` when the transcript does not
-     * exist. Adapters MUST NOT throw on a missing file — the audit treats
-     * `null` as `available: false` and continues.
-     *
-     * Adapters that do not opt in simply omit the field; the audit then
-     * reports `transcript-locator-unavailable`.
-     */
-    readonly resolveTranscriptPath?: (outerSessionId: string) => string | null;
-}
-/**
- * Input the generic `readContextPercent` reader passes to an adapter's
- * optional `IdeCompactProfile.readContextPercentFallback` hook. The adapter
- * owns the vendor-specific fallback logic (statusline poll, transcript
- * lookup, etc.); the generic reader stays IDE-agnostic.
- *
- * Added in slice 2026-09-02-vendor-neutral-context-probe.
- */
-export interface ContextPercentFallbackInput {
-    /** Project root (the probe's `--project` anchor). */
-    readonly projectRoot: string;
-    /** Peaks session id (NOT the harness / IDE transcript id). */
-    readonly sessionId: string;
-    /**
-     * Outer (harness / IDE) session id — the id the IDE uses to name its
-     * transcript / session files (e.g. a UUID). Optional: when unresolved,
-     * adapters whose fallback depends on it should return `null`.
-     */
-    readonly outerSessionId?: string | undefined;
-    /** Injectable env (defaults to process.env in the reader). */
-    readonly env?: NodeJS.ProcessEnv | undefined;
-    /**
-     * Raw `context.windowTokens` value from the merged config (project layer
-     * over user layer), read by the generic reader so the adapter stays free
-     * of config-path knowledge. UNVALIDATED — the adapter validates it via
-     * `parseContextWindowOverride` and warns on a bad value.
-     *
-     * Slice 2026-09-09-context-window-override.
-     */
-    readonly configWindowTokens?: unknown;
-    /**
-     * Raw value of the adapter's `autoCompactWindowEnvVar`, resolved by the
-     * generic reader from the adapter's own declarations (settings path +
-     * key name) — the window peaks-loop configured for the harness. Feeds the
-     * `harness-env` layer of `resolveContextWindow`.
-     *
-     * Slice 2026-09-13-auto-compact-trigger-ownership.
-     */
-    readonly harnessWindowTokens?: unknown;
-    /**
-     * True when `harnessWindowTokens` is a value peaks-loop ITSELF wrote (the
-     * harness settings carry the provenance marker matching it), false when a
-     * human set the key by hand.
-     *
-     * The `harness-env` layer outranks the model heuristic either way — that is
-     * what keeps peaks-loop's ratio and the harness's trigger on one number. The
-     * flag decides only whether the late 1M rescue may OVERRULE that layer when
-     * the observed context proves it too small: peaks-loop's own earlier
-     * resolution is self-correcting, whereas a human's explicit pin must not be
-     * silently rewritten (and, since it is persisted, permanently so).
-     *
-     * Omitted = treated as not peaks-written (the safe direction: do not touch
-     * what you did not write).
-     */
-    readonly harnessWindowPeakWritten?: boolean;
-}
 /**
  * Per-IDE standards-file location + format profile. Used by the
  * `peaks standards init` dispatch layer (slice 011) to write the

package/dist/services/ide/resource-profile.js

@@ -28,6 +28,6 @@ export function detectAllResourceTargets() {
     return listAdapterIds().map((ideId) => ({
         ideId,
         standardsProfile: getStandardsProfile(ideId),
-        skillInstall: getSkillInstall(ideId),
+        skillInstall: getSkillInstall(ideId)
     }));
 }

package/dist/services/ide/shared/atomic-json.js

@@ -50,7 +50,8 @@ export function atomicWriteJson(filePath, value) {
         try {
             unlinkSync(tempPath);
         }
-        catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
+        catch {
+            // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
             // best effort cleanup
         }
         throw error;

package/dist/services/impact/impact-scan-service.js

@@ -71,12 +71,16 @@ export function matchGlob(pattern, path) {
 }
 /** Risk of a single file based on its path patterns. */
 function fileRisk(path) {
-    if (matchGlob('**/auth/**', path) || matchGlob('**/permission/**', path) ||
-        matchGlob('**/rbac/**', path) || matchGlob('**/schema/**', path) ||
-        matchGlob('**/migrations/**', path) || matchGlob('**/prisma/**', path)) {
+    if (matchGlob('**/auth/**', path) ||
+        matchGlob('**/permission/**', path) ||
+        matchGlob('**/rbac/**', path) ||
+        matchGlob('**/schema/**', path) ||
+        matchGlob('**/migrations/**', path) ||
+        matchGlob('**/prisma/**', path)) {
         return 'high';
     }
-    if (matchGlob('**/services/**', path) || matchGlob('**/api/**', path) ||
+    if (matchGlob('**/services/**', path) ||
+        matchGlob('**/api/**', path) ||
         matchGlob('**/components/**', path)) {
         return 'medium';
     }
@@ -103,7 +107,10 @@ export function runImpactScan(opts) {
     for (const [name, patterns] of flows) {
         const matches = changed.filter((f) => patterns.some((p) => matchGlob(p, f)));
         if (matches.length > 0) {
-            affectedFlows.push({ name, reason: `changes touch ${matches.length} file(s) in this flow: ${matches.slice(0, 3).join(', ')}` });
+            affectedFlows.push({
+                name,
+                reason: `changes touch ${matches.length} file(s) in this flow: ${matches.slice(0, 3).join(', ')}`
+            });
         }
     }
     // Predict other files that may be affected (siblings of changed files).

package/dist/services/job/job-commit-verification.d.ts

@@ -0,0 +1,73 @@
+/**
+ * D2 (rid 2026-10-03-job-ledger-truthfulness) — can this commit sha be proved to
+ * exist in this repository?
+ *
+ * WHY THIS EXISTS. `peaks job checkpoint --state done --commit-sha <sha>` checked
+ * only `sha.length >= 7` (`job-orchestrator.ts:55`), so a typo'd sha was accepted
+ * and written into the ledger. Measured 2026-10-02 on `2026-10-02-c-wave9`, and
+ * again for this slice against the committed build: a 12-hex string that
+ * `git cat-file` calls `Not a valid object name` produced `ok: true` and a
+ * `state.json` whose `commitSha` named it. A ledger that points at a commit which
+ * does not exist is worse than no ledger, because it will be trusted later.
+ *
+ * WHY A GIT CALL AND NOT A REGEX. Length and alphabet say the string is
+ * sha-SHAPED; only the repository says whether the commit EXISTS. So the shape
+ * rule stays where it is (the checkpoint input schema's ≥7 pre-filter, which
+ * keeps a malformed string from paying a `git` call), and this module answers the
+ * one question git can answer: `git cat-file -e <sha>^{commit}`.
+ *
+ * THE BOUNDARY, STATED PLAINLY. Where the project root is not a git repository
+ * there is no "that repo" in which the sha could resolve, and git says so
+ * (`status: 'no-repository'`). That is not a verdict about the sha, so the
+ * checkpoint proceeds and records the claim exactly as it did before this slice —
+ * loudly named here rather than smuggled through, because the job suites run
+ * against tmp workspaces and a silent widening of the refusal to cover them would
+ * be a behaviour change this slice did not ask for.
+ *
+ * No writes, no locks, no state: one read-only question to git, four answers.
+ */
+/**
+ * The four things git can tell us about a sha-shaped string in a directory.
+ *
+ * - `verified`        — the sha resolves to a commit here.
+ * - `unresolved`      — a repository IS present and says this sha is not a
+ *                       commit. The refusal case.
+ * - `no-repository`   — no repository at or above `projectRoot`; nothing to
+ *                       check the claim against.
+ * - `git-unavailable` — `git` itself could not be run. Also not a verdict about
+ *                       the sha, and deliberately distinct from `no-repository`:
+ *                       a broken tool must never read as "this repo has no git".
+ */
+export type CommitVerification = {
+    readonly status: 'verified';
+    readonly sha: string;
+} | {
+    readonly status: 'unresolved';
+    readonly sha: string;
+    readonly detail: string;
+} | {
+    readonly status: 'no-repository';
+    readonly detail: string;
+} | {
+    readonly status: 'git-unavailable';
+    readonly detail: string;
+};
+/**
+ * Ask the repository whether `commitSha` is a commit in it.
+ *
+ * `commitSha` is expected to have already passed the caller's shape pre-filter;
+ * it is interpolated into git's *argument list* (never a shell string), so a
+ * value like `../..` reaches git as one argv slot rather than as a path to
+ * resolve.
+ */
+export declare function verifyCommitSha(projectRoot: string, commitSha: string): CommitVerification;
+/**
+ * The refusal sentence, or `null` when the claim may be recorded.
+ *
+ * Lives next to the check rather than at the call site so every consumer of the
+ * verdict says the same thing: the sha it was given, that it does not resolve,
+ * and where it looked. `git-unavailable` refuses too — a ledger entry whose
+ * commit could not be checked because git would not run is a claim the tool
+ * should say it could not honour, not one it quietly wrote.
+ */
+export declare function commitVerificationRefusal(verification: CommitVerification, projectRoot: string, commitSha: string): string | null;

package/dist/services/job/job-commit-verification.js

@@ -0,0 +1,72 @@
+/**
+ * D2 (rid 2026-10-03-job-ledger-truthfulness) — can this commit sha be proved to
+ * exist in this repository?
+ *
+ * WHY THIS EXISTS. `peaks job checkpoint --state done --commit-sha <sha>` checked
+ * only `sha.length >= 7` (`job-orchestrator.ts:55`), so a typo'd sha was accepted
+ * and written into the ledger. Measured 2026-10-02 on `2026-10-02-c-wave9`, and
+ * again for this slice against the committed build: a 12-hex string that
+ * `git cat-file` calls `Not a valid object name` produced `ok: true` and a
+ * `state.json` whose `commitSha` named it. A ledger that points at a commit which
+ * does not exist is worse than no ledger, because it will be trusted later.
+ *
+ * WHY A GIT CALL AND NOT A REGEX. Length and alphabet say the string is
+ * sha-SHAPED; only the repository says whether the commit EXISTS. So the shape
+ * rule stays where it is (the checkpoint input schema's ≥7 pre-filter, which
+ * keeps a malformed string from paying a `git` call), and this module answers the
+ * one question git can answer: `git cat-file -e <sha>^{commit}`.
+ *
+ * THE BOUNDARY, STATED PLAINLY. Where the project root is not a git repository
+ * there is no "that repo" in which the sha could resolve, and git says so
+ * (`status: 'no-repository'`). That is not a verdict about the sha, so the
+ * checkpoint proceeds and records the claim exactly as it did before this slice —
+ * loudly named here rather than smuggled through, because the job suites run
+ * against tmp workspaces and a silent widening of the refusal to cover them would
+ * be a behaviour change this slice did not ask for.
+ *
+ * No writes, no locks, no state: one read-only question to git, four answers.
+ */
+import { spawnSync } from 'node:child_process';
+/** The suffix that turns a sha into "the commit it names", per git's own grammar. */
+const COMMIT_DEREF = '^{commit}';
+/** git's own words for "this directory is not a repository" (all locales we ship). */
+const NOT_A_REPOSITORY = /not a git repository/i;
+/**
+ * Ask the repository whether `commitSha` is a commit in it.
+ *
+ * `commitSha` is expected to have already passed the caller's shape pre-filter;
+ * it is interpolated into git's *argument list* (never a shell string), so a
+ * value like `../..` reaches git as one argv slot rather than as a path to
+ * resolve.
+ */
+export function verifyCommitSha(projectRoot, commitSha) {
+    const res = spawnSync('git', ['-C', projectRoot, 'cat-file', '-e', `${commitSha}${COMMIT_DEREF}`], { encoding: 'utf8', windowsHide: true });
+    if (res.error !== undefined && res.error !== null) {
+        return { status: 'git-unavailable', detail: res.error.message };
+    }
+    const detail = (res.stderr ?? '').trim();
+    if (res.status === 0)
+        return { status: 'verified', sha: commitSha };
+    if (NOT_A_REPOSITORY.test(detail))
+        return { status: 'no-repository', detail };
+    return { status: 'unresolved', sha: commitSha, detail };
+}
+/**
+ * The refusal sentence, or `null` when the claim may be recorded.
+ *
+ * Lives next to the check rather than at the call site so every consumer of the
+ * verdict says the same thing: the sha it was given, that it does not resolve,
+ * and where it looked. `git-unavailable` refuses too — a ledger entry whose
+ * commit could not be checked because git would not run is a claim the tool
+ * should say it could not honour, not one it quietly wrote.
+ */
+export function commitVerificationRefusal(verification, projectRoot, commitSha) {
+    if (verification.status === 'verified' || verification.status === 'no-repository') {
+        return null;
+    }
+    const detail = verification.detail.length > 0 ? ` (${verification.detail})` : '';
+    if (verification.status === 'git-unavailable') {
+        return `commitSha "${commitSha}" could not be checked: git did not run in "${projectRoot}"${detail}`;
+    }
+    return `commitSha "${verification.sha}" does not resolve to a commit in "${projectRoot}"${detail}`;
+}

package/dist/services/job/job-orchestrator.d.ts

@@ -15,10 +15,52 @@ export interface BlockInput {
     sliceId: string;
     reason: string;
 }
+/** `peaks job add-slice` input, after the command has trimmed and checked shape. */
+export interface AddSliceInput {
+    readonly jobId: string;
+    readonly label: string;
+}
+/**
+ * What `addSlice` did. `added: false` is a SUCCESSFUL outcome — the label was
+ * already a slice of this job, so the honest answer is the slice that exists and
+ * a state file that was not written.
+ */
+export interface AddSliceOutcome {
+    readonly added: boolean;
+    readonly sliceId: string;
+    readonly label: string;
+    readonly total: number;
+}
 export declare class JobOrchestrator {
     private readonly store;
     constructor(store: JobStateStore);
     init(input: JobInitInput): JobState;
+    /**
+     * D1 (rid 2026-10-03-job-ledger-truthfulness) — register one more slice on an
+     * existing job.
+     *
+     * WHY THIS EXISTS. The slice list was decided once, at `peaks job init
+     * --slice-list`, and nothing could add to it. A wave that discovers its slices
+     * one at a time — which is how every split wave in this repository actually
+     * runs — could not record the slices it found: `checkpoint --slice-id
+     * <new-work>` answered `SLICE_NOT_FOUND` and `progress` kept reporting the
+     * `total` `init` wrote, so the ledger recorded the tooling's limitation instead
+     * of the work.
+     *
+     * THE CONTRACT, and the parts of it that are the point:
+     * - **idempotent and honest** — a label already registered on this job is
+     *   reported as itself with `added: false`, and `state.json` is never opened
+     *   for writing. Re-running the command cannot grow the job.
+     * - **never a silent duplicate** — an empty or whitespace-only label throws;
+     *   the command turns that into a structured refusal before it gets here.
+     * - **`total` follows** — the count every reader derives from `slices.length`
+     *   (`status`, `progress`, `continue`), so nothing has to be re-initialised.
+     *
+     * The label is the caller's string; `sliceId` stays the CLI's own
+     * `slice-NNN`, so `checkpoint`/`block` resolve the new slice by either name
+     * through the existing D7 resolution in `job-commands.ts`.
+     */
+    addSlice(input: AddSliceInput): AddSliceOutcome;
     /**
      * Atomically apply a mutation to a job's state under a single-process lock.
      *

package/dist/services/job/job-orchestrator.js

@@ -1,3 +1,23 @@
+/**
+ * `3` = the zero-padding width of the CLI's own `slice-NNN` id, the same width
+ * `JobStateStore.init` writes. Named because the pad is a convention, not a
+ * number to repeat.
+ */
+const SLICE_ID_PAD_WIDTH = 3;
+/**
+ * The next free `slice-NNN` id: one past the highest number already in use, not
+ * `length + 1`. Two jobs whose slices were added out of order therefore cannot
+ * collide, and a list that somehow holds 12 slices still gets `slice-012`.
+ */
+function nextSliceId(slices) {
+    let highest = 0;
+    for (const sl of slices) {
+        const digits = /^slice-(\d+)$/.exec(sl.sliceId);
+        if (digits !== null)
+            highest = Math.max(highest, Number(digits[1]));
+    }
+    return `slice-${String(highest + 1).padStart(SLICE_ID_PAD_WIDTH, '0')}`;
+}
 export class JobOrchestrator {
     store;
     constructor(store) {
@@ -6,6 +26,68 @@ export class JobOrchestrator {
     init(input) {
         return this.store.init(input);
     }
+    /**
+     * D1 (rid 2026-10-03-job-ledger-truthfulness) — register one more slice on an
+     * existing job.
+     *
+     * WHY THIS EXISTS. The slice list was decided once, at `peaks job init
+     * --slice-list`, and nothing could add to it. A wave that discovers its slices
+     * one at a time — which is how every split wave in this repository actually
+     * runs — could not record the slices it found: `checkpoint --slice-id
+     * <new-work>` answered `SLICE_NOT_FOUND` and `progress` kept reporting the
+     * `total` `init` wrote, so the ledger recorded the tooling's limitation instead
+     * of the work.
+     *
+     * THE CONTRACT, and the parts of it that are the point:
+     * - **idempotent and honest** — a label already registered on this job is
+     *   reported as itself with `added: false`, and `state.json` is never opened
+     *   for writing. Re-running the command cannot grow the job.
+     * - **never a silent duplicate** — an empty or whitespace-only label throws;
+     *   the command turns that into a structured refusal before it gets here.
+     * - **`total` follows** — the count every reader derives from `slices.length`
+     *   (`status`, `progress`, `continue`), so nothing has to be re-initialised.
+     *
+     * The label is the caller's string; `sliceId` stays the CLI's own
+     * `slice-NNN`, so `checkpoint`/`block` resolve the new slice by either name
+     * through the existing D7 resolution in `job-commands.ts`.
+     */
+    addSlice(input) {
+        const label = input.label.trim();
+        if (label.length === 0) {
+            throw new Error('addSlice: slice label must not be empty');
+        }
+        const before = this.store.load(input.jobId);
+        const already = before.slices.find((sl) => sl.label === label);
+        if (already !== undefined) {
+            return {
+                added: false,
+                sliceId: already.sliceId,
+                label: already.label,
+                total: before.slices.length
+            };
+        }
+        const after = this.mutate(input.jobId, (s) => {
+            if (s.slices.some((sl) => sl.label === label))
+                return s;
+            const appended = {
+                sliceId: nextSliceId(s.slices),
+                label,
+                status: 'pending',
+                repairCycles: 0
+            };
+            return { ...s, slices: [...s.slices, appended] };
+        });
+        const registered = after.slices.find((sl) => sl.label === label);
+        if (registered === undefined) {
+            throw new Error(`addSlice: internal — "${label}" is not registered in the saved state for ${input.jobId}`);
+        }
+        return {
+            added: after.slices.length > before.slices.length,
+            sliceId: registered.sliceId,
+            label: registered.label,
+            total: after.slices.length
+        };
+    }
     /**
      * Atomically apply a mutation to a job's state under a single-process lock.
      *
@@ -41,8 +123,13 @@ export class JobOrchestrator {
                 ...s,
                 lastCheckpointAt: new Date().toISOString(),
                 slices: s.slices.map((sl) => sl.sliceId === input.sliceId
-                    ? { ...sl, status: 'done', commitSha: input.commitSha, finishedAt: new Date().toISOString() }
-                    : sl),
+                    ? {
+                        ...sl,
+                        status: 'done',
+                        commitSha: input.commitSha,
+                        finishedAt: new Date().toISOString()
+                    }
+                    : sl)
             };
         });
     }
@@ -50,7 +137,7 @@ export class JobOrchestrator {
         return this.mutate(input.jobId, (s) => ({
             ...s,
             lastCheckpointAt: new Date().toISOString(),
-            slices: s.slices.map((sl) => sl.sliceId === input.sliceId ? { ...sl, status: 'skipped' } : sl),
+            slices: s.slices.map((sl) => sl.sliceId === input.sliceId ? { ...sl, status: 'skipped' } : sl)
         }));
     }
     async checkpointFailed(input) {
@@ -58,8 +145,13 @@ export class JobOrchestrator {
             ...s,
             lastCheckpointAt: new Date().toISOString(),
             slices: s.slices.map((sl) => sl.sliceId === input.sliceId
-                ? { ...sl, status: 'failed', failureReason: input.reason, finishedAt: new Date().toISOString() }
-                : sl),
+                ? {
+                    ...sl,
+                    status: 'failed',
+                    failureReason: input.reason,
+                    finishedAt: new Date().toISOString()
+                }
+                : sl)
         }));
     }
     async blockSlice(input) {
@@ -67,8 +159,13 @@ export class JobOrchestrator {
             ...s,
             lastCheckpointAt: new Date().toISOString(),
             slices: s.slices.map((sl) => sl.sliceId === input.sliceId
-                ? { ...sl, status: 'blocked', blockedReason: input.reason, finishedAt: new Date().toISOString() }
-                : sl),
+                ? {
+                    ...sl,
+                    status: 'blocked',
+                    blockedReason: input.reason,
+                    finishedAt: new Date().toISOString()
+                }
+                : sl)
         }));
     }
     status(jobId) {
@@ -84,7 +181,7 @@ export class JobOrchestrator {
             else if (sl.status === 'skipped')
                 counts.skipped++;
         }
-        const pendingIdx = s.slices.findIndex(sl => sl.status === 'pending' || sl.status === 'in-progress');
+        const pendingIdx = s.slices.findIndex((sl) => sl.status === 'pending' || sl.status === 'in-progress');
         return {
             total: s.slices.length,
             done: counts.done,
@@ -94,11 +191,14 @@ export class JobOrchestrator {
             currentSlice: pendingIdx >= 0 ? s.slices[pendingIdx].label : undefined,
             lastCheckpoint: s.lastCheckpointAt,
             mainLoopStrategy: s.mainLoopStrategy,
-            mainSessionCycle: s.mainSessionCycle,
+            mainSessionCycle: s.mainSessionCycle
         };
     }
     continueNow(jobId) {
         const summary = this.status(jobId);
-        return { remaining: summary.total - summary.done - summary.skipped - summary.blocked - summary.failed, next: summary.currentSlice };
+        return {
+            remaining: summary.total - summary.done - summary.skipped - summary.blocked - summary.failed,
+            next: summary.currentSlice
+        };
     }
 }