spexcode 0.7.0-next.1 → 0.7.0-next.3

package/node_modules/@spexcode/session-application/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/session-application",
-  "version": "0.7.0-next.1",
+  "version": "0.7.0-next.3",
   "publishConfig": { "access": "public" },
   "type": "module",
   "description": "Adopter-owned composition of session protocol and topology transactions.",
@@ -16,10 +16,10 @@
     "test": "npm run build && tsx --import ../../scripts/test-home.mjs --test src/*.test.ts"
   },
   "dependencies": {
-    "@spexcode/session-events": "0.7.0-next.1",
-    "@spexcode/session-protocol": "0.7.0-next.1",
-    "@spexcode/session-runtime": "0.7.0-next.1",
-    "@spexcode/session-topology": "0.7.0-next.1"
+    "@spexcode/session-events": "0.7.0-next.3",
+    "@spexcode/session-protocol": "0.7.0-next.3",
+    "@spexcode/session-runtime": "0.7.0-next.3",
+    "@spexcode/session-topology": "0.7.0-next.3"
   },
   "devDependencies": {
     "@types/node": "^20.16.0",

package/node_modules/@spexcode/session-events/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/session-events",
-  "version": "0.7.0-next.1",
+  "version": "0.7.0-next.3",
   "publishConfig": { "access": "public" },
   "type": "module",
   "description": "Append-only session facts and deterministic ordered replay inputs.",
@@ -15,7 +15,7 @@
     "prepublishOnly": "node ../../scripts/release-publish.mjs --from-package-publish",
     "test": "npm run build && tsx --import ../../scripts/test-home.mjs --test src/*.test.ts"
   },
