@spexcode/spec-cli 0.7.0-next.5 → 0.7.0-next.7

package/dist/client.js

@@ -132,10 +132,10 @@ const post = (body) => ({ method: 'POST', headers: { 'content-type': 'applicatio
 const seg = (id) => encodeURIComponent(id);
 // A rendezvous liveness probe can displace the real delivery client.
 function cachedStatus(rec) {
-    if (!rec.worktreePath || !existsSync(rec.worktreePath))
-        return 'retired';
     if (rec.archived)
         return 'offline';
+    if (!rec.worktreePath || !existsSync(rec.worktreePath))
+        return 'retired';
     if (rec.status === 'awaiting')
         return displayStatusForProposal(rec.proposal);
     return rec.status === 'active' || rec.status === 'idle' ? 'unknown' : rec.status;
@@ -179,9 +179,11 @@ export function localCachedSessions(includeArchived = false) {
         if (!state)
             continue;
         const lifecycle = state.status;
-        const status = state.status === 'awaiting'
-            ? displayStatusForProposal(state.proposal)
-            : state.status === 'archived' ? 'offline' : state.status;
+        const status = state.status === 'archived'
+            ? 'offline'
+            : state.status === 'awaiting'
+                ? displayStatusForProposal(state.proposal)
+                : state.status;
         rows.push({
             id,
             node: null,

package/dist/harness.d.ts

@@ -206,6 +206,7 @@ export type DispatchResult = {
 };
 export type HarnessDeliveryRecord = {
     session: string;
+    harness?: string;
     stopped?: boolean;
     archived?: boolean;
     worktreePath?: string;

package/dist/harness.js

@@ -18,7 +18,8 @@ import { runtimeRoot, mainCheckout, readConfig, sessionArtifactPath, spexcodeHom
 import { git } from '@spexcode/spec-core';
 import { shQuote } from './sh.js';
 import { detachedRuntimeGenerationToken, migrateLegacyDetachedRuntimeReceipt, processStartToken, verifyDetachedRuntime } from '@spexcode/spec-core';
-import { codexGenerationEndpoints, codexGenerationSocketPath, currentCodexGeneration, legacyCodexGenerationEndpoint, readCodexGenerationLedger, prepareCodexGenerationClose, resolveCodexGenerationForClose, resolveCodexGenerationForSession } from './codex-runtime-generations.js';
+import { codexGenerationEndpoints, codexGenerationSocketPath, currentCodexGeneration, legacyCodexGenerationEndpoint, readCodexGenerationLedger, prepareCodexGenerationClose, resolveCodexGenerationForClose, resolveCodexGenerationForResume, resolveCodexGenerationForSession } from './codex-runtime-generations.js';
+import { spawnDetachedRuntime } from './runtime-ownership.js';
 import { writeFileIfChanged } from './file-write.js';
 import { claudeTranscript, codexRolloutPath, codexTranscript, opencodeTranscript, piTranscript, unsupportedTranscript } from '@spexcode/transcript';
 import { harnessIdentity, HARNESS_IDENTITIES } from '@spexcode/spec-core';
@@ -2282,7 +2283,21 @@ async function deliverViaCodexAppServer(rec, text) {
     // the socket is PER-PROJECT (the runtime root), shared by every worktree's thread; the owned thread id on
     // the record picks out THIS session's thread.
     const runtimeDir = rec.runtimeDir ?? runtimeRoot();
-    const endpoint = rec.harnessSessionId ? codexEndpointForRecord(rec, runtimeDir) : currentCodexGeneration(runtimeDir);
+    let endpoint = rec.harnessSessionId ? codexEndpointForRecord(rec, runtimeDir) : currentCodexGeneration(runtimeDir);
+    // A generation may be reclaimed after rotation or a host restart while the session record remains valid.
+    // Repair that stale route at the delivery boundary using the same exact-thread re-pin used by resume, so an
+    // accepted message is not left indefinitely in the queue just because no later human resume was requested.
+    if ((!endpoint || !existsSync(endpoint.socketPath)) && rec.harnessSessionId) {
+        const command = codexBaseCmd(rec.launchCmd || 'codex');
+        const env = { ...process.env };
+        for (const key of sessionIdentityEnvVars())
+            delete env[key];
+        const start = async (candidate) => {
+            await spawnDetachedRuntime({ cwd: runtimeDir, logFile: candidate.logFile, pidFile: candidate.pidFile,
+                receiptFile: candidate.receiptFile, command, args: ['app-server', '--listen', `unix://${candidate.socketPath}`], env });
+        };
+        endpoint = await resolveCodexGenerationForResume(runtimeDir, rec.session, rec.harnessSessionId, start);
+    }
     if (!endpoint)
         return { ok: false, error: `no exact Codex generation binding for session ${rec.session} — immediate poke unavailable` };
     const sock = endpoint.socketPath;
@@ -2297,6 +2312,14 @@ async function deliverViaCodexAppServer(rec, text) {
             return { ok: false, error: `${r.error} — immediate poke unavailable` };
         threadId = r.threadId;
     }
+    const delivered = await sendCodexAppServerTurn(sock, threadId, text, rec.worktreePath, rec.mid);
+    if (delivered.ok || rec.harness !== 'codex-headless' || !/not loaded in the app-server/u.test(delivered.error || ''))
+        return delivered;
+    // Headless Codex has no TUI resume step. An idle thread can be evicted from the shared server's loaded set;
+    // reload the exact rollout, then retry the same turn once. This is idempotent and does not create a new thread.
+    const reopened = await codexReopenThread(sock, threadId);
+    if (!reopened.ok)
+        return { ok: false, error: `${delivered.error}; ${reopened.error}` };
     return sendCodexAppServerTurn(sock, threadId, text, rec.worktreePath, rec.mid);
 }
 // idempotent replace of the content between sentinels; the user's own content above/below is preserved. The

package/dist/host-resources.js

@@ -145,6 +145,23 @@ const descendants = (root, procs) => {
     }
     return ids;
 };
+// tmux is a shared host for many independent session windows. Its inherited environment is therefore
+// not a launch receipt: a token on the server or one of its panes cannot charge the whole hosted tree.
+const isTmuxServer = (proc) => proc?.command === 'tmux: server';
+const hasTmuxAncestor = (pid, procs) => {
+    const seen = new Set();
+    let next = procs.get(pid)?.ppid;
+    while (next && !seen.has(next)) {
+        seen.add(next);
+        const parent = procs.get(next);
+        if (!parent)
+            return false;
+        if (isTmuxServer(parent))
+            return true;
+        next = parent.ppid;
+    }
+    return false;
+};
 const publicRecordInventory = () => {
     const entries = listSessionIds().map(readPublicRecordEntry);
     const application = configuredSessionApplicationIfCutover();
@@ -345,13 +362,13 @@ const buildInventory = (procs, publicRecords = publicRecordInventory()) => {
     for (const p of procs.values()) {
         const acting = actingSession(p);
         const fallback = p.env.SPEXCODE_SESSION_ID;
-        const sid = acting ?? (fallback ? byId.get(fallback) : undefined);
+        const sid = acting ?? (!hasTmuxAncestor(p.pid, procs) && !isTmuxServer(p) && fallback ? byId.get(fallback) : undefined);
         if (sid)
             ownership.set(p.pid, `session:${sid}`);
     }
     for (const rec of activeRecs) {
         const root = runtimePid(join(runtimeRoot(), 'sessions', rec.session_id, 'agent.pid'));
-        if (root && procs.has(root))
+        if (root && procs.has(root) && !isTmuxServer(procs.get(root)))
             for (const pid of descendants(root, procs))
                 if (!ownership.has(pid))
                     ownership.set(pid, `session:${rec.session_id}`);
@@ -391,7 +408,7 @@ const buildInventory = (procs, publicRecords = publicRecordInventory()) => {
     }
     const root = repoRoot();
     for (const p of procs.values()) {
-        if (ownership.has(p.pid) || p.env.SPEXCODE_PROJECT_ROOT !== root)
+        if (ownership.has(p.pid) || p.env.SPEXCODE_PROJECT_ROOT !== root || hasTmuxAncestor(p.pid, procs) || isTmuxServer(p))
             continue;
         const claimed = p.env.SPEXCODE_SESSION_ID;
         if (claimed && !byId.has(claimed))

package/dist/materialize.js

@@ -1,4 +1,4 @@
-import { writeFileSync, mkdirSync, readFileSync, existsSync, readdirSync, renameSync, rmSync, rmdirSync } from 'node:fs';
+import { writeFileSync, mkdirSync, readFileSync, existsSync, readdirSync, renameSync, rmSync, rmdirSync, copyFileSync, chmodSync } from 'node:fs';
 import { join, dirname, relative } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { execFileSync } from 'node:child_process';
@@ -37,6 +37,58 @@ const DISPATCH = join(PKG, 'hooks', 'dispatch.sh');
 // CLI code and keeps the source-workspace mid-merge guard (one line + exit 75), so every hook callback
 // inherits both.
 const SPEX = join(PKG, 'bin', 'spex.mjs');
+const CORE_TEMPLATE = join(PKG, 'templates', 'spec', 'project', '.plugins', 'core');
+// Core hook handlers are shipped executable protocol, not adopter-owned plugin variants. Reconcile only the
+// known `core/` subtree before compiling the manifest so a project seeded by an older toolchain cannot keep
+// invoking a retired lifecycle writer. User plugins live outside this allowlist and are never enumerated.
+function refreshCorePluginHandlers(proj) {
+    if (!existsSync(CORE_TEMPLATE))
+        return [];
+    const specDir = join(proj, '.spec');
+    const roots = existsSync(specDir)
+        ? readdirSync(specDir, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory() && existsSync(join(specDir, entry.name, '.plugins', 'core')))
+            .map((entry) => join(specDir, entry.name, '.plugins', 'core'))
+        : [];
+    const handlers = [];
+    const walk = (dir, prefix = '') => {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            const rel = join(prefix, entry.name);
+            if (entry.isDirectory())
+                walk(join(dir, entry.name), rel);
+            else if (entry.isFile() && entry.name.endsWith('.sh'))
+                handlers.push(rel);
+        }
+    };
+    walk(CORE_TEMPLATE);
+    const refreshed = [];
+    for (const root of roots)
+        for (const rel of handlers) {
+            const source = join(CORE_TEMPLATE, rel);
+            const dest = join(root, rel);
+            let current = null;
+            try {
+                current = readFileSync(dest);
+            }
+            catch { }
+            if (current?.equals(readFileSync(source)))
+                continue;
+            mkdirSync(dirname(dest), { recursive: true });
+            const temp = `${dest}.spexcode-${process.pid}`;
+            try {
+                copyFileSync(source, temp);
+                chmodSync(temp, 0o755);
+                renameSync(temp, dest);
+                refreshed.push(relative(proj, dest));
+            }
+            finally {
+                rmSync(temp, { force: true });
+            }
+        }
+    if (refreshed.length)
+        console.log(`✓ refreshed core plugin handlers (${refreshed.join(', ')})`);
+    return refreshed;
+}
 // the manifest + content-hash marker + plugin-folder ledger land in the materialized TREE's own slot of the
 // GLOBAL per-project store (layout.treeSlotDir — trees/<enc-worktree>), NOT the worktree and NOT one shared
 // per-project file: each is a pure function of ONE tree's .plugins, and the old single slot let the last-
@@ -321,6 +373,7 @@ export function dematerialize(proj = process.cwd(), arts = { skills: [], agents:
 // the whole pay-per-change materialize. proj defaults to cwd. Its receipt is populated at each successful
 // write so callers report the actual selected footprint instead of maintaining a second artifact inventory.
 export function materialize(proj = process.cwd()) {
+    refreshCorePluginHandlers(proj);
     const rt = treeSlotDir(proj); // this tree's slot in the global store, not the worktree
     mkdirSync(rt, { recursive: true });
     const planted = [];

package/dist/session-transcript.d.ts

@@ -30,6 +30,7 @@ export declare function readSessionTranscript(c: Context): Promise<(Response & i
             readonly output?: string | undefined;
             readonly outputLines: number;
             readonly outputBytes: number;
+            readonly outcome?: "failed" | "rejected" | undefined;
         }[] | undefined;
     }[];
     readonly truncated: boolean;

package/dist/sessions.js

@@ -1102,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.
@@ -1176,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,
@@ -1305,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)
@@ -1824,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,
     };
@@ -4789,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;
@@ -5367,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;
@@ -5393,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/package.json

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