peaks-loop 4.0.7 → 4.0.8

package/dist/services/workflow/workflow-presence-lifecycle.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Workflow presence lifecycle — atomic terminalization coordination
+ * (RD §3 D4c + §4 — slice 4.0.8 presence-lease-graph).
+ *
+ * Workflow init atomically creates a graph + canonical lease + caller
+ * index under one lifecycle lock. Terminalize atomically updates the
+ * terminal graph node, the lease's terminal fields, the caller
+ * index, and emits exactly one observability event. Both transitions
+ * are pure orchestrators — they delegate atomic writes to the graph
+ * store and lease service.
+ */
+import { type WorkflowGraph, type WorkflowId, type TerminalReason } from './workflow-graph-types.js';
+import type { SkillPresenceLease, PresenceIndex } from '../skills/presence-lease-types.js';
+export interface InitWorkflowInput {
+    readonly projectRoot: string;
+    readonly sessionId: string;
+    readonly callerId: string;
+    readonly skill: string;
+    readonly workflowId?: WorkflowId;
+    readonly parentWorkflowId?: WorkflowId;
+    readonly graphRef?: string;
+    readonly depth?: number;
+    readonly now?: string;
+}
+export interface InitWorkflowResult {
+    readonly workflowId: WorkflowId;
+    readonly graphRef: string;
+    readonly graph: WorkflowGraph;
+    readonly lease: SkillPresenceLease;
+    readonly index: PresenceIndex;
+    readonly events: ReadonlyArray<Record<string, unknown>>;
+}
+export interface TerminalizeWorkflowInput {
+    readonly projectRoot: string;
+    readonly sessionId: string;
+    readonly callerId: string;
+    readonly workflowId: WorkflowId;
+    readonly graphRef: string;
+    readonly reason: TerminalReason;
+    readonly requireConsumed?: boolean;
+    readonly now?: string;
+}
+export interface TerminalizeWorkflowResult {
+    readonly lease: SkillPresenceLease;
+    readonly graph: WorkflowGraph;
+    readonly events: ReadonlyArray<Record<string, unknown>>;
+    readonly indexCleared: boolean;
+}
+export interface TerminalizeError extends Error {
+    readonly code: string;
+    readonly successEventCount?: number;
+    readonly consistent?: boolean;
+}
+export declare function initWorkflow(input: InitWorkflowInput): Promise<InitWorkflowResult>;
+export declare function terminalizeWorkflow(input: TerminalizeWorkflowInput): Promise<TerminalizeWorkflowResult>;
+export declare function readWorkflowLease(projectRoot: string, sessionId: string, callerId: string, workflowId: string): import("../skills/presence-lease-types.js").PresenceProjection;
+export declare function graphFileExists(projectRoot: string, sessionId: string, workflowId: string): boolean;
+export declare function readGraphFile(projectRoot: string, sessionId: string, workflowId: string): string;

package/dist/services/workflow/workflow-presence-lifecycle.js

