spexcode 0.6.7 → 0.7.0-next.0

package/node_modules/@spexcode/spec-core/dist/layout.d.ts

@@ -14,7 +14,6 @@ export type Config = {
         apiUrl?: string;
         title?: string;
         icon?: string;
-        showHeadlessLaunchers?: boolean;
     };
     uploads?: {
         maxBytes?: number;
@@ -111,8 +110,10 @@ export type RawRecord = {
     createdAt: number;
     harness?: string;
     harness_session_id?: string;
+    runtime_start_token?: string;
     stopped?: boolean;
     archived?: boolean;
+    closed_at?: string;
     cold_proof?: string;
     adapter_recovery?: string;
     launcher?: string;
@@ -125,6 +126,15 @@ export type RawRecord = {
     runtime_revision?: string;
     runtime_metadata?: Record<string, string>;
     base?: string;
+    diff_comments?: Array<{
+        id: string;
+        file_path: string;
+        line_start: number;
+        line_end: number;
+        body: string;
+        diff_identity: string;
+        sent_at: string | null;
+    }>;
     launch_readiness_pending?: '' | RawLaunchReadinessPending;
 };
 export declare const SESSION_LIFECYCLES: readonly ["active", "idle", "awaiting", "parked", "error", "asking", "queued"];
@@ -139,6 +149,7 @@ export type RawLaunchReadinessOriginal = {
     note: string | null;
     stopped: boolean;
     archived: boolean;
+    closed_at?: string | null;
     cold_proof: string | null;
     adapter_recovery: string | null;
 };

package/node_modules/@spexcode/spec-core/dist/layout.js

@@ -136,7 +136,7 @@ export function mainRoot(proj) {
 }
 // @@@ global per-session store - Fork A: NO SpexCode files live in the worktree any more, so the worktree's
 // spec/code tree is pristine (zero per-session pollution). Every per-session runtime artifact — the
-// structured record (session.json) AND the launcher products (prompt, launch, launch.sh) AND the recorded comms AND
+// runtime envelope (runtime.json) AND the launcher products (prompt, launch, launch.sh) AND the recorded comms AND
 // the spec-discipline sentinels — lives in a per-USER GLOBAL store, keyed by the harness `session_id` so two
 // agents in one folder never clobber, and grouped PER PROJECT (mirroring Claude's ~/.claude/projects/<enc>/)
 // so the board enumerates ONE directory. This is the single seam that knows where the store sits; sessions.ts
@@ -169,7 +169,7 @@ export function treeSlotDir(wt) {
 // all keyed by session_id under <home>/projects/<enc>/sessions/.
 export function sessionsRoot() { return join(runtimeRoot(), 'sessions'); }
 export function sessionStoreDir(id) { return join(sessionsRoot(), id); }
-export function sessionRecordPath(id) { return join(sessionStoreDir(id), 'session.json'); }
+export function sessionRecordPath(id) { return join(sessionStoreDir(id), 'runtime.json'); }
 export function sessionArtifactPath(id, name) { return join(sessionStoreDir(id), name); }
 export const SESSION_LIFECYCLES = ['active', 'idle', 'awaiting', 'parked', 'error', 'asking', 'queued'];
 export const SESSION_PROPOSALS = ['merge', 'nothing', 'close'];
@@ -190,6 +190,7 @@ export function rawLaunchReadinessOriginal(raw) {
         || !(original.proposal === null || original.proposal === '' || isSessionProposal(original.proposal))
         || !(typeof original.note === 'string' || original.note === null)
         || typeof original.stopped !== 'boolean' || typeof original.archived !== 'boolean'
+        || !(typeof original.closed_at === 'string' || original.closed_at === null || original.closed_at === undefined)
         || !(typeof original.cold_proof === 'string' || original.cold_proof === null)
         || !(typeof original.adapter_recovery === 'string' || original.adapter_recovery === null)) {
         throw new Error(`session '${raw.session_id}' has an invalid launch_readiness_pending fence`);
@@ -281,6 +282,7 @@ export function projectPublicRecordEntry(id, entry) {
                 note: original.note || null,
                 stopped: original.stopped,
                 archived: original.archived,
+                closed_at: original.closed_at ?? undefined,
                 cold_proof: original.cold_proof ?? undefined,
                 adapter_recovery: original.adapter_recovery ?? undefined,
                 launch_readiness_pending: '',

package/node_modules/@spexcode/spec-core/dist/resilience.d.ts

@@ -1,2 +1,3 @@
+export declare function isTrashWorktreePath(path: string): boolean;
 export declare function guardWorktree<T>(dir: string, fn: () => T | Promise<T>, degraded: () => T): Promise<T | null>;
 export declare function installProcessGuards(): void;

package/node_modules/@spexcode/spec-core/dist/resilience.js

@@ -1,7 +1,15 @@
 import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
 function describe(e) {
     return e instanceof Error ? e.message : String(e);
 }
+// Delayed close deletion lives below this directory and is never a live worktree input.
+export function isTrashWorktreePath(path) {
+    const normalized = resolve(path);
+    const parts = normalized.split(/[\\/]+/);
+    const worktrees = parts.lastIndexOf('.worktrees');
+    return worktrees >= 0 && parts[worktrees + 1] === '.trash';
+}
 // run a per-worktree DETAIL read; on a throw, branch on whether the worktree DIRECTORY still exists.
 //   dir gone   → the worktree was genuinely removed mid-read → return null so the caller omits it.
 //   dir present → a flaky detail read (ENOENT race on a sibling file, or a git index/ref lock under a

package/node_modules/@spexcode/spec-core/dist/review/reviewFilters.d.ts

@@ -68,6 +68,7 @@ export const EVAL_FILTER_KIND: Readonly<{
     RESULT: "result";
     BLIND: "blind";
     UNMEASURED: "unmeasured";
+    DEFERRED: "deferred";
     DANGLING: "dangling";
 }>;
 export function evidenceList(reading: any): any;

package/node_modules/@spexcode/spec-core/dist/review/reviewFilters.js

@@ -11,6 +11,7 @@ export const EVAL_FILTER_KIND = Object.freeze({
     RESULT: 'result',
     BLIND: 'blind',
     UNMEASURED: 'unmeasured',
+    DEFERRED: 'deferred',
     DANGLING: 'dangling',
 });
 export const evidenceList = (reading) => reading?.evidence?.length ? reading.evidence
@@ -146,9 +147,11 @@ export function issueFilterModel(items, raw = {}, context = {}) {
 const evalIsResult = (entry) => entry.filterKind === EVAL_FILTER_KIND.RESULT;
 const verdictOf = (entry) => evalIsResult(entry)
     ? (entry.verdict?.status || 'unscored')
-    : entry.filterKind === EVAL_FILTER_KIND.BLIND || entry.filterKind === EVAL_FILTER_KIND.UNMEASURED
-        ? 'unmeasured'
-        : 'unscored';
+    : entry.filterKind === EVAL_FILTER_KIND.DEFERRED
+        ? 'deferred'
+        : entry.filterKind === EVAL_FILTER_KIND.BLIND || entry.filterKind === EVAL_FILTER_KIND.UNMEASURED
+            ? 'unmeasured'
+            : 'unscored';
 const reviewStateOf = (entry) => (evalIsResult(entry) && entry.fresh && entry.humanOk ? 'reviewed' : 'current');
 // the ONE freshness axis of the Eval adapter — the facet's option values and the verdict sections' split
 // read it, so a chip and its Freshness menu can never disagree about what "stale" counts.
@@ -194,6 +197,7 @@ const EVAL_CONFIG = {
             { value: 'fail', label: 'reviewList.verdict.fail', split: true },
             { value: 'pass', label: 'reviewList.verdict.pass', split: true },
             { value: 'unmeasured', label: 'reviewList.verdict.unmeasured' },
+            { value: 'deferred', label: 'reviewList.verdict.deferred' },
         ],
     },
     facets: [

package/node_modules/@spexcode/spec-core/dist/review/reviewQuery.d.ts

@@ -31,6 +31,7 @@ export const ISSUE_QUERY_DEFAULT: "is:issue state:open";
 export const EVAL_QUERY_DEFAULT: "is:eval";
 export function scopedEvalQuery(sessionId: any): any;
 export function nodeEvalQuery(nodeId: any): any;
+export function nodeIssueQuery(nodeId: any): any;
 export function quoteValue(v: any): string;
 export function tokenize(text: any): ({
     ws: boolean;

package/node_modules/@spexcode/spec-core/dist/review/reviewQuery.js

@@ -8,6 +8,10 @@ export const EVAL_QUERY_DEFAULT = 'is:eval';
 export const scopedEvalQuery = (sessionId) => setToken(EVAL_QUERY_DEFAULT, 'scope', sessionId);
 // the aggregate score/count doors' address ([[eval-score-badge]]): the default view, node-filtered.
 export const nodeEvalQuery = (nodeId) => setToken(EVAL_QUERY_DEFAULT, 'node', nodeId);
+// a node's OPEN issues ([[context-dock]]): the issue list's default view, node-filtered. Same shape and
+// same reason as the eval twin — a surface that wants "this node's issues" asks for a text, never for a
+// second filter path, so the panel and the list it links to are literally the same query.
+export const nodeIssueQuery = (nodeId) => setToken(ISSUE_QUERY_DEFAULT, 'node', nodeId);
 const KEY_RE = /^([A-Za-z][A-Za-z0-9-]*):(.*)$/s;
 const unquote = (v) => (v.length >= 2 && v.startsWith('"') && v.endsWith('"') ? v.slice(1, -1) : v);
 export const quoteValue = (v) => (/\s/.test(String(v)) ? `"${v}"` : String(v));

package/node_modules/@spexcode/spec-core/dist/specs.d.ts

@@ -9,6 +9,7 @@ export type SpecParts = {
     expandedSpec: string;
 };
 declare function parseParts(body: string): SpecParts | null;
+export declare function bodyMentions(body: string): string[];
 export type DerivedStatus = 'pending' | 'active' | 'merged' | 'drift';
 export declare function deriveStatus(d: {
     version: number;
@@ -43,6 +44,7 @@ export declare function specContent(id: string): {
     body: string;
     parts: ReturnType<typeof parseParts>;
 } | null;
+export declare function specDir(id: string): string | null;
 export type LoadSpecsOptions = {
     tip?: string;
     history?: HistoryIndex | null;

package/node_modules/@spexcode/spec-core/dist/specs.js

@@ -68,6 +68,29 @@ function parseParts(body) {
     const t = (a) => a.join('\n').trim();
     return { rawSource: t(acc.rawSource), expandedSpec: t(acc.expandedSpec) };
 }
+// the `[[id]]` reference grammar as a spec BODY writes it. Its consumer is the lint rule that rejects a
+// dangling reference — the one place a `[[name]]` has to be judged against the node universe. It is a
+// parser and not a projection: the loader once shipped the surviving ids as a `mentions` edge on every
+// node, and that edge is gone, because a prose mention is a fact about the GRAPH and never was a fact
+// about the node the reader has open ([[context-dock]]). Prose only: a fenced block or an inline
+// `code span` is sample text (`[[node]]`, `[[<id>]]` placeholders live there), not a reference. Distinct,
+// in first-appearance order; whether a name resolves to a real node is the caller's judgement.
+const MENTION_RE = /\[\[(\.?[\p{L}\p{N}_-]+)\]\]/gu;
+export function bodyMentions(body) {
+    const out = new Set();
+    let inFence = false;
+    for (const rawLine of body.split('\n')) {
+        if (/^\s*```/.test(rawLine)) {
+            inFence = !inFence;
+            continue;
+        }
+        if (inFence)
+            continue;
+        for (const m of rawLine.replace(/`[^`]*`/g, '').matchAll(MENTION_RE))
+            out.add(m[1]);
+    }
+    return [...out];
+}
 export function deriveStatus(d) {
     if (d.fmStatus === 'pending' && !d.hasCode && d.drift === 0)
         return 'pending';
@@ -228,6 +251,13 @@ export function specContent(id) {
     const r = raws().find((x) => x.id === id);
     return r ? { body: r.body.trim(), parts: parseParts(r.body) } : null;
 }
+// Where a node LIVES, repo-relative — its own folder, not its spec.md. A node's folder is the unit (the
+// same rule the plugin instances are built on), so anything that wants to see what a node carries besides
+// its body asks the spec tree's own reader rather than re-deriving a path from an id.
+export function specDir(id) {
+    const r = raws().find((x) => x.id === id);
+    return r ? r.relPath.replace(/\/spec\.md$/, '') : null;
+}
 export async function loadSpecs(root = ROOT, options = {}) {
     // The default pair shares one immutable-event snapshot; explicit sides let callers skip or supply either
     // projection. Every node below is then a pure in-memory lookup.

package/node_modules/@spexcode/spec-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/spec-core",
-  "version": "0.6.7",
+  "version": "0.7.0-next.0",
   "type": "module",
   "description": "SpexCode's dependency-minimal spec graph core.",
   "files": [
@@ -17,6 +17,9 @@
   "engines": {
     "node": ">=22"
   },
+  "dependencies": {
+    "@vscode/tree-sitter-wasm": "0.3.1"
+  },
   "publishConfig": {
     "access": "public"
   },

package/node_modules/@spexcode/spec-core/templates/spexcode.json

@@ -1,9 +1,8 @@
 {
   "lint": {
-    "governedRoots": ["."]
-  },
-  "dashboard": {
-    "showHeadlessLaunchers": false
+    "governedRoots": [
+      "."
+    ]
   },
   "uploads": {
     "maxBytes": 2147483648,
@@ -19,15 +18,39 @@
   },
   "sessions": {
     "launchers": {
-      "claude": { "harness": "claude", "cmd": "claude" },
-      "claude-headless": { "harness": "claude-headless", "cmd": "claude" },
-      "codex": { "harness": "codex", "cmd": "codex" },
-      "codex-headless": { "harness": "codex-headless", "cmd": "codex --yolo" },
-      "opencode": { "harness": "opencode", "cmd": "opencode" },
-      "opencode-headless": { "harness": "opencode-headless", "cmd": "opencode --auto" },
-      "pi": { "harness": "pi", "cmd": "pi" },
-      "pi-headless": { "harness": "pi-headless", "cmd": "pi" }
+      "claude-headless": {
+        "harness": "claude-headless",
+        "cmd": "claude"
+      },
+      "claude": {
+        "harness": "claude",
+        "cmd": "claude"
+      },
+      "codex-headless": {
+        "harness": "codex-headless",
+        "cmd": "codex --yolo"
+      },
+      "codex": {
+        "harness": "codex",
+        "cmd": "codex"
+      },
+      "opencode-headless": {
+        "harness": "opencode-headless",
+        "cmd": "opencode --auto"
+      },
+      "opencode": {
+        "harness": "opencode",
+        "cmd": "opencode"
+      },
+      "pi-headless": {
+        "harness": "pi-headless",
+        "cmd": "pi"
+      },
+      "pi": {
+        "harness": "pi",
+        "cmd": "pi"
+      }
     },
-    "defaultLauncher": "claude"
+    "defaultLauncher": "claude-headless"
   }
 }

package/node_modules/@spexcode/spec-eval/dist/cli.js

@@ -203,7 +203,7 @@ async function scan(args = []) {
                     }
                     // an anchor is a claim a named unit exists — dead/ambiguous/unextractable is LOUD, and until it is
                     // repaired the probe issues no verdict, so the reading stays conservatively stale.
-                    for (const p of [...axis.problems, ...anchorProblems(root, axis.entries)]) {
+                    for (const p of [...axis.problems, ...(await anchorProblems(root, axis.entries))]) {
                         malformed++;
                         findings.push(`  • eval-schema: '${s.id}' scenario '${sc.name}' ${p} — fix ${y.evalPath}`);
                     }

package/node_modules/@spexcode/spec-eval/dist/evaltab.d.ts

@@ -83,6 +83,7 @@ export type EvalContext = {
 export declare function evalContext(root: string, specs: Awaited<ReturnType<typeof loadSpecs>>, idx: DriftIndex, hidx: HistoryIndex, remarks?: Map<string, RemarkTrack>, ynodes?: EvalNode[]): Promise<EvalContext>;
 export declare function evalTimelines(ids: readonly string[], ctx?: EvalContext, opts?: {
     order?: boolean;
+    latestOnly?: boolean;
 }): Promise<EvalTimeline[]>;
 export declare function evalTimeline(id: string, ctx?: EvalContext): Promise<EvalTimeline>;
 export type BlobResult = {

package/node_modules/@spexcode/spec-eval/dist/evaltab.js

@@ -50,9 +50,14 @@ export async function evalTimelines(ids, ctx, opts = {}) {
         const codeEntries = specs.find((s) => dirname(s.path) === relative(root, ynode.dir))?.codeEntries ?? [];
         const byName = new Map(ynode.scenarios.map((s) => [s.name, s]));
         const { readings, retractions, oks } = readSidecar(ynode.sidecarPath);
-        const rows = applyRetractions(readings, retractions).map((reading) => ({
+        const allRows = applyRetractions(readings, retractions).map((reading) => ({
             reading, axis: scenarioCodeAxis(byName.get(reading.scenario)?.code, codeEntries),
         }));
+        // The board only renders the latest state per scenario. Historical rows remain available to the
+        // session/eval detail paths, but sending them through freshness here multiplies immutable Git probes.
+        const rows = opts.latestOnly
+            ? [...allRows.reduce((latest, row) => latest.set(row.reading.scenario, row), new Map()).values()]
+            : allRows;
         return { id, ynode, codeEntries, rows, retractions, oks };
     });
     // an order-only read stops HERE, before a single probe: the rows above are already the whole answer.

package/node_modules/@spexcode/spec-eval/dist/freshness.d.ts

@@ -30,7 +30,7 @@ export type AnchorDemand = {
     entries: readonly RelationEntry[];
 };
 export declare function anchorProbeFor(root: string, idx: DriftIndex): AnchorProbe;
-export declare function anchorProblems(root: string, entries: readonly RelationEntry[]): string[];
+export declare function anchorProblems(root: string, entries: readonly RelationEntry[]): Promise<string[]>;
 export type RemarkSignal = {
     resolved: boolean;
     resolvedAt?: string;

package/node_modules/@spexcode/spec-eval/dist/freshness.js

@@ -497,7 +497,7 @@ const currentTreeUnitMemo = new Map();
 // caller retaining a verdict derived from these units names it by the same identity that decides the parse
 // ([[selector-anchor-scope]]). Returning the key rather than re-deriving it elsewhere is what keeps the two
 // from drifting apart.
-function currentTreeImage(root, x, path) {
+async function currentTreeImage(root, x, path) {
     const source = readFileSync(join(root, path), 'utf8');
     const key = `${x.memoKey(path)}\0${createHash('sha1').update(source).digest('hex')}`;
     const hit = currentTreeUnitMemo.get(key);
@@ -508,7 +508,7 @@ function currentTreeImage(root, x, path) {
     }
     let entry;
     try {
-        entry = { units: x.extract(source, path) };
+        entry = { units: await x.extract(source, path) };
     }
     catch (err) {
         entry = { failed: err?.message ?? String(err) };
@@ -520,15 +520,15 @@ function currentTreeImage(root, x, path) {
         throw new Error(entry.failed);
     return { key, units: entry.units };
 }
-function entryImage(root, regs, path, selector) {
+async function entryImage(root, regs, path, selector) {
     const x = extractorFor(regs, extOf(path));
     if (!x)
         return { problem: `\`code\` selector \`${path}#${selector}\` — no designated extractor for that language; drop the #anchor or add a language row` };
-    const ready = x.ready();
+    const ready = await x.ready();
     if (ready !== true)
         return { problem: `\`code\` anchors on ${path} are unverified: ${ready}` };
     try {
-        return currentTreeImage(root, x, path);
+        return await currentTreeImage(root, x, path);
     }
     catch (err) {
         return { problem: `\`code\` anchors on ${path} are unverified: ${err?.message ?? String(err)}` };
@@ -550,8 +550,8 @@ function selectorProblem(units, path, selectors) {
     }
     return null;
 }
-function entryUnverifiable(root, regs, entry) {
-    const image = entryImage(root, regs, entry.path, entry.selectors[0]);
+async function entryUnverifiable(root, regs, entry) {
+    const image = await entryImage(root, regs, entry.path, entry.selectors[0]);
     return 'problem' in image ? image.problem : selectorProblem(image.units, entry.path, entry.selectors);
 }
 // @@@ the verify sweep must reach the MACROTASK queue - resolving every reading's `code:` selectors against
@@ -603,10 +603,10 @@ export function anchorProbeFor(root, idx) {
             // one coherent read of each source per sweep: every entry on a path resolves against the same bytes,
             // and the read that names the verdict is the read the verdict was derived from.
             const images = new Map();
-            const imageOf = (path, selector) => {
+            const imageOf = async (path, selector) => {
                 let hit = images.get(path);
                 if (hit === undefined) {
-                    hit = entryImage(root, regs, path, selector);
+                    hit = await entryImage(root, regs, path, selector);
                     images.set(path, hit);
                 }
                 return hit;
@@ -630,7 +630,7 @@ export function anchorProbeFor(root, idx) {
                     const key = anchorKey(sinceSha, e.path, e.selectors);
                     if (verdicts.has(key) || queued.has(key))
                         continue;
-                    const image = imageOf(e.path, e.selectors[0]);
+                    const image = await imageOf(e.path, e.selectors[0]);
                     const name = 'problem' in image ? null : `${registry}\x1f${image.key}\x1f${key}`;
                     const remembered = scope && name !== null ? scope.anchorVerdicts.get(name) : undefined;
                     if (remembered !== undefined) {
@@ -666,13 +666,13 @@ export function anchorProbeFor(root, idx) {
 // the LOUD half: a selector is a claim that a named unit EXISTS, held to the same standard as a ghost path.
 // Dead, ambiguous, unparseable, or no designated extractor — each names itself and its repair, and until
 // repaired the probe issues no verdict, so the reading stays stale. Over-warn, never a silent pass.
-export function anchorProblems(root, entries) {
+export async function anchorProblems(root, entries) {
     const regs = extractors(root);
     const out = [];
     for (const e of entries) {
         if (!e.selectors.length)
             continue;
-        const problem = entryUnverifiable(root, regs, e);
+        const problem = await entryUnverifiable(root, regs, e);
         if (problem)
             out.push(problem);
     }

package/node_modules/@spexcode/spec-eval/dist/host.d.ts

@@ -1,4 +1,5 @@
 import type { RemarkTrack } from './remarks.js';
+import type { ReviewDiffFile } from '@spexcode/spec-core';
 export type EvalHost = {
     loadConfig?: (root: string) => any;
     trackedSourceFiles?: (root: string, roots: string[], policy: any) => string[];
@@ -19,7 +20,7 @@ export type ReviewPayload = {
     label: string;
     ahead: number;
     dirtyNonRuntime: number;
-    diff: import('@spexcode/spec-core').ReviewDiffFile[];
+    diff: ReviewDiffFile[];
     gates: {
         conflictsWithMain: boolean;
         lint: {

package/node_modules/@spexcode/spec-eval/dist/sessioneval.d.ts

@@ -218,7 +218,7 @@ export type SessionEvalRevision = {
 export type SessionEvalProjection = {
     epoch: string;
     generation: number;
-    phase: 'loading' | 'updating' | 'ready' | 'error';
+    phase: 'loading' | 'updating' | 'ready' | 'error' | 'dormant';
     revision?: string;
     value?: SessionEvalSummary;
     lastKnown?: {
@@ -279,6 +279,7 @@ export declare class SessionEvalProjectionCache {
     demand<T>(id: string, path: string, run: () => Promise<T>): Promise<T>;
     idle(): Promise<void>;
     accept(id: string, generation: number, revision: string, value: SessionEvalSummary): boolean;
+    private dormantEntry;
     private project;
     private matches;
     private publish;

package/node_modules/@spexcode/spec-eval/dist/sessioneval.js

@@ -116,7 +116,7 @@ async function validateSelectorEntry(context, revision, entry, sourceView) {
     if (!x) {
         throw new SessionImpactUnavailableError(`session impact selector '${entry.path}#${entry.selectors[0]}' is unavailable: no designated extractor for '.${extOf(entry.path)}'`);
     }
-    const ready = x.ready();
+    const ready = await x.ready();
     if (ready !== true) {
         throw new SessionImpactUnavailableError(`session impact selectors on '${entry.path}' are unavailable: ${ready}`);
     }
@@ -132,7 +132,7 @@ async function validateSelectorEntry(context, revision, entry, sourceView) {
                 throw new SessionImpactUnavailableError(`session impact selector '${entry.path}#${entry.selectors[0]}' is dead at ${revision.slice(0, 8)}: the file does not exist`);
             }
             try {
-                return { extractor: x, units: x.extract(source, entry.path) };
+                return { extractor: x, units: await x.extract(source, entry.path) };
             }
             catch (error) {
                 throw new SessionImpactUnavailableError(`session impact selectors on '${entry.path}' are unextractable at ${revision.slice(0, 8)}: ${error?.message ?? String(error)}`);
@@ -1636,6 +1636,16 @@ export class SessionEvalProjectionCache {
         promise.finally(() => {
             if (this.demands.get(id) === promise)
                 this.demands.delete(id);
+            // The cancel above exists ONLY so the warmup does not duplicate the build this demand is about to run.
+            // Once the demand has settled that reason is spent — and a demand that REJECTED published nothing, so
+            // leaving the mark set kept `authorize` refusing this generation forever and the entry stuck at
+            // `loading`/`updating` with no build ever scheduled. A demand that published is already `ready` and
+            // needs no second build.
+            if (this.entries.get(id) !== entry || entry.demandCancelledGeneration !== entry.generation)
+                return;
+            entry.demandCancelledGeneration = null;
+            this.authorize(entry);
+            queueMicrotask(() => this.startScheduled());
         }).catch(() => { });
         return promise;
     }
@@ -1660,12 +1670,19 @@ export class SessionEvalProjectionCache {
             this.notify();
         return true;
     }
+    // Dormant offline history is demand-only BY POLICY: `authorize` refuses to schedule an offline entry, so
+    // nothing will move it until a demand builds it. `loading`/`updating` are arrival phases — a reader that
+    // renders them as progress waits forever. This names the difference at the one place that knows it.
+    dormantEntry(entry) {
+        return entry.liveness === 'offline' && entry.running == null && entry.scheduled == null
+            && entry.observerHolds.size === 0 && entry.phase !== 'ready' && entry.phase !== 'error';
+    }
     project(entry) {
         const stable = entry.current;
         return {
             epoch: this.epoch,
             generation: entry.generation,
-            phase: entry.phase,
+            phase: this.dormantEntry(entry) ? 'dormant' : entry.phase,
             ...(entry.phase === 'ready' && stable
                 ? { revision: stable.revision, value: stable.value }
                 : stable ? { lastKnown: stable } : {}),

package/node_modules/@spexcode/spec-eval/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/spec-eval",
-  "version": "0.6.7",
+  "version": "0.7.0-next.0",
   "type": "module",
   "exports": {
     ".": "./dist/index.js",
@@ -26,7 +26,7 @@
     "test": "tsx --import ../scripts/test-home.mjs --test src/*.test.ts"
   },
   "dependencies": {
-    "@spexcode/spec-core": "0.6.7"
+    "@spexcode/spec-core": "0.7.0-next.0"
   },
   "devDependencies": {
     "@types/node": "^20.16.0",

package/node_modules/@spexcode/spec-forge/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/spec-forge",
-  "version": "0.6.7",
+  "version": "0.7.0-next.0",
   "type": "module",
   "exports": {
     ".": "./dist/index.js",
@@ -22,7 +22,7 @@
     "test": "tsx --test src/*.test.ts"
   },
   "dependencies": {
-    "@spexcode/spec-core": "0.6.7"
+    "@spexcode/spec-core": "0.7.0-next.0"
   },
   "devDependencies": {
     "@types/node": "^20.16.0",

package/node_modules/@spexcode/transcript/dist/frames.d.ts

@@ -0,0 +1,44 @@
+import { type TranscriptRead, type TranscriptReader, type TranscriptTool, type TranscriptTurn } from './turns.js';
+export type StreamTool = Readonly<Omit<TranscriptTool, 'output'> & {
+    output?: null;
+}>;
+export type StreamTurn = Readonly<Omit<TranscriptTurn, 'tools'> & {
+    tools?: readonly StreamTool[];
+}>;
+export type StreamFrame = Readonly<Omit<TranscriptRead, 'turns'> & {
+    kind: 'full' | 'delta';
+    turns: readonly StreamTurn[];
+    removed?: readonly string[];
+}>;
+export type TranscriptErrorFrame = Readonly<{
+    revision: string;
+    from: number;
+    to: number;
+    error: string;
+    reason: string;
+}>;
+export type TranscriptFrame = StreamFrame | TranscriptErrorFrame;
+export declare const isErrorFrame: (frame: TranscriptFrame) => frame is TranscriptErrorFrame;
+export declare const ABSENT_REVISION = "absent";
+export declare const withheld: (read: TranscriptRead) => Omit<StreamFrame, "kind">;
+export declare class FrameProducer {
+    private primed;
+    private sent;
+    private counters;
+    next(read: TranscriptRead): StreamFrame | null;
+    reset(): void;
+}
+export declare const absentFrame: (from: number, to: number) => StreamFrame;
+export type FrameStream = Readonly<{
+    publish(now?: number): Promise<TranscriptFrame | null>;
+    close(): void;
+}>;
+export declare function openFrameStream(reader: TranscriptReader, threadId: string, from: number, clock?: () => number): FrameStream;
+export type HeldTranscript = Readonly<{
+    turns: readonly StreamTurn[];
+}>;
+export type MergedFrame = Readonly<{
+    state: HeldTranscript;
+    payload: TranscriptErrorFrame | (Omit<StreamFrame, 'kind' | 'removed'>);
+}>;
+export declare function mergeTranscriptFrame(state: HeldTranscript, frame: TranscriptFrame): MergedFrame;