@co0ontty/wand 2.4.0 → 2.4.1

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "commit": "64b14513c83cef484b8635b6142a63e3cd19af6c",
-  "builtAt": "2026-07-04T09:00:31.976Z",
-  "version": "2.4.0",
+  "commit": "f3d51073dca38b18ea1104511c7fdebdd125b086",
+  "builtAt": "2026-07-04T10:40:24.303Z",
+  "version": "2.4.1",
   "channel": "stable"
 }

package/dist/process-manager.d.ts

@@ -30,8 +30,10 @@ export interface CodexHistorySession {
     claudeSessionId: string;
     cwd: string;
     firstUserMessage: string;
+    firstUserAt: string;
     timestamp: string;
     mtimeMs: number;
+    hasUser: boolean;
     hasConversation: boolean;
     managedByWand: boolean;
     provider: "codex";

package/dist/process-manager.js

@@ -331,6 +331,7 @@ function readCodexSessionSummary(filePath) {
         let cwd = "";
         let timestamp = "";
         let firstUserMessage = "";
+        let firstUserAt = "";
         let hasUser = false;
         let hasAssistant = false;
         for (const line of lines) {
@@ -363,6 +364,9 @@ function readCodexSessionSummary(filePath) {
                     : "";
                 if (text.trim()) {
                     hasUser = true;
+                    if (!firstUserAt && parsed.timestamp) {
+                        firstUserAt = parsed.timestamp;
+                    }
                     if (!firstUserMessage && !isCodexSystemInjectedText(text)) {
                         firstUserMessage = text.trim().slice(0, 120);
                     }
@@ -378,8 +382,10 @@ function readCodexSessionSummary(filePath) {
             claudeSessionId: id,
             cwd,
             firstUserMessage,
+            firstUserAt,
             timestamp: timestamp || new Date(stats.mtimeMs).toISOString(),
             mtimeMs: stats.mtimeMs,
+            hasUser,
             hasConversation: hasUser && hasAssistant,
             managedByWand: false,
             provider: "codex",
@@ -433,10 +439,19 @@ function isSameResolvedPath(left, right) {
         return false;
     return path.resolve(left) === path.resolve(right);
 }
+function isUsableCodexHistorySession(session) {
+    return session.hasUser || session.hasConversation;
+}
+function parseTimeMs(value) {
+    if (!value)
+        return null;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
 function selectCodexSessionForRecord(record) {
     const knownMtimes = record.knownCodexSessionMtimes ?? new Map();
     const candidates = listAllCodexHistorySessions()
-        .filter((session) => session.hasConversation)
+        .filter(isUsableCodexHistorySession)
         .filter((session) => isSameResolvedPath(session.cwd, record.cwd))
         .filter((session) => {
         const previousMtime = knownMtimes.get(session.claudeSessionId);
@@ -459,6 +474,36 @@ function selectCodexSessionForRecord(record) {
 function getLatestCodexSessionId(record) {
     return selectCodexSessionForRecord(record)?.claudeSessionId ?? null;
 }
+function selectCodexSessionForTimeWindow(record) {
+    const startedAtMs = parseTimeMs(record.startedAt);
+    if (startedAtMs === null)
+        return null;
+    const endedAtMs = parseTimeMs(record.endedAt) ?? Date.now();
+    const windowStart = startedAtMs - START_TIME_SKEW_MS;
+    const windowEnd = endedAtMs + START_TIME_SKEW_MS;
+    const candidates = listAllCodexHistorySessions()
+        .filter(isUsableCodexHistorySession)
+        .filter((session) => isSameResolvedPath(session.cwd, record.cwd))
+        .filter((session) => {
+        const firstUserAtMs = parseTimeMs(session.firstUserAt);
+        if (firstUserAtMs !== null) {
+            return firstUserAtMs >= windowStart && firstUserAtMs <= windowEnd;
+        }
+        return session.mtimeMs >= windowStart && session.mtimeMs <= endedAtMs + DISCOVERY_RECENT_WINDOW_MS;
+    })
+        .sort((a, b) => {
+        const aTime = parseTimeMs(a.firstUserAt) ?? a.mtimeMs;
+        const bTime = parseTimeMs(b.firstUserAt) ?? b.mtimeMs;
+        return Math.abs(aTime - startedAtMs) - Math.abs(bTime - startedAtMs);
+    });
+    return candidates.length === 1 ? candidates[0] : null;
+}
+function recoverCodexSessionIdFromHistory(snapshot) {
+    if (snapshot.provider !== "codex" || snapshot.claudeSessionId) {
+        return null;
+    }
+    return getCodexResumeCommandSessionId(snapshot.command) ?? selectCodexSessionForTimeWindow(snapshot)?.claudeSessionId ?? null;
+}
 /** Delete every rollout file belonging to the given codex thread ids. */
 function deleteCodexRolloutFiles(threadIds) {
     if (threadIds.size === 0)
@@ -597,6 +642,15 @@ export class ProcessManager extends EventEmitter {
                 : isCodexCmd
                     ? getCodexResumeCommandSessionId(snapshot.command)
                     : null;
+            const orphanEndedAt = snapshot.status === "running" ? new Date().toISOString() : null;
+            const sessionIdFromHistory = isCodexCmd
+                ? recoverCodexSessionIdFromHistory({
+                    ...snapshot,
+                    provider: "codex",
+                    endedAt: snapshot.endedAt ?? orphanEndedAt,
+                })
+                : null;
+            const restoredSessionId = resumeCommandSessionId ?? snapshot.claudeSessionId ?? sessionIdFromHistory;
             // Sessions restored from storage have ptyProcess: null — the old server's PTY
             // belongs to a dead process. Mark running sessions as exited so the UI
             // reflects reality and users can start fresh sessions.
@@ -605,10 +659,14 @@ export class ProcessManager extends EventEmitter {
                 const updated = {
                     ...snapshot,
                     status: "exited",
-                    endedAt: new Date().toISOString(),
+                    endedAt: orphanEndedAt,
+                    claudeSessionId: restoredSessionId ?? null,
                     messages: recoveredMessages.length > 0 ? recoveredMessages : snapshot.messages,
                 };
                 this.storage.saveSession(updated);
+                if (isCodexCmd && restoredSessionId && restoredSessionId !== snapshot.claudeSessionId) {
+                    process.stderr.write(`[wand] Recovered Codex thread ID for orphan PTY ${snapshot.id}: ${restoredSessionId}\n`);
+                }
                 this.sessions.set(snapshot.id, {
                     ...updated,
                     provider,
@@ -641,7 +699,7 @@ export class ProcessManager extends EventEmitter {
                     knownClaudeProjectMtimes: isClaudeCmd ? listClaudeProjectSessionMtimes(updated.cwd) : undefined,
                     knownCodexSessionMtimes: isCodexCmd ? listCodexSessionMtimes() : undefined,
                     codexSessionDiscoveryTimer: null,
-                    claudeSessionId: resumeCommandSessionId ?? updated.claudeSessionId,
+                    claudeSessionId: restoredSessionId ?? updated.claudeSessionId,
                     approvalStats: { tool: 0, command: 0, file: 0, total: 0 },
                     ptyCols: snapshot.ptyCols ?? 120,
                     ptyRows: snapshot.ptyRows ?? 36,
@@ -649,8 +707,17 @@ export class ProcessManager extends EventEmitter {
                 this.orphanRecoveredCount += 1;
             }
             else {
+                const updated = restoredSessionId && restoredSessionId !== snapshot.claudeSessionId
+                    ? { ...snapshot, claudeSessionId: restoredSessionId }
+                    : snapshot;
+                if (updated !== snapshot) {
+                    this.storage.saveSessionMetadata(updated);
+                    if (isCodexCmd) {
+                        process.stderr.write(`[wand] Recovered Codex thread ID for saved PTY ${snapshot.id}: ${restoredSessionId}\n`);
+                    }
+                }
                 this.sessions.set(snapshot.id, {
-                    ...snapshot,
+                    ...updated,
                     provider,
                     processId: null,
                     ptyProcess: null,
@@ -676,10 +743,10 @@ export class ProcessManager extends EventEmitter {
                     lastEmittedTask: null,
                     knownClaudeTaskIds: undefined,
                     claudeTaskDiscoveryTimer: null,
-                    knownClaudeProjectMtimes: isClaudeCmd ? listClaudeProjectSessionMtimes(snapshot.cwd) : undefined,
+                    knownClaudeProjectMtimes: isClaudeCmd ? listClaudeProjectSessionMtimes(updated.cwd) : undefined,
                     knownCodexSessionMtimes: isCodexCmd ? listCodexSessionMtimes() : undefined,
                     codexSessionDiscoveryTimer: null,
-                    claudeSessionId: resumeCommandSessionId ?? snapshot.claudeSessionId,
+                    claudeSessionId: restoredSessionId ?? updated.claudeSessionId,
                     approvalStats: { tool: 0, command: 0, file: 0, total: 0 },
                     ptyCols: snapshot.ptyCols ?? 120,
                     ptyRows: snapshot.ptyRows ?? 36,
@@ -928,7 +995,7 @@ export class ProcessManager extends EventEmitter {
             }
             current.pendingEscalation = null;
             current.ptyPermissionBlocked = false;
-            this.captureCodexSessionId(current);
+            this.captureCodexSessionId(current, { allowTimeWindowFallback: true });
             current.status = current.stopRequested ? "stopped" : exitCode === 0 ? "exited" : "failed";
             current.exitCode = current.stopRequested ? null : exitCode;
             current.endedAt = new Date().toISOString();
@@ -1175,22 +1242,30 @@ export class ProcessManager extends EventEmitter {
         }
         return deleted;
     }
-    captureCodexSessionId(record) {
-        if (record.provider !== "codex" || record.claudeSessionId || !record.knownCodexSessionMtimes) {
+    captureCodexSessionId(record, options) {
+        if (record.provider !== "codex" || record.claudeSessionId) {
             return false;
         }
-        const discoveredThreadId = getLatestCodexSessionId({
-            cwd: record.cwd,
-            startedAt: record.startedAt,
-            knownCodexSessionMtimes: record.knownCodexSessionMtimes,
-        });
-        if (!discoveredThreadId) {
+        const discoveredThreadId = record.knownCodexSessionMtimes
+            ? getLatestCodexSessionId({
+                cwd: record.cwd,
+                startedAt: record.startedAt,
+                knownCodexSessionMtimes: record.knownCodexSessionMtimes,
+            })
+            : null;
+        const fallbackThreadId = discoveredThreadId
+            ? null
+            : options?.allowTimeWindowFallback
+                ? selectCodexSessionForTimeWindow(record)?.claudeSessionId ?? null
+                : null;
+        const threadId = discoveredThreadId ?? fallbackThreadId;
+        if (!threadId) {
             return false;
         }
-        record.claudeSessionId = discoveredThreadId;
-        record.knownCodexSessionMtimes.set(discoveredThreadId, Date.now());
+        record.claudeSessionId = threadId;
+        record.knownCodexSessionMtimes?.set(threadId, Date.now());
         this.codexHistoryCache = null;
-        process.stderr.write(`[wand] Captured Codex thread ID: ${discoveredThreadId}\n`);
+        process.stderr.write(`[wand] Captured Codex thread ID: ${threadId}\n`);
         return true;
     }
     get(id) {
@@ -1388,7 +1463,7 @@ export class ProcessManager extends EventEmitter {
             record.ptyBridge = null;
         }
         // Update lifecycle
-        this.captureCodexSessionId(record);
+        this.captureCodexSessionId(record, { allowTimeWindowFallback: true });
         this.persist(record);
         return this.snapshot(record);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@co0ontty/wand",
-  "version": "2.4.0",
+  "version": "2.4.1",
   "description": "A web terminal for local CLI tools like Claude.",
   "type": "module",
   "bin": {