peaks-loop 4.0.54 → 4.1.0

package/dist/services/dispatch/dispatch-record-writer.js

@@ -126,25 +126,36 @@ function buildInitialDispatchRecord(input, now) {
         // `null` for legacy / ad-hoc dispatches that do not bind a graph
         // node; v4.0.0 schema is structural (required field), so a `null`
         // is the explicit "no binding" state.
-        workflowId: typeof input.workflowId === 'string' && /^[a-zA-Z0-9._-]{1,200}$/.test(input.workflowId) ? input.workflowId : null,
-        graphNodeId: typeof input.graphNodeId === 'string' && /^[a-zA-Z0-9._-]{1,200}$/.test(input.graphNodeId) ? input.graphNodeId : null,
+        workflowId: typeof input.workflowId === 'string' && /^[a-zA-Z0-9._-]{1,200}$/.test(input.workflowId)
+            ? input.workflowId
+            : null,
+        graphNodeId: typeof input.graphNodeId === 'string' && /^[a-zA-Z0-9._-]{1,200}$/.test(input.graphNodeId)
+            ? input.graphNodeId
+            : null,
         graphRef: typeof input.graphRef === 'string' && input.graphRef.length > 0 ? input.graphRef : null,
         // Phase A Task 8: detached sub-agent mode (default in-process).
         mode: input.mode === 'detached' ? 'detached' : 'in-process',
-        vendor: input.vendor === 'claude' || input.vendor === 'codex' || input.vendor === 'copilot' ? input.vendor : null,
+        vendor: input.vendor === 'claude' || input.vendor === 'codex' || input.vendor === 'copilot'
+            ? input.vendor
+            : null,
         autoCompactEvents: Array.isArray(input.autoCompactEvents)
             ? input.autoCompactEvents.filter((e) => typeof e?.at === 'number' &&
                 (e?.threshold === '0.85' || e?.threshold === '0.95') &&
                 typeof e?.tokensBefore === 'number' &&
                 typeof e?.tokensAfter === 'number')
             : [],
-        tokenUsage: typeof input.tokenUsage === 'object' && input.tokenUsage !== null && typeof input.tokenUsage.promptTokens === 'number' && typeof input.tokenUsage.completionTokens === 'number'
+        tokenUsage: typeof input.tokenUsage === 'object' &&
+            input.tokenUsage !== null &&
+            typeof input.tokenUsage.promptTokens === 'number' &&
+            typeof input.tokenUsage.completionTokens === 'number'
             ? {
                 promptTokens: input.tokenUsage.promptTokens,
                 completionTokens: input.tokenUsage.completionTokens,
-                ...(typeof input.tokenUsage.totalCostUsd === 'number' ? { totalCostUsd: input.tokenUsage.totalCostUsd } : {}),
+                ...(typeof input.tokenUsage.totalCostUsd === 'number'
+                    ? { totalCostUsd: input.tokenUsage.totalCostUsd }
+                    : {})
             }
-            : null,
+            : null
     };
 }
 function activeDispatchIndexPath(projectRoot, sessionId) {
@@ -306,10 +317,7 @@ export function appendHeartbeat(input) {
         // our pre-lock `readRecord` above and lock acquisition (heartbeats
         // and markCompleted share the same record file).
         const lockedExisting = readRecord(recordPath);
-        const lockedHeartbeats = applyTruncation([
-            ...lockedExisting.heartbeats,
-            entry
-        ]).heartbeats;
+        const lockedHeartbeats = applyTruncation([...lockedExisting.heartbeats, entry]).heartbeats;
         const lockedNext = {
             ...lockedExisting,
             heartbeats: lockedHeartbeats,
@@ -395,10 +403,14 @@ async function spawnLeaseReleaseChild(args) {
         const cp = await import('node:child_process');
         const child = cp.spawn(process.execPath, [
             process.argv[1] ?? '',
-            'worktree', 'release',
-            '--lease-id', args.leaseId,
-            '--project', args.projectRoot,
-            '--session', args.sessionId,
+            'worktree',
+            'release',
+            '--lease-id',
+            args.leaseId,
+            '--project',
+            args.projectRoot,
+            '--session',
+            args.sessionId,
             '--json'
         ], 
         // `pipe` rather than `ignore` so a spawn failure (e.g. ENOENT
@@ -414,9 +426,15 @@ async function spawnLeaseReleaseChild(args) {
             child.on('exit', (code) => process.stderr.write(`[release exit] code=${code}\n`));
         }
         else {
-            child.stderr?.on('data', () => { });
-            child.stdout?.on('data', () => { });
-            child.on('error', () => { });
+            child.stderr?.on('data', () => {
+                /* drain */
+            });
+            child.stdout?.on('data', () => {
+                /* drain */
+            });
+            child.on('error', () => {
+                /* detached best-effort */
+            });
         }
         child.unref();
     }
@@ -479,7 +497,9 @@ export function markCompleted(input) {
     // PEAKS_GRAPH_REF_BROKEN, etc.) is reused. Failures are swallowed
     // (best-effort; the dispatch record itself is the source of truth
     // and the transition is observable through the graph store).
-    if (result.record.workflowId !== null && result.record.graphNodeId !== null && result.record.graphRef !== null) {
+    if (result.record.workflowId !== null &&
+        result.record.graphNodeId !== null &&
+        result.record.graphRef !== null) {
         scheduleGraphEnvelopeTransition(input, result.record);
     }
     // Slice 2026-06-23-audit-4th #A4: update the active-dispatches
@@ -496,7 +516,8 @@ export function markCompleted(input) {
                 status: input.status
             });
         }
-        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 */
         }
     }
@@ -507,7 +528,9 @@ export function markCompleted(input) {
     // and best-effort; a crash here cannot roll back the markCompleted
     // write (we already returned from the lock). The next gc pass is
     // the safety net.
-    if (result.record.leaseId !== null && typeof input.projectRoot === 'string' && input.projectRoot.length > 0) {
+    if (result.record.leaseId !== null &&
+        typeof input.projectRoot === 'string' &&
+        input.projectRoot.length > 0) {
         try {
             tryAutoReleaseLease({
                 projectRoot: input.projectRoot,
@@ -515,7 +538,8 @@ export function markCompleted(input) {
                 leaseId: result.record.leaseId
             });
         }
-        catch { // best-effort; release is async anyway
+        catch {
+            // best-effort; release is async anyway
             /* swallow */
         }
     }
@@ -549,7 +573,7 @@ function scheduleGraphEnvelopeTransition(input, record) {
                             projectRoot: input.projectRoot ?? '',
                             sessionId: record.sessionId,
                             graphRef: record.graphRef ?? '',
-                            workflowId: record.workflowId ?? '',
+                            workflowId: record.workflowId ?? ''
                         });
                     }
                     catch {
@@ -562,7 +586,7 @@ function scheduleGraphEnvelopeTransition(input, record) {
                     projectRoot: input.projectRoot ?? '',
                     sessionId: record.sessionId,
                     graphRef: record.graphRef ?? '',
-                    workflowId: record.workflowId ?? '',
+                    workflowId: record.workflowId ?? ''
                 });
                 const node = graph.nodes.find((n) => n.id === record.graphNodeId);
                 if (node === undefined)
@@ -574,13 +598,17 @@ function scheduleGraphEnvelopeTransition(input, record) {
                 lifecycleMod.writeEnvelope({
                     graphNode: node,
                     dispatchRef,
-                    envelopeDispatchRef: dispatchRef,
+                    envelopeDispatchRef: dispatchRef
                 });
             }
-            catch { /* best-effort graph transition */ }
+            catch {
+                /* best-effort graph transition */
+            }
         })();
     }
-    catch { /* best-effort */ }
+    catch {
+        /* best-effort */
+    }
 }
 /** Mark a record as disposed (reducer ran). */
 export function markDisposed(recordPath, now = () => new Date()) {

package/dist/services/dispatch/dispatch-sub-agent.js

@@ -23,7 +23,12 @@
 export function runGitLsFiles(projectRoot, glob) {
     try {
         const { execFileSync } = require('node:child_process');
-        const stdout = execFileSync('git', ['ls-files', '--', glob], { cwd: projectRoot, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true });
+        const stdout = execFileSync('git', ['ls-files', '--', glob], {
+            cwd: projectRoot,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            windowsHide: true
+        });
         return stdout.split('\n').filter((line) => line.length > 0);
     }
     catch {
@@ -50,6 +55,6 @@ export async function dispatchSubAgent(input) {
     return {
         role: input.role,
         toolCall: null,
-        dispatchRecordPath: null,
+        dispatchRecordPath: null
     };
 }

package/dist/services/dispatch/e2e-fixtures.js

@@ -64,7 +64,7 @@ export function readE2EPlan(input) {
                 name: scenario,
                 file: join(scenarioDir, file),
                 url: parsed.url,
-                matchers: parsed.matchers,
+                matchers: parsed.matchers
             });
         }
     }