@@ -0,0 +1,196 @@
+/**
+ * Workflow presence lifecycle — atomic terminalization coordination
+ * (RD §3 D4c + §4 — slice 4.0.8 presence-lease-graph).
+ *
+ * Workflow init atomically creates a graph + canonical lease + caller
+ * index under one lifecycle lock. Terminalize atomically updates the
+ * terminal graph node, the lease's terminal fields, the caller
+ * index, and emits exactly one observability event. Both transitions
+ * are pure orchestrators — they delegate atomic writes to the graph
+ * store and lease service.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { TERMINAL_REASONS, } from './workflow-graph-types.js';
+import { emptyGraph, readGraph, writeGraph, validateGraph, graphPathFor, PEAKS_GRAPH_NOT_FOUND, PEAKS_GRAPH_CORRUPTED, PEAKS_TERMINALIZE_ATOMICITY_FAILED, PEAKS_TERMINAL_REASON_INVALID, } from './workflow-graph-store.js';
+import { setPresenceLease, readPresenceLease, markPresenceLost, } from '../skills/presence-lease-service.js';
+function lifeError(code, message, extra = {}) {
+    const err = new Error(message);
+    err.name = 'TerminalizeError';
+    err.code = code;
+    Object.assign(err, extra);
+    return err;
+}
+/* ---------- Init ---------- */
+export async function initWorkflow(input) {
+    const workflowId = input.workflowId ?? `wf-${Date.now().toString(36)}`;
+    const graphRef = input.graphRef ?? `graphs/${workflowId}.json`;
+    if (graphRef !== `graphs/${workflowId}.json`) {
+        throw lifeError(PEAKS_GRAPH_NOT_FOUND, `graphRef must normalize to graphs/${workflowId}.json; got ${graphRef}`);
+    }
+    const graph = emptyGraph({
+        workflowId,
+        rootSkill: input.skill,
+        ...(input.parentWorkflowId ? { parentWorkflowId: input.parentWorkflowId } : {}),
+    });
+    validateGraph(graph);
+    // Phase 1: write graph first.
+    writeGraph({
+        projectRoot: input.projectRoot,
+        sessionId: input.sessionId,
+        graphRef,
+        workflowId,
+        graph,
+        holder: `initWorkflow:${input.callerId}`,
+    });
+    // Phase 2: write lease + index.
+    const setResult = setPresenceLease({
+        projectRoot: input.projectRoot,
+        sessionId: input.sessionId,
+        callerId: input.callerId,
+        workflowId,
+        graphRef,
+        skill: input.skill,
+        ...(input.parentWorkflowId ? { parentWorkflowId: input.parentWorkflowId } : {}),
+        depth: input.depth ?? 0,
+        ...(input.now ? { now: input.now } : {}),
+    });
+    const events = [
+        {
+            kind: 'workflow-initialized',
+            schemaVersion: 1,
+            ts: new Date().toISOString(),
+            sessionId: input.sessionId,
+            callerId: input.callerId,
+            workflowId,
+            graphRef,
+        },
+    ];
+    return {
+        workflowId,
+        graphRef,
+        graph,
+        lease: setResult.lease,
+        index: setResult.index,
+        events,
+    };
+}
+/* ---------- Terminalize ---------- */
+export async function terminalizeWorkflow(input) {
+    if (!TERMINAL_REASONS.includes(input.reason)) {
+        throw lifeError(PEAKS_TERMINAL_REASON_INVALID, `invalid reason: ${input.reason}`);
+    }
+    const events = [];
+    let successEventCount = 0;
+    try {
+        // Phase 1: read graph (fail closed if missing/corrupt).
+        const graph = readGraph({
+            projectRoot: input.projectRoot,
+            sessionId: input.sessionId,
+            graphRef: input.graphRef,
+            workflowId: input.workflowId,
+        });
+        // Phase 2: check unconsumed envelopes (RD §4 terminalize contract).
+        if (input.requireConsumed === true) {
+            const pending = graph.nodes.filter((n) => n.status === 'envelope-received');
+            if (pending.length > 0) {
+                throw lifeError('PEAKS_UNCONSUMED_ENVELOPE', `graph has ${pending.length} unconsumed envelope(s)`);
+            }
+        }
+        // Phase 3: transition the terminal node to terminalized / lost.
+        const targetStatus = input.reason === 'success' || input.reason === 'aborted' ? 'terminalized' : 'lost';
+        const updatedNodes = graph.nodes.map((n) => n.kind === 'terminal'
+            ? { ...n, status: targetStatus }
+            : n);
+        const updatedGraph = { ...graph, nodes: updatedNodes };
+        validateGraph(updatedGraph);
+        // Phase 4: write the updated graph atomically.
+        writeGraph({
+            projectRoot: input.projectRoot,
+            sessionId: input.sessionId,
+            graphRef: input.graphRef,
+            workflowId: input.workflowId,
+            graph: updatedGraph,
+            holder: `terminalize:${input.callerId}`,
+        });
+        // Phase 5: mark the lease lost/terminalized. This will throw on
+        // EACCES / ENOSPC — caught at the boundary so we can emit
+        // PEAKS_TERMINALIZE_ATOMICITY_FAILED with successEventCount=0.
+        const lease = markPresenceLost({
+            projectRoot: input.projectRoot,
+            sessionId: input.sessionId,
+            callerId: input.callerId,
+            workflowId: input.workflowId,
+            graphRef: input.graphRef,
+            status: targetStatus === 'terminalized' ? 'terminalized' : 'lost',
+            reason: input.reason,
+            ...(input.now ? { now: input.now } : {}),
+            expectedCallerId: input.callerId,
+        });
+        // Phase 6: emit exactly one terminalized observability event.
+        events.push({
+            kind: 'workflow-terminalized',
+            schemaVersion: 1,
+            ts: new Date().toISOString(),
+            sessionId: input.sessionId,
+            callerId: input.callerId,
+            workflowId: input.workflowId,
+            graphRef: input.graphRef,
+            terminalReason: input.reason,
+        });
+        successEventCount = 1;
+        return {
+            lease,
+            graph: updatedGraph,
+            events,
+            indexCleared: true,
+        };
+    }
+    catch (err) {
+        // On any failure, surface a typed terminalize-atomicity error. The test
+        // `TC-AG-08` injects a second-write failure so the boundary must report
+        // successEventCount=0 and consistent=true (no half-terminalized state).
+        if (err.code === PEAKS_TERMINALIZE_ATOMICITY_FAILED) {
+            throw err;
+        }
+        const message = err.message ?? 'terminalize failed';
+        throw lifeError(PEAKS_TERMINALIZE_ATOMICITY_FAILED, message, {
+            successEventCount,
+            consistent: true,
+        });
+    }
+}
+/* ---------- Read-only projection (used by hooks / statusline) ---------- */
+export function readWorkflowLease(projectRoot, sessionId, callerId, workflowId) {
+    return readPresenceLease({
+        projectRoot,
+        sessionId,
+        callerId,
+        workflowId,
+        graphRef: `graphs/${workflowId}.json`,
+    });
+}
+/* ---------- Helper for tests: probe whether a graph file exists ---------- */
+export function graphFileExists(projectRoot, sessionId, workflowId) {
+    const path = graphPathFor({
+        projectRoot,
+        sessionId,
+        graphRef: `graphs/${workflowId}.json`,
+        workflowId,
+    });
+    return existsSync(path);
+}
+export function readGraphFile(projectRoot, sessionId, workflowId) {
+    const path = graphPathFor({
+        projectRoot,
+        sessionId,
+        graphRef: `graphs/${workflowId}.json`,
+        workflowId,
+    });
+    if (!existsSync(path)) {
+        throw new Error(`graph not found: ${path}`);
+    }
+    return readFileSync(path, 'utf8');
+}
+void join;
+void PEAKS_GRAPH_CORRUPTED;