-  "dependencies": { "@spexcode/session-protocol": "0.7.0-next.1" },
+  "dependencies": { "@spexcode/session-protocol": "0.7.0-next.3" },
   "devDependencies": {
     "@types/node": "^20.16.0",
     "tsx": "^4.19.2",

package/node_modules/@spexcode/session-protocol/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/session-protocol",
-  "version": "0.7.0-next.1",
+  "version": "0.7.0-next.3",
   "type": "module",
   "description": "A durable SQLite session message protocol.",
   "files": [

package/node_modules/@spexcode/session-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/session-runtime",
-  "version": "0.7.0-next.1",
+  "version": "0.7.0-next.3",
   "publishConfig": { "access": "public" },
   "type": "module",
   "description": "Adopter-owned bindings between protocol addresses and native runtime identities.",
@@ -15,7 +15,7 @@
     "prepublishOnly": "node ../../scripts/release-publish.mjs --from-package-publish",
     "test": "npm run build && tsx --import ../../scripts/test-home.mjs --test src/*.test.ts"
   },
-  "dependencies": { "@spexcode/session-protocol": "0.7.0-next.1" },
+  "dependencies": { "@spexcode/session-protocol": "0.7.0-next.3" },
   "devDependencies": {
     "@types/node": "^20.16.0",
     "tsx": "^4.19.2",

package/node_modules/@spexcode/session-selflaunch/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/session-selflaunch",
-  "version": "0.7.0-next.1",
+  "version": "0.7.0-next.3",
   "publishConfig": { "access": "public" },
   "type": "module",
   "description": "A fail-closed self-launch adopter for the SpexCode session protocol.",
@@ -24,8 +24,8 @@
     "test": "npm run build && tsx --import ../../scripts/test-home.mjs --test src/*.test.ts"
   },
   "dependencies": {
-    "@spexcode/session-protocol": "0.7.0-next.1",
-    "@spexcode/session-runtime": "0.7.0-next.1"
+    "@spexcode/session-protocol": "0.7.0-next.3",
+    "@spexcode/session-runtime": "0.7.0-next.3"
   },
   "devDependencies": {
     "@types/node": "^20.16.0",

package/node_modules/@spexcode/session-topology/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/session-topology",
-  "version": "0.7.0-next.1",
+  "version": "0.7.0-next.3",
   "publishConfig": { "access": "public" },
   "type": "module",
   "description": "A neutral SQLite relation model for session addresses.",
@@ -15,7 +15,7 @@
     "prepublishOnly": "node ../../scripts/release-publish.mjs --from-package-publish",
     "test": "npm run build && tsx --import ../../scripts/test-home.mjs --test src/*.test.ts"
   },
-  "dependencies": { "@spexcode/session-protocol": "0.7.0-next.1" },
+  "dependencies": { "@spexcode/session-protocol": "0.7.0-next.3" },
   "devDependencies": {
     "@types/node": "^20.16.0",
     "tsx": "^4.19.2",

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

@@ -1,4 +1,5 @@
 import { execFile, execFileSync, spawn } from 'node:child_process';
+import { createConnection } from 'node:net';
 import { promisify } from 'node:util';
 import { createHash, randomUUID } from 'node:crypto';
 import { readFileSync, writeFileSync, existsSync, renameSync, linkSync, mkdirSync, rmSync, readdirSync, realpathSync, statSync, unlinkSync } from 'node:fs';
@@ -15,6 +16,7 @@ import { readSessionFiles } from './session-files.js';
 import { readSessionWebs } from './session-web.js';
 import { acquireFreshSessionApplicationForCreate, configuredSessionApplicationIfCutover, initializeFreshSessionApplication, releaseFreshSessionApplicationForCreate, sessionApplicationCutoverState, setSessionApplicationCommitWake } from './session-application.js';
 import { jsonMigrationFencePath } from '@spexcode/session-application';
+import { decodeEventJson } from '@spexcode/session-events';
 import { withDeliveryLocks } from './delivery-lock.js';
 import { withSessionRecordLock, withSessionRecordLockSync as coreWithSessionRecordLockSync } from './session-record-lock.js';
 import { stripRefSigil } from './mentions.js';
@@ -1704,11 +1706,45 @@ let draining = false; // re-entrancy guard: only one drain pass runs at a time (
 // A native receipt is bound before the readiness fence validates it. Suppress only that immediate wake so
 // queued prompts cannot drain during the candidate window; the successful publication path drains normally.
 const readinessWakeSuppressed = new Set();
+// A readiness timeout is launch-phase evidence only until the session produces another durable event. The
+// first event at/after the readiness marker is the launch transition itself; anything after that proves the
+// worker progressed (including a declaration), so a late diagnostic is moot and must not replace its note.
+function hasLaterLaunchReadinessEvent(rec) {
+    const startedAt = rec.launchReadinessStartedAt;
+    if (!Number.isFinite(startedAt))
+        return false;
+    const application = configuredSessionApplicationIfCutover();
+    if (!application?.readState(rec.session))
+        return false;
+    const events = application.readEvents(rec.session);
+    const statusPayload = (event) => {
+        const payload = decodeEventJson(event.payload);
+        return payload && typeof payload === 'object' && !Array.isArray(payload) && 'status' in payload
+            ? payload : null;
+    };
+    const baseline = events.find((event) => {
+        if (event.occurredAtMs < Number(startedAt))
+            return false;
+        const payload = statusPayload(event);
+        return payload?.status === 'active';
+    });
+    return baseline ? events.some((event) => {
+        if (event.eventSeq <= baseline.eventSeq)
+            return false;
+        const payload = statusPayload(event);
+        if (!payload)
+            return false;
+        const note = payload.note;
+        return !(typeof note === 'string' && /^(?:queued launch readiness failed|launch readiness warning):/.test(note));
+    }) : false;
+}
 function noteQueuedLaunchFailureUnlocked(id, error, terminal = true, label, live = false) {
+    const rec = readRecord(id);
+    if (rec && (terminal || label === 'launch readiness warning') && hasLaterLaunchReadinessEvent(rec))
+        return;
     const reason = error instanceof Error ? error.message : String(error);
     const note = `${label ?? (terminal ? 'queued launch readiness failed' : 'launch readiness warning')}: ${reason}`;
     console.error(`spex: session ${id}: ${note}`);
-    const rec = readRecord(id);
     if (rec && !retirementReason(rec) && (rec.note !== note
         || (terminal && (rec.status !== 'error' || !rec.stopped || rec.launchReadinessStartedAt != null))
         || (!terminal && live && (rec.status === 'error' || rec.stopped)))) {
@@ -2488,9 +2524,46 @@ function isExplicitConnectionRefused(error) {
         return errors.length > 0 && errors.every(isExplicitConnectionRefused);
     return isExplicitConnectionRefused(error.cause);
 }
+async function establishBackendConnection(target) {
+    const parsed = new URL(target.url);
+    const port = Number(parsed.port) || (parsed.protocol === 'https:' ? 443 : 80);
+    return await new Promise((resolve, reject) => {
+        const socket = createConnection({ host: parsed.hostname, port });
+        let settled = false;
+        const finish = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            socket.destroy();
+            fn();
+        };
+        const timer = setTimeout(() => finish(() => {
+            const error = new Error(`backend connection was not accepted at ${target.url} within 1500ms`);
+            error.name = 'BackendError';
+            Object.assign(error, { code: 'backend_availability_indeterminate' });
+            reject(error);
+        }), 1500);
+        timer.unref?.();
+        socket.once('connect', () => finish(() => resolve(false)));
+        socket.once('error', (error) => finish(() => {
+            if (isExplicitConnectionRefused(error))
+                return resolve(true);
+            const failed = new Error(`backend availability is indeterminate at ${target.url}; refusing in-process session creation (${error instanceof Error ? error.message : error})`);
+            failed.name = 'BackendError';
+            Object.assign(failed, { code: 'backend_availability_indeterminate', cause: error });
+            reject(failed);
+        }));
+    });
+}
 async function probeSessionCreateAuthority(target) {
+    // TCP acceptance establishes presence. The identity route can be delayed by a busy backend event loop,
+    // so it gets the ordinary create request deadline instead of a short availability deadline.
+    const refused = await establishBackendConnection(target);
+    if (refused)
+        return true;
     const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), 1500);
+    const timer = setTimeout(() => controller.abort(new Error('backend authority request timed out')), sessionCreateTimeoutMs() + 5_000);
     timer.unref?.();
     let response;
     try {
@@ -2498,11 +2571,9 @@ async function probeSessionCreateAuthority(target) {
     }
     catch (error) {
         clearTimeout(timer);
-        if (isExplicitConnectionRefused(error))
-            return true;
-        const failed = new Error(`backend availability is indeterminate at ${target.url}; refusing in-process session creation (${error instanceof Error ? error.message : error})`);
+        const failed = new Error(`backend authority read failed after connection at ${target.url}; refusing in-process session creation (${error instanceof Error ? error.message : error})`);
         failed.name = 'BackendError';
-        Object.assign(failed, { code: 'backend_availability_indeterminate', cause: error });
+        Object.assign(failed, { code: 'backend_authority_read_failed', cause: error });
         throw failed;
     }
     try {

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

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/spec-cli",
-  "version": "0.7.0-next.1",
+  "version": "0.7.0-next.3",
   "type": "module",
   "description": "SpexCode CLI + server. The root spexcode package delegates to this compiled package; dashboard assets live in @spexcode/spec-dashboard.",
   "bin": {
@@ -35,12 +35,12 @@
     "test": "tsx --import ../scripts/test-home.mjs --test src/*.test.ts"
   },
   "dependencies": {
-    "@spexcode/session-application": "0.7.0-next.1",
-    "@spexcode/session-selflaunch": "0.7.0-next.1",
-    "@spexcode/spec-core": "0.7.0-next.1",
-    "@spexcode/spec-eval": "0.7.0-next.1",
-    "@spexcode/spec-forge": "0.7.0-next.1",
-    "@spexcode/transcript": "0.7.0-next.1",
+    "@spexcode/session-application": "0.7.0-next.3",
+    "@spexcode/session-selflaunch": "0.7.0-next.3",
+    "@spexcode/spec-core": "0.7.0-next.3",
+    "@spexcode/spec-eval": "0.7.0-next.3",
+    "@spexcode/spec-forge": "0.7.0-next.3",
+    "@spexcode/transcript": "0.7.0-next.3",
     "smol-toml": "^1.8.0"
   },
   "devDependencies": {

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

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/spec-core",
-  "version": "0.7.0-next.1",
+  "version": "0.7.0-next.3",
   "type": "module",
   "description": "SpexCode's dependency-minimal spec graph core.",
   "files": [

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

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/spec-eval",
-  "version": "0.7.0-next.1",
+  "version": "0.7.0-next.3",
   "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.7.0-next.1"
+    "@spexcode/spec-core": "0.7.0-next.3"
   },
   "devDependencies": {
     "@types/node": "^20.16.0",

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

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

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

@@ -27,6 +27,8 @@ export type ParsedEvent = {
 export type Parse = (value: unknown) => ParsedEvent | null;
 export declare function claudeEvent(value: unknown): ParsedEvent | null;
 export declare function codexEvent(value: unknown): ParsedEvent | null;
+export declare function codexAppServerEvent(value: unknown): ParsedEvent | null;
+export declare function codexAppServerStream(): Parse;
 export declare function piEvent(value: unknown): ParsedEvent | null;
 export declare function geminiEvent(value: unknown): ParsedEvent | null;
 export declare function openclawEvent(value: unknown): ParsedEvent | null;

package/node_modules/@spexcode/transcript/dist/parsers.js

@@ -54,8 +54,22 @@ const lineCount = (value) => value ? value.split(/\r?\n/).length : 0;
 // --- the seven native shapes -------------------------------------------------------------------------------
 export function claudeEvent(value) {
     const entry = object(value);
-    const message = object(entry?.message);
-    if (!entry || !message)
+    if (!entry)
+        return null;
+    // A message steered into a RUNNING turn (stream-json `type:user` on stdin, a queued command in the TUI) is not
+    // recorded as a `user` message: Claude writes it as an `attachment` of type `queued_command` carrying the prompt
+    // blocks. It is the person's turn all the same, and the one place a steer becomes observable — hooks never fire
+    // for it — so the reader draws it as a user turn at the moment it entered the conversation.
+    if (entry.type === 'attachment') {
+        const attachment = object(entry.attachment);
+        const queuedAt = at(entry);
+        if (attachment?.type !== 'queued_command' || queuedAt === null)
+            return null;
+        const text = items(attachment.prompt).map((block) => string(object(block)?.text)).filter(Boolean).join('\n') || null;
+        return text ? { at: queuedAt, turn: { id: idOf(entry), at: queuedAt, role: 'user', text, tools: [] } } : null;
+    }
+    const message = object(entry.message);
+    if (!message)
         return null;
     const eventAt = at(entry) ?? at(message);
     if (eventAt === null)
@@ -120,6 +134,101 @@ export function codexEvent(value) {
     }
     return null;
 }
+// Codex app-server notifications are a different native stream from rollout lines. Keep this mapping stateless:
+// a caller that needs streamed prose uses codexAppServerStream below, while file and in-memory sources still
+// share the same one-record parser contract.
+export function codexAppServerEvent(value) {
+    const entry = object(value);
+    const params = object(entry?.params);
+    if (!entry || !params || typeof entry.method !== 'string')
+        return null;
+    const item = object(params.item);
+    const method = entry.method;
+    const recognized = method === 'item/agentMessage/delta' || method === 'item/started' || method === 'item/completed';
+    if (!recognized)
+        return null;
+    const eventAt = timestamp(params.emittedAtMs) ?? timestamp(params.startedAtMs) ?? timestamp(params.completedAtMs);
+    if (eventAt === null)
+        return { at: null, turn: null };
+    if (method === 'item/agentMessage/delta') {
+        const id = string(params.itemId);
+        const delta = string(params.delta);
+        return id && delta !== null
+            ? { at: eventAt, turn: { id, at: eventAt, role: 'assistant', text: delta, tools: [] } }
+            : null;
+    }
+    if ((method !== 'item/started' && method !== 'item/completed') || !item)
+        return null;
+    const id = string(item.id);
+    const type = string(item.type);
+    if (!id || !type)
+        return null;
+    if (type === 'userMessage') {
+        const text = blockText(item.content);
+        return text ? { at: eventAt, turn: { id, at: eventAt, role: 'user', text, tools: [] } } : null;
+    }
+    if (type === 'agentMessage') {
+        const text = string(item.text);
+        return { at: eventAt, turn: { id, at: eventAt, role: 'assistant', text: text ?? undefined, tools: [] } };
+    }
+    const toolTypes = new Set(['commandExecution', 'functionCall', 'customToolCall', 'mcpToolCall', 'dynamicToolCall']);
+    if (!toolTypes.has(type))
+        return null;
+    if (method === 'item/started') {
+        const name = type === 'commandExecution' ? 'command'
+            : string(item.name) ?? string(item.tool) ?? (type === 'mcpToolCall' ? 'mcp' : 'tool');
+        const input = item.arguments !== undefined ? item.arguments
+            : item.input !== undefined ? item.input
+                : item.command !== undefined ? item.command
+                    : undefined;
+        return { at: eventAt, turn: { id, at: eventAt, role: 'assistant', tools: [{ id, name, input: input === undefined ? undefined : compact(input), outputLines: 0, outputBytes: 0 }] } };
+    }
+    let output = undefined;
+    if (type === 'commandExecution')
+        output = item.aggregatedOutput;
+    else if (type === 'functionCall' || type === 'customToolCall')
+        output = item.output ?? item.result;
+    else if (type === 'mcpToolCall')
+        output = item.result ?? item.error;
+    else if (type === 'dynamicToolCall')
+        output = item.contentItems ?? item.output ?? item.error;
+    return output === undefined || output === null
+        ? { at: eventAt, turn: null }
+        : { at: eventAt, turn: null, toolOutputs: [{ id, text: compact(output) }] };
+}
+// Agent-message deltas are fragments of one native item. The closure remembers only that item's text and
+// re-emits its native id, allowing IntervalCollector to replace the earlier turn in place.
+export function codexAppServerStream() {
+    const textByItem = new Map();
+    return (value) => {
+        const parsed = codexAppServerEvent(value);
+        if (!parsed)
+            return null;
+        const entry = object(value);
+        const params = object(entry?.params);
+        const item = object(params?.item);
+        if (entry?.method === 'item/agentMessage/delta') {
+            const id = string(params?.itemId);
+            if (!id || !parsed.turn)
+                return parsed;
+            const text = (textByItem.get(id) ?? '') + (parsed.turn.text ?? '');
+            textByItem.set(id, text);
+            return { ...parsed, turn: { ...parsed.turn, text } };
+        }
+        if (item && item.type === 'agentMessage') {
+            const id = string(item.id);
+            if (id) {
+                const text = string(item.text);
+                if (text !== null || !textByItem.has(id))
+                    textByItem.set(id, text ?? '');
+                const turn = parsed.turn;
+                if (turn)
+                    return { ...parsed, turn: { ...turn, text: textByItem.get(id) || undefined } };
+            }
+        }
+        return parsed;
+    };
+}
 const blockText = (content) => typeof content === 'string'
     ? string(content)
     : items(content).map((block) => string(object(block)?.text)).filter(Boolean).join('\n') || null;
@@ -366,14 +475,31 @@ export class IntervalCollector {
                 this.synthesized.set(base, seen + 1);
                 turn.id = seen ? `${base}#${seen}` : base;
             }
-            this.turns.push(turn);
-            for (const tool of turn.tools)
-                this.byTool.set(tool.id, tool);
-            if (this.turns.length > MAX_TURNS) {
-                const dropped = this.turns.shift();
-                for (const tool of dropped.tools)
-                    this.evicted.add(tool.id);
-                this.omittedTurns++;
+            const existingAt = this.turns.findIndex((candidate) => candidate.id === turn.id);
+            if (existingAt >= 0) {
+                const existing = this.turns[existingAt];
+                const incomingTools = new Map(turn.tools.map((tool) => [tool.id, tool]));
+                const tools = existing.tools.map((tool) => {
+                    const incoming = incomingTools.get(tool.id);
+                    incomingTools.delete(tool.id);
+                    return incoming ? { ...tool, ...incoming, output: incoming.output ?? tool.output } : tool;
+                });
+                tools.push(...incomingTools.values());
+                const replacement = { ...existing, ...turn, text: turn.text ?? existing.text, tools };
+                this.turns[existingAt] = replacement;
+                for (const tool of replacement.tools)
+                    this.byTool.set(tool.id, tool);
+            }
+            else {
+                this.turns.push(turn);
+                for (const tool of turn.tools)
+                    this.byTool.set(tool.id, tool);
+                if (this.turns.length > MAX_TURNS) {
+                    const dropped = this.turns.shift();
+                    for (const tool of dropped.tools)
+                        this.evicted.add(tool.id);
+                    this.omittedTurns++;
+                }
             }
         }
         return this.pastRange;

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

@@ -1,6 +1,6 @@
 import { type TranscriptReader } from './turns.js';
 export declare function claudeTranscriptPath(threadId: string, root?: string): string | null;
-export declare function codexRolloutPath(threadId: string, root?: string): string | null;
+export declare function codexRolloutPath(threadId: string, root?: string, archive?: string): string | null;
 export declare function piSessionPath(threadId: string, root?: string): string | null;
 export declare function geminiTranscriptPath(threadId: string, root?: string): string | null;
 export declare function openclawTranscriptPath(threadId: string, root?: string): string | null;

package/node_modules/@spexcode/transcript/dist/readers.js

@@ -1,7 +1,7 @@
 import { execFileSync } from 'node:child_process';
 import { closeSync, openSync, readFileSync, readSync, readdirSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { TranscriptReadError } from './turns.js';
 import { IntervalCollector, claudeEvent, codexEvent, geminiEvent, hermesEvents, openclawEvent, opencodeEvents, piEvent } from './parsers.js';
 // THE NATIVE-THREAD READERS. Each harness keeps its conversation somewhere private — Claude's project JSONL,
@@ -31,7 +31,10 @@ export function claudeTranscriptPath(threadId, root = projectTranscriptRoot()) {
 const codexSessionsDir = () => join(process.env.CODEX_HOME || join(homedir(), '.codex'), 'sessions');
 // Walk newest day first and return on the first hit; the walk is exhaustive rather than capped, because
 // future-dated junk under sessions/ sorts above every real day and a cap once masked every real rollout.
-export function codexRolloutPath(threadId, root = codexSessionsDir()) {
+// A thread Codex has ARCHIVED (the app-server's thread/archive, which a closed session runs) keeps its
+// rollout, moved out of the dated tree into the flat `archived_sessions/` beside it — a closed session's
+// conversation is still on disk and still readable, so the locator looks there second.
+export function codexRolloutPath(threadId, root = codexSessionsDir(), archive = join(dirname(root), 'archived_sessions')) {
     for (const year of children(root))
         for (const month of children(join(root, year)))
             for (const day of children(join(root, year, month))) {
@@ -40,7 +43,8 @@ export function codexRolloutPath(threadId, root = codexSessionsDir()) {
                 if (file)
                     return join(dir, file);
             }
-    return null;
+    const archived = children(archive).find((name) => name.includes(threadId));
+    return archived ? join(archive, archived) : null;
 }
 const piSessionsRoot = () => join(process.env.SPEXCODE_PI_AGENT_DIR || join(homedir(), '.pi', 'agent'), 'sessions');
 const piSessionPaths = new Map();

package/node_modules/@spexcode/transcript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/transcript",
-  "version": "0.7.0-next.1",
+  "version": "0.7.0-next.3",
   "type": "module",
   "description": "Normalized agent transcripts: one parser per harness, a bounded interval reader over a native thread file or an in-memory event stream, and the full/delta frame protocol every transport and renderer share.",
   "files": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spexcode",
-  "version": "0.7.0-next.1",
+  "version": "0.7.0-next.3",
   "type": "module",
   "description": "SpexCode — a spec-driven, self-developing dev tool. The `spex` CLI + spec server reads the .spec tree and its git history, and serves the dashboard.",
   "license": "MIT",
@@ -44,7 +44,7 @@
     "prepack": "node scripts/sync-init-plugins.mjs --check && node scripts/prepack.mjs"
   },
   "dependencies": {
-    "@spexcode/spec-cli": "0.7.0-next.1"
+    "@spexcode/spec-cli": "0.7.0-next.3"
   },
   "publishConfig": {
     "access": "public"