package/dist/services/dispatch/isolation-lease.js

@@ -21,18 +21,28 @@ export function spawnWorktreeLease(args) {
             // this for us; here we explicitly use process.execPath + the
             // resolved entry to avoid PATH surprises.
             process.argv[1] ?? '',
-            'worktree', 'spawn',
-            '--rid', args.rid,
-            '--role', args.role,
-            '--purpose', args.purpose,
-            '--project', args.projectRoot,
-            '--session', args.sessionId,
+            'worktree',
+            'spawn',
+            '--rid',
+            args.rid,
+            '--role',
+            args.role,
+            '--purpose',
+            args.purpose,
+            '--project',
+            args.projectRoot,
+            '--session',
+            args.sessionId,
             '--json'
         ], { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true, detached: true });
         let stdout = '';
         let stderr = '';
-        child.stdout.on('data', (d) => { stdout += d.toString('utf8'); });
-        child.stderr.on('data', (d) => { stderr += d.toString('utf8'); });
+        child.stdout.on('data', (d) => {
+            stdout += d.toString('utf8');
+        });
+        child.stderr.on('data', (d) => {
+            stderr += d.toString('utf8');
+        });
         child.on('error', (err) => reject(new Error(`worktree spawn subprocess failed: ${err.message}`)));
         child.on('close', (code) => {
             if (code !== 0) {
@@ -68,7 +78,9 @@ export function spawnWorktreeLease(args) {
             // child handle. Without this microtask defer, the unref
             // races the buffered stdout close and the test receives
             // an empty JSON envelope.
-            setImmediate(() => { child.unref(); });
+            setImmediate(() => {
+                child.unref();
+            });
         });
     });
 }