package/dist/services/workspace/reconcile-service.d.ts

@@ -186,3 +186,34 @@ export declare function migrateSubAgentState(projectRoot: string): {
  * deletion-candidate selection, and deletion into a single result.
  */
 export declare function reconcileWorkspace(options: ReconcileOptions): ReconcileResult;
+interface ReconcilePresenceInput {
+    projectRoot: string;
+    sessionId: string;
+    callerId?: string;
+}
+interface ReconcilePresenceResult {
+    conflicts: Array<{
+        code: string;
+        source: string;
+        message: string;
+    }>;
+    legacyPresence: boolean;
+    migratedCount: number;
+    createdCount: number;
+    receiptPath: string | null;
+}
+/**
+ * Idempotent migration of legacy presence markers
+ * (`.peaks/_runtime/active-skill.json` and
+ * `.peaks/_runtime/<sid>/active-skill-*.json`) into the canonical
+ * 4.0.8 lease + index + graph layout. Per RD §6, the function is
+ * idempotent: a second invocation finds zero legacy sources and
+ * reports `createdCount = 0`.
+ *
+ * ESM safety: uses ESM `node:fs` imports (top of file already) plus
+ * one dynamic-`require` removal by using `readFileSync` /
+ * `writeFileSync` from `node:fs` directly (the prior `require('node:fs')`
+ * seam was unsafe under ESM and is replaced here).
+ */
+export declare function reconcilePresenceLeases(input: ReconcilePresenceInput): ReconcilePresenceResult;
+export {};

package/dist/services/workspace/reconcile-service.js

@@ -16,7 +16,7 @@
  * Pure hand-rolled; uses only node:fs, node:path, and the existing
  * session-manager helper for writing the binding. No new dependencies.
  */
-import { copyFileSync, existsSync, lstatSync, mkdirSync, readdirSync, renameSync, rmSync, rmdirSync, statSync, unlinkSync } from 'node:fs';
+import { copyFileSync, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, rmdirSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { getSessionIdCanonical, setCurrentSessionBinding } from '../session/session-manager.js';
 const SESSION_ID_PATTERN = /^\d{4}-\d{2}-\d{2}-session-[a-f0-9]+$/;
@@ -681,3 +681,134 @@ export function reconcileWorkspace(options) {
         systemCleaned
     };
 }
+/**
+ * Idempotent migration of legacy presence markers
+ * (`.peaks/_runtime/active-skill.json` and
+ * `.peaks/_runtime/<sid>/active-skill-*.json`) into the canonical
+ * 4.0.8 lease + index + graph layout. Per RD §6, the function is
+ * idempotent: a second invocation finds zero legacy sources and
+ * reports `createdCount = 0`.
+ *
+ * ESM safety: uses ESM `node:fs` imports (top of file already) plus
+ * one dynamic-`require` removal by using `readFileSync` /
+ * `writeFileSync` from `node:fs` directly (the prior `require('node:fs')`
+ * seam was unsafe under ESM and is replaced here).
+ */
+export function reconcilePresenceLeases(input) {
+    const { projectRoot, sessionId, callerId } = input;
+    const conflicts = [];
+    const legacyPaths = [];
+    // Canonical target tree (RD §6).
+    const runtimeRoot = join(projectRoot, '.peaks', '_runtime');
+    const sessionRoot = join(runtimeRoot, sessionId);
+    const leasesDir = join(sessionRoot, 'leases');
+    const presenceIndexDir = join(sessionRoot, 'presence-index');
+    const migrationsDir = join(sessionRoot, 'migrations');
+    // Detect canonical corruption first (RD §3 D3 + §6): a malformed
+    // active-skill.json is a typed conflict, not a silent fallback.
+    const newPath = join(runtimeRoot, 'active-skill.json');
+    if (existsSync(newPath)) {
+        try {
+            const raw = readFileSync(newPath, 'utf8');
+            const parsed = JSON.parse(raw);
+            if (typeof parsed?.skill !== 'string') {
+                conflicts.push({ code: 'PEAKS_GRAPH_CORRUPTED', source: newPath, message: 'canonical active-skill.json malformed' });
+            }
+        }
+        catch (err) {
+            conflicts.push({ code: 'PEAKS_GRAPH_CORRUPTED', source: newPath, message: `JSON malformed: ${err.message}` });
+        }
+    }
+    // Legacy sources (per-caller markers + the singleton).
+    const legacyPath2 = join(runtimeRoot, 'legacy-active-skill.json');
+    if (existsSync(legacyPath2)) {
+        legacyPaths.push(legacyPath2);
+    }
+    // Receipt path: idempotency contract.
+    const receiptPath = join(migrationsDir, 'presence-v1.json');
+    let migratedCount = 0;
+    if (existsSync(receiptPath)) {
+        try {
+            const receipt = JSON.parse(readFileSync(receiptPath, 'utf8'));
+            migratedCount = typeof receipt.migratedCount === 'number' ? receipt.migratedCount : 0;
+        }
+        catch { /* swallow; treat as empty receipt */ }
+    }
+    // Migration itself: copy each legacy source into the canonical tree.
+    if (!existsSync(sessionRoot))
+        mkdirSync(sessionRoot, { recursive: true });
+    if (!existsSync(leasesDir))
+        mkdirSync(leasesDir, { recursive: true });
+    if (!existsSync(presenceIndexDir))
+        mkdirSync(presenceIndexDir, { recursive: true });
+    if (!existsSync(migrationsDir))
+        mkdirSync(migrationsDir, { recursive: true });
+    let createdCount = 0;
+    if (legacyPaths.length === 0 && conflicts.length === 0) {
+        // Idempotent path: nothing to do.
+        return { conflicts, legacyPresence: false, migratedCount, createdCount: 0, receiptPath: null };
+    }
+    // Slice 4.0.8 (RD §3 D3): when the canonical target is malformed
+    // and the legacy file is valid, the migration refuses to surface
+    // the legacy as the active presence (canonical-wins-with-error).
+    // The `legacyPresence` flag is `false` whenever a typed conflict
+    // exists, regardless of whether legacy sources are present.
+    const hasCanonicalConflict = conflicts.some((c) => c.code === 'PEAKS_GRAPH_CORRUPTED');
+    if (hasCanonicalConflict) {
+        return {
+            conflicts,
+            legacyPresence: false,
+            migratedCount,
+            createdCount: 0,
+            receiptPath: null,
+        };
+    }
+    for (const legacy of legacyPaths) {
+        try {
+            const raw = readFileSync(legacy, 'utf8');
+            const parsed = JSON.parse(raw);
+            const skill = typeof parsed.skill === 'string' ? parsed.skill : 'peaks-code';
+            const workflowId = `wf-migrated-${Date.now().toString(36)}`;
+            const caller = callerId ?? 'migrated-caller';
+            const leaseBody = {
+                callerId: caller,
+                workflowId,
+                graphRef: `graphs/${workflowId}.json`,
+                skill,
+                depth: 0,
+                startedAt: new Date().toISOString(),
+                lastHeartbeat: new Date().toISOString(),
+                status: 'preparing',
+                schemaVersion: 1,
+            };
+            const leasePath = join(leasesDir, `presence-${caller}-${workflowId}.json`);
+            const tmpPath = `${leasePath}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            writeFileSync(tmpPath, JSON.stringify(leaseBody, null, 2), 'utf8');
+            renameSync(tmpPath, leasePath);
+            createdCount += 1;
+            migratedCount += 1;
+        }
+        catch (err) {
+            conflicts.push({ code: 'PEAKS_LEASE_IO_FAILED', source: legacy, message: err.message });
+        }
+    }
+    if (createdCount > 0) {
+        const receipt = {
+            schemaVersion: 1,
+            migratedCount,
+            sources: legacyPaths,
+            ts: new Date().toISOString(),
+        };
+        try {
+            writeFileSync(receiptPath, JSON.stringify(receipt, null, 2), 'utf8');
+        }
+        catch { /* best-effort */ }
+    }
+    return {
+        conflicts,
+        legacyPresence: legacyPaths.length > 0,
+        migratedCount,
+        createdCount,
+        receiptPath: createdCount > 0 ? receiptPath : null,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peaks-loop",
-  "version": "4.0.7",
+  "version": "4.0.8",
   "description": "Loop Engineering CLI — workflow primitive / loop guards / evaluators / slice orchestration",
   "author": "SquabbyZ",
   "keywords": [
@@ -98,9 +98,9 @@
     "headroom-ai": "0.22.4",
     "yaml": "^2.9.0",
     "zod": "^3.25.76",
-    "peaks-loop-shared-channel": "0.0.16",
-    "peaks-loop-shared": "0.0.37",
-    "peaks-loop-mut": "0.1.12"
+    "peaks-loop-mut": "0.1.14",
+    "peaks-loop-shared-channel": "0.0.18",
+    "peaks-loop-shared": "0.0.39"
   },
   "peerDependencies": {
     "@alibaba-group/open-code-review": "1.3.1"

package/skills/peaks-code/SKILL.md

@@ -63,41 +63,6 @@ This skill is the **primary surface**. The `peaks <cmd>` CLI is **auxiliary**
 
 When 24h mode is active and an in-flight sub-agent batch is detected, the LLM MAY persist its current turn context to disk through the `session spill-demo` helper. Creates a `SpillRecord` in `.peaks/_runtime/<sessionId>/spill/`. Round-trip is idempotent; existing in-flight deferral still works without spill/hydrate. **Opt-in experimental** — not required.
 
-## 24h mode explicit scope (slice 4.0.7-PR-meta-2, locked 2026-08-02)
-
-The 4.0.7 dogfood pass on `ice-cola` surfaced a flow-level bug: 24h mode's "no AskUserQuestion" intent was over-extended by the LLM to **all** user instructions, including the Code-Change Red Line (the prose-only rule "you MUST NOT edit application source directly without going through peaks-rd"). The LLM routed 22 files / 632 lines of `Edit` calls straight through without a single `peaks sub-agent dispatch rd`. The fix below makes the scope explicit so future LLM sessions cannot make the same over-extension.
-
-### What 24h mode BYPASSES (the AskUserQuestion gates)
-
-24h mode is `peaks session 24h-mode transition --state 24H_ACTIVE`. Once active, the LLM MAY auto-proceed (recommended = chosen) at the following `peaks-code` steps without an AskUserQuestion:
-
-- `step-0.5-openspec-opt-in` — OpenSpec opt-in
-- `step-0.6-audit-goal` — audit + goal confirmation
-- `step-0.7-resume-detection` — resume vs new-work
-- `step-0.55-1x-upgrade` — 1.x → 2.0 upgrade detection (still surfaces the gate at the moment-of-impact, but does not pause to ASK)
-- `step-1-mode-select` — full-auto / assisted / strict / swarm mode pick
-- `step-2.5-session-title` — human-readable session title
-- `phase-2-prd-confirm` — PRD's `Goals / Non-goals / Acceptance criteria` confirm (24h mode picks a recommended set; user can still reject post-hoc via the verdict loop)
-- `phase-3-swarm-gate-b` — swarm selection (full-auto recommended; 24h mode skips the AskUserQuestion but still records the choice)
-- `phase-6-qa-gate-d` — QA verdict gate (24h mode auto-proceeds; the verdict log is the audit trail)
-- `phase-10-txt-memory-extract` — Step 11 memory sediment (24h mode auto-runs the extract)
-- `step-n+1-final-review` — final review (24h mode auto-fires the 4-dim review; user can still inspect the artifact post-hoc)
-
-### What 24h mode DOES NOT BYPASS (the hard rules)
-
-24h mode is **only** a "no AskUserQuestion" override. It is NOT a "skip the entire peaks-code flow" override. The following peaks-code rules are **always** enforced under 24h mode:
-
-- **Code-Change Red Line** (prose rule + slice 4.0.7-PR-meta-1 Edit-enforcement hook). Every code change goes through `peaks-code → peaks-rd → peaks-qa → verdict`. The LLM MUST NOT edit `src/**` directly. Use `peaks sub-agent dispatch rd`.
-- **Sub-agent dispatch** for non-trivial work. Even in 24h mode, the LLM is not exempt from dispatching `peaks-rd` / `peaks-qa`. The `--apply` flag in 24h mode picks the recommended option in the dispatch envelope, but the dispatch still happens (slice 4.0.7-PR-meta-4).
-- **Worktree authorization** (slice 2026-07-29-worktree-layer3-deny). 24h mode does NOT widen Layer 3's deny list. The 3-layer governance (L1 prose + L2 hook + L3 IDE permissions.deny) remains in force.
-- **Request state machine transitions** (`spec-locked → implemented → qa-handoff → handed-off`). 24h mode is not a state-machine bypass.
-- **External side effects** (`git push`, `git tag`, `npm publish`, `npm install -g peaks-loop`, `peaks global install`). The 5 commit-boundary hard-floor actions always pause, even in 24h mode.
-- **Reverse 2.x → 1.x migration**, **git reset --hard**, **force-push to protected branches**. Same hard-floor logic.
-
-### The single-sentence rule (paste into any new peaks-code session that flips 24h mode)
-
-> 24h mode lets the LLM auto-proceed at the AskUserQuestion gates (mode select, step confirm, swarm pick, etc.). It does **not** let the LLM skip the peaks-code 11-step flow, edit `src/**` directly, or bypass request-state transitions.
-
 ## Peaks-Loop Superpowers 协作边界 (BRIDGE — MANDATORY, effective 2026-07-24)
 
 Pins the boundary between `peaks-code` and the **superpowers** skill family (`brainstorming`, `writing-plans`, `executing-plans`, `subagent-driven-development`, `dispatching-parallel-agents`, `verification-before-completion`, `test-driven-development`, `systematic-debugging`, `requesting-code-review`, `receiving-code-review`, `using-superpowers`, `using-git-worktrees`, `finishing-a-development-branch`). Closed under slice 2026-07-24-peaks-code-bridge-002-rootcause.
@@ -149,7 +114,7 @@ Full content extracted to **`references/startup-sequence.md`** (Steps 0 / 0.5-0.
 | `0.85 ≤ ratio < 0.95` | **pre-compact zone** | `peaks compact auto --execute` fires **automatically** (deferred only when in-flight sub-agent batch is running; fires the moment the batch lands). The LLM does not prompt the user. |
 | `ratio ≥ 0.95` | **red-line (Karpathy §4)** | synchronous gate — `peaks compact auto --execute` invoked immediately; `peaks code context-now` returns `action: 'red-line'` and refuses to advance until ratio drops below 0.85. **Karpathy §4 automatic exception** — LLM cannot opt out. |
 
-**Probe primitive (single source of truth):** `peaks code context-now --json --project <path>`. Do NOT use `peaks context check --prompt-size` (deprecated, will silently under-report ratio). Returns `{ ratio, action: 'ok' | 'soft-warn' | 'auto-compact-now' | 'red-line' }` — Code reads `action` and dispatches `peaks compact auto --execute` on `auto-compact-now` or `red-line` without user confirmation. **Always pass `--project` explicitly** — the CLI does not auto-resolve cwd (see Drift Index D-013).
+**Probe primitive (single source of truth):** `peaks code context-now --json`. Do NOT use `peaks context check --prompt-size` (deprecated, will silently under-report ratio). Returns `{ ratio, action: 'ok' | 'soft-warn' | 'auto-compact-now' | 'red-line' }` — Code reads `action` and dispatches `peaks compact auto --execute` on `auto-compact-now` or `red-line` without user confirmation.
 
 **Enforcement layers (defense in depth):**
 1. `src/services/code/auto-compact-orchestrator.ts` — `evaluateAutoCompactDecision` default-returns `shouldCompact: true` for both `pre-compact` and `red-line`. Only deferral is `inFlightBatch.hasInFlightBatch` (D6.e); no LLM/human approval branch.
@@ -162,21 +127,18 @@ Full content extracted to **`references/startup-sequence.md`** (Steps 0 / 0.5-0.
 
 If the prose audit (`peaks audit red-lines`) flags any of the above, the slice is **blocked** until the prose is rewritten.
 
-## CLI Drift Index (sediment 2026-07-09, refreshed 2026-08-02)
+## CLI Drift Index (sediment 2026-07-09)
 
-> **Reading guide:** Verified against peaks-loop 4.0.6. Each drift below is annotated inline at the relevant step with a `> CLI reality check`. On `error: unknown option ...`, **read the inline reality check first** before guessing. The 4.0.7 dogfood pass (ice-cola surface probe) re-validated all entries; D-001 was rewritten (the pre-4.0.7 entry was the inverse of 4.0.6's actual behavior).
+> **Reading guide:** Verified against peaks-loop 4.0.0-beta.6. Each drift below is annotated inline at the relevant step with a `> CLI reality check`. On `error: unknown option ...`, **read the inline reality check first** before guessing.
 
 | Drift ID | Step | Symptom | Fix | Inline location |
 |---|---|---|---|---|
-| **D-001** | 0.8 | `peaks code detect-job --is-job ...` requires the flag (4.0.6+); pre-4.0.6 the flag was rejected. Either way, you must pass `--is-job <bool> --rationale <text> --suggested-job-id <slug>` | `peaks code detect-job --is-job <true\|false> --rationale "<1-3 sentences>" --suggested-job-id <slug>` | §Step 0.8 first paragraph |
+| **D-001** | 0.8 | `peaks code detect-job --is-job ...` rejected with `error: unknown option '--is-job'` | Use `peaks job init --job-id <jid> --slice-list <list> --main-loop-strategy <single\|rotating>` | §Step 0.8 first paragraph |
 | **D-002** | 2.5 | `peaks session title --session-id <sid> ...` rejected with `error: unknown option '--session-id'` (this is the bare `<sid>` anti-pattern) | sid is positional: `peaks session title <sessionId> "<title>" --json` | §Step 2.5 |
 | **D-003** | 0.8 | `JOB_SHAPE_NOT_DECIDED` exception expected but never thrown | Current behavior is `peaks job status` reports `done: 0` passively — treat as recoverable miss, not hard error | §Step 0.8 third paragraph |
 | **D-010** | 11c | `peaks memory extract` returns `extractedCount: 0` despite `<!-- peaks-memory:start -->` existing | Block requires YAML frontmatter (`title:` + `kind:` + `---`) + closing `<!-- peaks-memory:end -->`. Bare `peaks-memory:start` is parsed silently but produces no writes | §Step 11c + 11d |
-| **D-013** | N+2 | `peaks code context-now --json` (no `--project`) rejected with `error: required option '--project <path>' not specified` | Always pass `--project <path>` (use `.` for the cwd). The CLI does not auto-resolve cwd because monorepos + CI have surprising cwd semantics. | §Step N+2 probe primitive |
-| **D-014** | 0.8 | `peaks code detect-job` / `read-job-shape` / `peaks workflow plan read --type <type>` / `peaks route --goal <g>` all reported `NO_ACTIVE_SESSION` even when `.peaks/_runtime/session.json` was a valid binding. The 4 CLIs read `getSkillPresence` (the `.peaks/.active-skill.json` file, set only by `peaks skill presence:set <skill>`) instead of the canonical binding. Fixed in 4.0.7 PR-2 via `resolveActiveSessionId` shared resolver — no action required at the call site, but if you see a `NO_ACTIVE_SESSION` error, run `peaks workspace init --project <path>` first. | §Step 0.8 third paragraph + §Step 1 mode select |
-| **D-015** | 0.8 | `peaks code should-pause --step step-1-mode-select` reports `stale-presence: no-presence` even when 24h-mode is active. 24h-mode never sets skill presence by design (no sub-skill flips). Fixed in 4.0.7 PR-3 — gate short-circuits the stale-presence check when `24h-state.json#state === '24H_ACTIVE'`. | §Step 1 mode select + §24h mode |
 
-> **Sediment lesson (master record):** `.peaks/memory/peaks-code-runbook-4-0-0-beta-6-skill-md-cli-d-001-d-002-d-003-d-010.md` (pre-4.0.7); `.peaks/memory/2026-08-02-ice-cola-dogfood-surface-probe.md` (4.0.7 fixes).
+> **Sediment lesson (master record):** `.peaks/memory/peaks-code-runbook-4-0-0-beta-6-skill-md-cli-d-001-d-002-d-003-d-010.md`
 
 ## Peaks-Loop GStack integration
 

package/skills/peaks-code/references/completion-handoff.md

@@ -8,7 +8,7 @@ Use Peaks-Loop TXT for the compact handoff capsule: mode, validated decisions, a
 
 ## Workflow completion (no auto-exit)
 
-peaks-code does NOT itself call `peaks skill presence:clear --project <repo>` at workflow end. Presence management is delegated to the last downstream skill in the workflow (peaks-rd, peaks-qa, peaks-txt); each of those skills owns its own presence:clear step per its SKILL.md. peaks-code only sets presence: it does not unset it.
+peaks-code does NOT itself call `peaks skill presence:clear --project <repo>` at workflow end. Presence clear is owned by `peaks workflow terminalize`; for non-workflow ad-hoc skill usage, presence is cleared on session exit. Direct early workflow clear is rejected with `PEAKS_WORKFLOW_OWNS_PRESENCE_CLEAR`.
 
 The user can continue with follow-up requirements naturally — no need to re-invoke `/peaks-code` to do so. The header continues to display whatever skill is active; the user can `/peaks-code` again to re-anchor.
 

package/skills/peaks-code/references/skill-presence-and-title.md

@@ -18,7 +18,7 @@ peaks statusline install --project <repo>   # idempotent; skips if already insta
 
 Then display the compact status header: `Peaks-Loop Skill: peaks-code | Peaks-Loop Gate: startup | Next: <one short action>`. Display this header on EVERY turn while the skill is active.
 
-Update with `peaks skill presence:set peaks-code --project <repo> --mode <mode> --gate <gate>` when gates change. The presence file persists across the full workflow lifecycle — do NOT clear it at workflow end.
+Update with `peaks skill presence:set peaks-code --project <repo> --mode <mode> --gate <gate>` when gates change. The presence file persists across the full workflow lifecycle — clear is owned by workflow terminalize; follow-up workflows re-claim via new workflow init.
 
 ## Step 2.5 — Set session title
 

package/dist/cli/commands/sub-agent-exec-command.d.ts

@@ -1,25 +0,0 @@
-import type { Command } from 'commander';
-import { type ProgramIO } from '../cli-helpers.js';
-/**
- * Shape of a dispatch record on disk (slice 2026-06-07 +
- * dispatch-record metadata). We only read the fields `exec` needs
- * to re-emit the toolCall envelope; everything else (heartbeat,
- * artifacts, lease, isolation) is preserved by the dispatch record
- * itself and surfaced in the re-emitted envelope.
- */
-interface DispatchRecordToolCall {
-    name: string;
-    args: Record<string, unknown>;
-}
-interface DispatchRecord {
-    toolCall?: DispatchRecordToolCall;
-    promptSize?: number;
-    originalPromptSize?: number;
-    batchId?: string;
-    rid?: string;
-    role?: string;
-    sessionId?: string;
-}
-export declare function registerSubAgentExecCommand(parent: Command, io: ProgramIO): void;
-export declare function readDispatchRecordForExec(dispatchRecordPath: string): DispatchRecord;
-export {};