spexcode 0.7.0-next.0 → 0.7.0-next.10

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';
@@ -1100,7 +1102,7 @@ export function toSession(rec, status, lv, activity = null) {
     const pp = prompt ? oneLinePreview(prompt) : null;
     const parts = { id: rec.session, name: rec.name, node: rec.node, title: rec.title, branch: rec.branch, activity: act, note: rec.note, promptPreview: pp };
     const harness = harnessById(rec.harness || defaultHarness.id);
-    return { id: rec.session, node: rec.node, branch: rec.branch, label: deriveLabel(parts), title: deriveTitle(parts), raw: { name: rec.name, title: rec.title }, path: rec.worktreePath, parent: rec.parent, harness: harness.id, capabilities: { headless: harness.headless }, launcher: rec.launcher, lifecycle: rec.status, proposal: rec.proposal, merges: rec.merges, note: rec.note, status, liveness: lv, archived: rec.archived, closedAt: rec.archived ? rec.closedAt : null, archiveHazard: null, prompt, promptPreview: pp, created: rec.createdAt, activity: act, sortKey: rec.sortKey, files: readSessionFiles(rec.session), web: readSessionWebs(rec.session), ...(rec.zcodeChildSessionIds?.length ? { zcodeChildSessionIds: [...rec.zcodeChildSessionIds] } : {}) };
+    return { id: rec.session, node: rec.node, branch: rec.branch, label: deriveLabel(parts), title: deriveTitle(parts), raw: { name: rec.name, title: rec.title }, path: rec.worktreePath, parent: rec.parent, harness: harness.id, capabilities: { headless: harness.headless }, launcher: rec.launcher, lifecycle: rec.closedAt ? 'archived' : rec.status, proposal: rec.closedAt ? null : rec.proposal, merges: rec.merges, note: rec.note, status, liveness: lv, archived: rec.archived || !!rec.closedAt, closedAt: rec.closedAt, archiveHazard: null, prompt, promptPreview: pp, created: rec.createdAt, activity: act, sortKey: rec.sortKey, files: readSessionFiles(rec.session), web: readSessionWebs(rec.session), ...(rec.zcodeChildSessionIds?.length ? { zcodeChildSessionIds: [...rec.zcodeChildSessionIds] } : {}) };
 }
 // @@@zcode child identity - ZCode owns the child id and SpexCode owns the session record. The writer accepts
 // only their exact declared pair; names, worktrees, branches, and timestamps are deliberately not candidates.