@@ -86,18 +98,28 @@ export function spawnContainerLease(args) {
     return new Promise((resolve, reject) => {
         const child = childProcessSpawn(process.execPath, [
             process.argv[1] ?? '',
-            'container', 'spawn',
-            '--rid', args.rid,
-            '--role', args.role,
-            '--purpose', args.purpose,
-            '--project', args.projectRoot,
-            '--session', args.sessionId,
+            'container',
+            'spawn',
+            '--rid',
+            args.rid,
+            '--role',
+            args.role,
+            '--purpose',
+            args.purpose,
+            '--project',
+            args.projectRoot,
+            '--session',
+            args.sessionId,
             '--json'
         ], { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true, detached: true });
         let stdout = '';
         let stderr = '';
-        child.stdout.on('data', (d) => { stdout += d.toString('utf8'); });
-        child.stderr.on('data', (d) => { stderr += d.toString('utf8'); });
+        child.stdout.on('data', (d) => {
+            stdout += d.toString('utf8');
+        });
+        child.stderr.on('data', (d) => {
+            stderr += d.toString('utf8');
+        });
         child.on('error', (err) => reject(new Error(`container spawn subprocess failed: ${err.message}`)));
         child.on('close', (code) => {
             if (code !== 0) {

package/dist/services/dispatch/merge-back-runner.js

@@ -21,7 +21,11 @@ function readRegistrations(input) {
 }
 function captureConflictDiff(input) {
     try {
-        return execFileSync('git', ['diff', '--merge', '--no-color'], { cwd: input.projectRoot, encoding: 'utf8', windowsHide: true });
+        return execFileSync('git', ['diff', '--merge', '--no-color'], {
+            cwd: input.projectRoot,
+            encoding: 'utf8',
+            windowsHide: true
+        });
     }
     catch {
         return '';
@@ -29,7 +33,11 @@ function captureConflictDiff(input) {
 }
 function captureTranscript(input) {
     try {
-        return execFileSync('git', ['merge', '--no-edit', '--no-ff', input.agentBranch], { cwd: input.projectRoot, encoding: 'utf8', windowsHide: true }).split('\n');
+        return execFileSync('git', ['merge', '--no-edit', '--no-ff', input.agentBranch], {
+            cwd: input.projectRoot,
+            encoding: 'utf8',
+            windowsHide: true
+        }).split('\n');
     }
     catch {
         return ['git merge --no-edit --no-ff ' + input.agentBranch];
@@ -45,7 +53,7 @@ export async function runMergeBack(input) {
             callerBranch: input.callerBranch,
             agentBranch: input.agentBranch,
             commitsBehind: 0,
-            conflictingFiles: [],
+            conflictingFiles: []
         });
         if (plan.kind === 'noop')
             return { kind: 'noop', attempts, serviceKills: kills };
@@ -53,29 +61,61 @@ export async function runMergeBack(input) {
             return { kind: 'replay-exhausted', attempts, serviceKills: kills };
         if (plan.kind === 'conflict') {
             const conflictDiff = captureConflictDiff(input);
-            const replay = buildConflictReplay({ originalPrompt, mergeAttemptTranscript: [], conflictDiff, callerBranch: input.callerBranch });
+            const replay = buildConflictReplay({
+                originalPrompt,
+                mergeAttemptTranscript: [],
+                conflictDiff,
+                callerBranch: input.callerBranch
+            });
             const replayResult = await input.onConflict(replay);
             if (!replayResult.ok) {
-                return { kind: attempts >= 2 ? 'replay-exhausted' : 'replay-still-conflict', attempts, serviceKills: kills };
+                return {
+                    kind: attempts >= 2 ? 'replay-exhausted' : 'replay-still-conflict',
+                    attempts,
+                    serviceKills: kills
+                };
             }
             continue;
         }
         try {
-            execFileSync('git', ['checkout', input.callerBranch], { cwd: input.projectRoot, stdio: 'ignore', windowsHide: true });
-            execFileSync(plan.command[0], plan.command.slice(1), { cwd: input.projectRoot, stdio: 'ignore', windowsHide: true });
+            execFileSync('git', ['checkout', input.callerBranch], {
+                cwd: input.projectRoot,
+                stdio: 'ignore',
+                windowsHide: true
+            });
+            execFileSync(plan.command[0], plan.command.slice(1), {
+                cwd: input.projectRoot,
+                stdio: 'ignore',
+                windowsHide: true
+            });
             return { kind: 'merged', attempts, serviceKills: kills };
         }
         catch (error) {
             const transcript = captureTranscript(input);
             const conflictDiff = captureConflictDiff(input);
-            const replay = buildConflictReplay({ originalPrompt, mergeAttemptTranscript: transcript, conflictDiff, callerBranch: input.callerBranch });
+            const replay = buildConflictReplay({
+                originalPrompt,
+                mergeAttemptTranscript: transcript,
+                conflictDiff,
+                callerBranch: input.callerBranch
+            });
             const replayResult = await input.onConflict(replay);
             try {
-                execFileSync('git', ['merge', '--abort'], { cwd: input.projectRoot, stdio: 'ignore', windowsHide: true });
+                execFileSync('git', ['merge', '--abort'], {
+                    cwd: input.projectRoot,
+                    stdio: 'ignore',
+                    windowsHide: true
+                });
+            }
+            catch {
+                /* ignore */
             }
-            catch { /* ignore */ }
             if (!replayResult.ok) {
-                return { kind: attempts >= 2 ? 'replay-exhausted' : 'replay-still-conflict', attempts, serviceKills: kills };
+                return {
+                    kind: attempts >= 2 ? 'replay-exhausted' : 'replay-still-conflict',
+                    attempts,
+                    serviceKills: kills
+                };
             }
         }
     }

package/dist/services/dispatch/service-shutdown.js

@@ -30,7 +30,10 @@ export function killRegisteredServices(input) {
         }
         try {
             if (platform === 'win32') {
-                execFileSync('taskkill', ['/T', '/F', '/PID', String(reg.pid)], { stdio: 'ignore', windowsHide: true });
+                execFileSync('taskkill', ['/T', '/F', '/PID', String(reg.pid)], {
+                    stdio: 'ignore',
+                    windowsHide: true
+                });
                 return { pid: reg.pid, name: reg.name, skipped: false, signal: 'taskkill' };
             }
             // POSIX: try SIGTERM via the `kill` CLI (universally available);

package/dist/services/dispatch/slice-dag-types.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Slice DAG type surface — moved VERBATIM out of `slice-dag.ts` for the
+ * 300-raw-line cap (slice `b1-filesplit-campaign`, wave 3C). No behavior
+ * lives here: node/edge model types, the complexity tier, and the two
+ * error classes, plus the wave-plan envelopes. `slice-dag.ts` re-exports
+ * every name from this module, so all existing import paths keep working.
+ */
+/**
+ * Slice complexity tier (v2.15.0 follow-up, G2 in 12 Gaps).
+ * Used by Code to schedule complex slices during user-attended hours
+ * and trivial / simple slices overnight.
+ */
+export type SliceComplexity = 'trivial' | 'simple' | 'complex';
+export declare const SLICE_COMPLEXITIES: readonly SliceComplexity[];
+export declare function isSliceComplexity(value: string): value is SliceComplexity;
+export interface SliceNode {
+    readonly id: string;
+    readonly role: string;
+    /** Human-readable label, optional. */
+    readonly label?: string;
+    /** Optional prompt override; dispatch falls back to a default placeholder. */
+    readonly prompt?: string;
+    /**
+     * v2.15.0 follow-up — G12: foundation slice. Foundation slices run before
+     * business slices in the layered DAG. Business slices do NOT wait for
+     * ALL foundation slices — they wait only for the foundation subset
+     * they declare as `dependsOn`. Optional; default false.
+     */
+    readonly foundation?: boolean;
+    /**
+     * v2.15.0 follow-up — G11: upstream sync slice. Marks a slice that
+     * syncs an upstream fork (e.g. hermes) to a new tag. UpstreamSync
+     * slices take priority within their topological level. Optional.
+     */
+    readonly upstreamSync?: boolean;
+    /**
+     * v2.15.0 follow-up — G2: complexity tier. Drives Code's scheduling
+     * (complex = user-attended, simple/trivial = overnight). Optional.
+     */
+    readonly complexity?: SliceComplexity;
+    /**
+     * Slice 2026-09-10-dispatch-token-and-swarm §3: files this slice is
+     * expected to touch. When EVERY node of a topological level declares
+     * `files`, `--from-dag` emits a file-overlap wave plan (`firstLevelWaves`)
+     * so the LLM can fan the level out without serializing on a shared file.
+     * Optional and additive: absent → DAG hash and dispatch behavior are
+     * byte-identical to before this slice.
+     */
+    readonly files?: readonly string[];
+}
+export interface DependsOn {
+    readonly from: string;
+    readonly to: string;
+}
+export interface SliceDag {
+    readonly nodes: readonly SliceNode[];
+    readonly edges: readonly DependsOn[];
+}
+/** Thrown by `validateDag` when the graph violates one of the constraints. */
+export declare class InvalidSliceDagError extends Error {
+    readonly path?: readonly string[] | undefined;
+    readonly code: "INVALID_SLICE_DAG";
+    constructor(message: string, path?: readonly string[] | undefined);
+}
+/** Thrown by `topologicalLevels` when the graph has a cycle (defensive). */
+export declare class SliceDagCycleError extends Error {
+    readonly cyclePath: readonly string[];
+    readonly code: "SLICE_DAG_CYCLE";
+    constructor(cyclePath: readonly string[]);
+}
+/**
+ * Knobs for wave planning + artifact-pass behaviour.
+ *
+ * - `maxConcurrency`: hard cap on how many slices a single Wave can hold.
+ *   Each topological level is chunked into Waves of at most this many
+ *   slice IDs (default 6 per `2026-07-28-24h-loop-audit.md` E direction).
+ * - `passArtifacts`: when true, each Wave's prompt is augmented with a
+ *   `WaveArtifact` envelope (contracts of preceding Waves). Default
+ *   false — the existing `runDag` ancestor-injection path already covers
+ *   per-slice contract coverage.
+ */
+export interface WaveOptions {
+    readonly maxConcurrency: number;
+    readonly passArtifacts: boolean;
+}
+/** Default wave options: 6 leaves per wave; artifact-pass off. */
+export declare const DEFAULT_MAX_CONCURRENCY = 6;
+export declare const DEFAULT_WAVE_OPTIONS: WaveOptions;
+/**
+ * Artifact envelope emitted when a Wave completes successfully.
+ *
+ * - `waveIndex`: sequential, 0-based across the whole plan.
+ * - `completedLeaves`: slice IDs that finished (`status: 'done'`). Failed
+ *    or cancelled leaves are NOT included.
+ * - `contracts`: per-slice public contract snapshot (sliceId → record).
+ *    Stored verbatim so a downstream Wave can re-inject this without
+ *    re-reading the disk-side contract store.
+ * - `passedAt`: ISO timestamp of Wave completion (caller-supplied to keep
+ *    the surface pure).
+ */
+export interface WaveArtifact {
+    readonly waveIndex: number;
+    readonly completedLeaves: readonly string[];
+    readonly contracts: Readonly<Record<string, unknown>>;
+    readonly passedAt: string;
+}
+/**
+ * A single dispatch Wave. Holds the slice IDs that must execute together,
+ * respecting `WaveOptions.maxConcurrency`. Waves are emitted in
+ * topological order; downstream consumers may treat `waveIndex` as a
+ * monotonic cursor.
+ */
+export interface Wave {
+    readonly waveIndex: number;
+    readonly slices: readonly string[];
+}

package/dist/services/dispatch/slice-dag-types.js

@@ -0,0 +1,41 @@
+/**
+ * Slice DAG type surface — moved VERBATIM out of `slice-dag.ts` for the
+ * 300-raw-line cap (slice `b1-filesplit-campaign`, wave 3C). No behavior
+ * lives here: node/edge model types, the complexity tier, and the two
+ * error classes, plus the wave-plan envelopes. `slice-dag.ts` re-exports
+ * every name from this module, so all existing import paths keep working.
+ */
+export const SLICE_COMPLEXITIES = [
+    'trivial',
+    'simple',
+    'complex'
+];
+export function isSliceComplexity(value) {
+    return SLICE_COMPLEXITIES.includes(value);
+}
+/** Thrown by `validateDag` when the graph violates one of the constraints. */
+export class InvalidSliceDagError extends Error {
+    path;
+    code = 'INVALID_SLICE_DAG';
+    constructor(message, path) {
+        super(message);
+        this.path = path;
+        this.name = 'InvalidSliceDagError';
+    }
+}
+/** Thrown by `topologicalLevels` when the graph has a cycle (defensive). */
+export class SliceDagCycleError extends Error {
+    cyclePath;
+    code = 'SLICE_DAG_CYCLE';
+    constructor(cyclePath) {
+        super(`cycle detected in slice DAG: ${cyclePath.join(' -> ')}`);
+        this.cyclePath = cyclePath;
+        this.name = 'SliceDagCycleError';
+    }
+}
+/** Default wave options: 6 leaves per wave; artifact-pass off. */
+export const DEFAULT_MAX_CONCURRENCY = 6;
+export const DEFAULT_WAVE_OPTIONS = {
+    maxConcurrency: DEFAULT_MAX_CONCURRENCY,
+    passArtifacts: false
+};