@@ -1174,7 +1176,7 @@ export async function listArchivedSessionIndex(probe) {
         if (entry.kind !== 'ok')
             continue;
         const rec = fromRaw(entry.raw);
-        if (!rec.governed || !rec.archived)
+        if (!rec.governed || (!rec.archived && !rec.closedAt))
             continue;
         const parts = {
             id: rec.session, name: rec.name, node: rec.node, title: rec.title, branch: rec.branch,
@@ -1303,7 +1305,11 @@ export async function listSessions(includeArchived = false) {
         // missing durable cold proof is also legacy: leaf liveness alone cannot prove a Codex loaded thread was
         // unloaded, so it remains visible until an explicit archive repair.
         const cleanCold = projectedRecord.archived && !changedDuringCensus.has(id) && hasValidColdProof(projectedRecord) && physical === 'offline' && (!residentRequired || resident?.healthy === true);
-        const projected = projectedRecord.archived && !cleanCold ? { ...projectedRecord, archived: false, stopped: false } : projectedRecord;
+        // A published close is terminal public history even if a later census cannot prove the old adapter fully
+        // unloaded. Only legacy archived rows without closedAt may be exposed as a working hazard for repair.
+        const projected = projectedRecord.archived && !cleanCold && !projectedRecord.closedAt
+            ? { ...projectedRecord, archived: false, stopped: false }
+            : projectedRecord;
         const projectedLv = projected === projectedRecord
             ? sessionHarness.runtimeOwnership === 'adapter'
                 ? adapterResidentLiveness(projectedRecord, resident)
@@ -1704,11 +1710,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)))) {
@@ -1788,12 +1828,16 @@ export function canonicalRecordProjection(rec, canonical) {
     // The application row is the only lifecycle fact after cutover. A JSON status is historical envelope data,
     // so it must not win merely because it says waiting/error/archived while the canonical row says otherwise.
     if (!canonical) {
-        return rec;
+        return ('closedAt' in rec && rec.closedAt
+            ? { ...rec, archived: true }
+            : rec);
     }
+    const closed = 'closedAt' in rec && !!rec.closedAt;
     return {
         ...rec,
-        status: canonical.status,
-        proposal: canonical.proposal,
+        archived: closed ? true : rec.archived,
+        status: (closed ? 'archived' : canonical.status),
+        proposal: (closed ? null : canonical.proposal),
         note: canonical.note,
         parent: canonical.parentSessionId,
     };
@@ -2488,9 +2532,53 @@ 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(() => {
+            // The event loop may have been blocked past the wall after the kernel completed the handshake. In that
+            // case Node has not emitted `connect` yet, but `connecting` is already false; acceptance still proves
+            // presence and must not be relabelled as an unavailable backend.
+            if (!socket.connecting || socket.readyState === 'open')
+                return finish(() => resolve(false));
+            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 +2586,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 {
@@ -2988,7 +3074,7 @@ async function prepareSession(prompt, parent, launcher, name, context) {
                 try {
                     gitMutationStarted = true;
                     traceSessionCreate(id, requestDigest, phase, 'start', 'worktree-add');
-                    const added = await withGitAbortSignal(signal, () => gitTry(['-C', root, 'worktree', 'add', '-b', branch, path, startPoint], { extraEnv: DEFER_FOOTPRINT_REFRESH }));
+                    const added = await withGitAbortSignal(signal, () => gitTry(['-C', root, 'worktree', 'add', '--no-track', '-b', branch, path, startPoint], { extraEnv: DEFER_FOOTPRINT_REFRESH }));
                     traceSessionCreate(id, requestDigest, phase, 'finish', 'worktree-add');
                     if (added.ok)
                         Object.assign(owned, { path: true, worktree: true, branch: true });
@@ -4711,12 +4797,25 @@ async function closeOwnedSessionUnlocked(id, wt, _source, unboundStopped = false
         throw new ResourceConflict(`refusing to finish close for ${id}: session record disappeared before publication`);
     writeRecord({
         ...latest,
+        proposal: null,
         archived: true,
         closedAt: latest.closedAt || new Date().toISOString(),
         stopped: true,
         coldProof: latest.coldProof || coldProofFor(latest),
         adapterRecovery: null,
     });
+    // The canonical lifecycle must settle at the same terminal boundary as the durable close fact. `archived`
+    // is an internal terminal marker; public projections render its closed record as `retired`.
+    const application = configuredSessionApplicationIfCutover();
+    if (application?.readState(id)) {
+        application.transitionSession(id, {
+            status: 'archived',
+            proposal: null,
+            note: latest.note,
+            parentSessionId: latest.parent,
+            recipientSessionIds: canonicalWatchRecipients(application, id, 'archived'),
+        });
+    }
     let slot = null;
     try {
         slot = existsSync(wt.path) ? treeSlotDir(wt.path) : null;
@@ -5289,6 +5388,8 @@ export async function drainSession(id) {
                         const removed = application.dequeuePendingMessage(id, msg.messageId);
                         if (!removed || removed.messageId !== msg.messageId)
                             throw new ResourceConflict(`canonical queue head changed while delivering ${id}`);
+                        if (!msg.senderSessionId)
+                            markHumanPromptActive(id);
                     }
                 });
                 return;
@@ -5315,6 +5416,8 @@ export async function drainSession(id) {
                 const removed = application.dequeueForRuntime(id, 'spex-governed', binding.bindingGeneration, msg.messageId);
                 if (!removed || removed.messageId !== msg.messageId)
                     throw new ResourceConflict(`canonical queue head changed while delivering ${id}`);
+                if (!msg.senderSessionId)
+                    markHumanPromptActive(id);
             }
         });
         return;

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

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/spec-cli",
-  "version": "0.7.0-next.0",
+  "version": "0.7.0-next.10",
   "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.0",
-    "@spexcode/session-selflaunch": "0.7.0-next.0",
-    "@spexcode/spec-core": "0.7.0-next.0",
-    "@spexcode/spec-eval": "0.7.0-next.0",
-    "@spexcode/spec-forge": "0.7.0-next.0",
-    "@spexcode/transcript": "0.7.0-next.0",
+    "@spexcode/session-application": "0.7.0-next.10",
+    "@spexcode/session-selflaunch": "0.7.0-next.10",
+    "@spexcode/spec-core": "0.7.0-next.10",
+    "@spexcode/spec-eval": "0.7.0-next.10",
+    "@spexcode/spec-forge": "0.7.0-next.10",
+    "@spexcode/transcript": "0.7.0-next.10",
     "smol-toml": "^1.8.0"
   },
   "devDependencies": {

package/node_modules/@spexcode/spec-cli/templates/spec/project/.plugins/skills/merge/spec.md

@@ -19,9 +19,15 @@ Land the current SpexCode session's branch; do not dispatch another merge reques
 3. Immediately before landing, verify
    `git merge-base --is-ancestor <source-head> <session-head>`. If it fails, sync again. A clean textual merge
    is not product proof.
-4. In the source-of-truth checkout, make one `--no-ff` merge of the already-synced session tip. Do not resolve
-   conflicts there. If unrelated dirty work prevents the merge, preserve it byte-for-byte and report the exact
-   overlap rather than forcing, resetting, or committing it.
+4. Land with one `--no-ff` merge of the already-synced session tip, without touching the source checkout's
+   dirty work. Git refuses a merge over a dirty index, so do NOT clear it: add a temporary detached worktree of
+   the source head (`git worktree add --detach <tmp> <source-branch>`), make the `--no-ff` merge there, then
+   fast-forward the source checkout to that commit (`git merge --ff-only <tmp-head>`) and remove the temporary
+   worktree. A fast-forward never rewrites a path the merge did not change, so user-owned dirty files keep
+   their bytes and their staged/unstaged state. Never `git restore`, `reset`, `checkout`, `stash`, or overwrite
+   a user-owned path — an unstaged edit has no blob anywhere, so "save and put back" loses it, and a copy of the
+   same path from another worktree is a different version, not a restoration. Do not resolve conflicts in the
+   source checkout; if the merge genuinely overlaps a user-owned path, stop and report the exact overlap.
 5. Verify the source checkout has no `MERGE_HEAD`, the session tip is its ancestor, unrelated dirty
    fingerprints are unchanged, and the post-merge gates pass. Push the source-of-truth branch only after
    those checks.

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

@@ -122,6 +122,7 @@ export declare function historyCacheStats(): {
     historyRoots: number;
     driftRoots: number;
 };
+export declare function pruneHistoryCaches(activeRoots: Iterable<string>): void;
 export declare function resetHistoryCachesForTests(): void;
 export declare function historyEventCachePathForTests(root: string): string;
 export declare function ancestorsOf(idx: Reachability, sha: string): Uint8Array | undefined;

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

@@ -2270,6 +2270,31 @@ export function sourceIndexes(root, tip = 'HEAD') {
 export function historyCacheStats() {
     return { historyHeads: indexCache.size, driftHeads: driftIdxCache.size, historyRoots: indexRoots.size, driftRoots: driftRoots.size };
 }
+// A backend snapshot is the authority for which checkout roots are live. Release cache ownership for roots
+// that disappeared from that snapshot so closed session worktrees do not keep immutable history warm until
+// the generic slot bound happens to evict them. Shared entries survive while another live root still names
+// the same immutable key; an in-flight promise remains usable by its current caller even after its cache key
+// is released.
+export function pruneHistoryCaches(activeRoots) {
+    const active = new Set([...activeRoots].map(rootKey));
+    for (const [root] of indexRoots)
+        if (!active.has(root))
+            indexRoots.delete(root);
+    for (const [root] of driftRoots)
+        if (!active.has(root))
+            driftRoots.delete(root);
+    const referencedHistory = new Set(indexRoots.values());
+    const referencedDrift = new Set(driftRoots.values());
+    for (const key of indexCache.keys())
+        if (!referencedHistory.has(key))
+            indexCache.delete(key);
+    for (const key of driftIdxCache.keys())
+        if (!referencedDrift.has(key))
+            driftIdxCache.delete(key);
+    for (const root of eventPathMemo.keys())
+        if (!active.has(root))
+            eventPathMemo.delete(root);
+}
 // Tests deliberately clear process-local promises and path identity to exercise both cold and read-back paths.
 // Production callers retain the bounded index caches; this is not a correctness escape hatch.
 export function resetHistoryCachesForTests() {

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

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

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

@@ -1,4 +1,6 @@
 import { type TranscriptRead, type TranscriptReader, type TranscriptTool, type TranscriptTurn } from './turns.js';
+export { TranscriptReadError } from './turns.js';
+export type { TranscriptRange, TranscriptRead, TranscriptReader, TranscriptTail, TranscriptTool, TranscriptTurn } from './turns.js';
 export type StreamTool = Readonly<Omit<TranscriptTool, 'output'> & {
     output?: null;
 }>;

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

@@ -1,4 +1,6 @@
 import { TranscriptReadError } from './turns.js';
+// the browser-safe entry is complete on its own: the normalized shape travels with the frames that carry it
+export { TranscriptReadError } from './turns.js';
 export const isErrorFrame = (frame) => 'error' in frame;
 // The revision an absent source reports: the thread has not started writing. Not an error.
 export const ABSENT_REVISION = 'absent';

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

@@ -8,6 +8,7 @@ export type MutableTool = {
     output?: string;
     outputLines: number;
     outputBytes: number;
+    outcome?: ToolOutcome;
 };
 export type MutableTurn = {
     id: string | null;
@@ -16,18 +17,25 @@ export type MutableTurn = {
     text?: string;
     tools: MutableTool[];
 };
+export type ToolOutcome = 'failed' | 'rejected';
 export type ParsedEvent = {
     at: number | null;
     turn: MutableTurn | null;
     toolOutputs?: readonly {
         id: string;
         text: string;
+        outcome?: ToolOutcome;
     }[];
 };
 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;
+export declare function hermesEvents(value: unknown): ParsedEvent[];
 export declare function opencodeEvents(value: unknown): ParsedEvent[];
 export declare class IntervalCollector {
     readonly turns: MutableTurn[];