@co0ontty/wand 1.39.1 → 1.40.1

package/dist/git-quick-commit.js

@@ -64,6 +64,20 @@ function resolvePushRemote(cwd) {
     }
     return "origin";
 }
+/**
+ * Derive a default next-version tag from the latest existing tag by bumping the
+ * patch component (preserving an optional `v` prefix). Returns a sane starting
+ * version when there's no tag yet, or `undefined` if the latest tag isn't semver-ish.
+ */
+function computeSuggestedTag(latestTag) {
+    if (!latestTag)
+        return "v0.1.0";
+    const m = latestTag.match(/^(v?)(\d+)\.(\d+)\.(\d+)$/);
+    if (!m)
+        return undefined;
+    const [, prefix, major, minor, patch] = m;
+    return `${prefix}${major}.${minor}.${Number.parseInt(patch, 10) + 1}`;
+}
 function unquotePath(raw) {
     if (raw.startsWith("\"") && raw.endsWith("\"")) {
         return raw.slice(1, -1).replace(/\\"/g, "\"").replace(/\\\\/g, "\\");
@@ -217,6 +231,17 @@ export function getGitStatus(cwd) {
     // `ls-remote` is a synchronous network call that can block the event loop
     // for seconds. The "unpushed tag" UI chip is best-effort and a separate
     // async endpoint should compute it on demand if reintroduced.
+    // Latest tag + a locally-derived next-version suggestion (both git-local, fast).
+    let latestTag;
+    if (!initialCommit) {
+        try {
+            latestTag = runGit(["describe", "--tags", "--abbrev=0"], cwd) || undefined;
+        }
+        catch {
+            latestTag = undefined;
+        }
+    }
+    const suggestedTag = computeSuggestedTag(latestTag);
     return {
         isGit: true,
         branch,
@@ -229,6 +254,8 @@ export function getGitStatus(cwd) {
         ahead,
         behind,
         lastCommit,
+        latestTag,
+        suggestedTag,
     };
 }
 export class QuickCommitError extends Error {

package/dist/process-manager.d.ts

@@ -81,6 +81,7 @@ export declare class ProcessManager extends EventEmitter {
     listCodexHistorySessions(): CodexHistorySession[];
     hasCodexSessionFile(threadId: string): boolean;
     deleteCodexHistoryFiles(threadIds: string[]): number;
+    private captureCodexSessionId;
     get(id: string): SessionSnapshot | null;
     getPtyTranscript(id: string): string | null;
     /**

package/dist/process-manager.js

@@ -12,7 +12,7 @@ import { appendWindow, hasExplicitConfirmSyntax, hasPermissionActionContext, nor
 import { buildChildEnv } from "./env-utils.js";
 import { buildLanguageDirective } from "./language-prompt.js";
 import { prepareSessionWorktree } from "./git-worktree.js";
-import { getResumeCommandSessionId } from "./resume-policy.js";
+import { getCodexResumeCommandSessionId, getResumeCommandSessionId } from "./resume-policy.js";
 import { applyThinkingEffortToPrompt, normalizeThinkingEffort } from "./structured-session-manager.js";
 function resolveProviderFromCommand(command) {
     return /^codex\b/.test(command.trim()) ? "codex" : "claude";
@@ -421,6 +421,40 @@ function listAllCodexHistorySessions() {
     }
     return Array.from(byThread.values()).sort((a, b) => b.mtimeMs - a.mtimeMs);
 }
+function listCodexSessionMtimes() {
+    return new Map(listAllCodexHistorySessions().map((session) => [session.claudeSessionId, session.mtimeMs]));
+}
+function isSameResolvedPath(left, right) {
+    if (!left || !right)
+        return false;
+    return path.resolve(left) === path.resolve(right);
+}
+function selectCodexSessionForRecord(record) {
+    const knownMtimes = record.knownCodexSessionMtimes ?? new Map();
+    const candidates = listAllCodexHistorySessions()
+        .filter((session) => session.hasConversation)
+        .filter((session) => isSameResolvedPath(session.cwd, record.cwd))
+        .filter((session) => {
+        const previousMtime = knownMtimes.get(session.claudeSessionId);
+        return previousMtime === undefined || session.mtimeMs > previousMtime;
+    })
+        .filter((session) => hasRecentProjectActivity(session, record.startedAt))
+        .sort((a, b) => b.mtimeMs - a.mtimeMs);
+    if (candidates.length === 0) {
+        return null;
+    }
+    const fresh = candidates.filter((session) => !knownMtimes.has(session.claudeSessionId));
+    if (fresh.length === 1) {
+        return fresh[0];
+    }
+    if (fresh.length > 1) {
+        return null;
+    }
+    return candidates.length === 1 ? candidates[0] : null;
+}
+function getLatestCodexSessionId(record) {
+    return selectCodexSessionForRecord(record)?.claudeSessionId ?? null;
+}
 /** Delete every rollout file belonging to the given codex thread ids. */
 function deleteCodexRolloutFiles(threadIds) {
     if (threadIds.size === 0)
@@ -548,7 +582,12 @@ export class ProcessManager extends EventEmitter {
             }
             const provider = snapshot.provider ?? resolveProviderFromCommand(snapshot.command);
             const isClaudeCmd = provider === "claude";
-            const resumeCommandSessionId = isClaudeCmd ? getResumeCommandSessionId(snapshot.command) : null;
+            const isCodexCmd = provider === "codex";
+            const resumeCommandSessionId = isClaudeCmd
+                ? getResumeCommandSessionId(snapshot.command)
+                : isCodexCmd
+                    ? getCodexResumeCommandSessionId(snapshot.command)
+                    : null;
             // 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.
@@ -591,6 +630,8 @@ export class ProcessManager extends EventEmitter {
                     knownClaudeTaskIds: undefined,
                     claudeTaskDiscoveryTimer: null,
                     knownClaudeProjectMtimes: isClaudeCmd ? listClaudeProjectSessionMtimes(updated.cwd) : undefined,
+                    knownCodexSessionMtimes: isCodexCmd ? listCodexSessionMtimes() : undefined,
+                    codexSessionDiscoveryTimer: null,
                     claudeSessionId: resumeCommandSessionId ?? updated.claudeSessionId,
                     approvalStats: { tool: 0, command: 0, file: 0, total: 0 },
                     ptyCols: snapshot.ptyCols ?? 120,
@@ -627,6 +668,8 @@ export class ProcessManager extends EventEmitter {
                     knownClaudeTaskIds: undefined,
                     claudeTaskDiscoveryTimer: null,
                     knownClaudeProjectMtimes: isClaudeCmd ? listClaudeProjectSessionMtimes(snapshot.cwd) : undefined,
+                    knownCodexSessionMtimes: isCodexCmd ? listCodexSessionMtimes() : undefined,
+                    codexSessionDiscoveryTimer: null,
                     claudeSessionId: resumeCommandSessionId ?? snapshot.claudeSessionId,
                     approvalStats: { tool: 0, command: 0, file: 0, total: 0 },
                     ptyCols: snapshot.ptyCols ?? 120,
@@ -686,7 +729,9 @@ export class ProcessManager extends EventEmitter {
             const record = this.sessions.get(id);
             if (record) {
                 this.logger.deleteSession(id);
-                this.deleteClaudeCache(record);
+                if (record.provider === "claude") {
+                    this.deleteClaudeCache(record);
+                }
             }
             this.sessions.delete(id);
             this.lastPersistedMessageState.delete(id);
@@ -694,6 +739,7 @@ export class ProcessManager extends EventEmitter {
         }
         if (toRemove.length > 0) {
             this.claudeHistoryCache = null;
+            this.codexHistoryCache = null;
         }
     }
     start(command, cwd, mode, initialInput, opts) {
@@ -731,9 +777,16 @@ export class ProcessManager extends EventEmitter {
         const resumeCommandSessionId = isClaudeProvider
             ? getResumeCommandSessionId(processedCommand) ?? getResumeCommandSessionId(command)
             : null;
+        const isCodexProvider = provider === "codex";
+        const codexResumeCommandSessionId = isCodexProvider
+            ? getCodexResumeCommandSessionId(processedCommand) ?? getCodexResumeCommandSessionId(command)
+            : null;
         const knownClaudeTaskIds = isClaudeProvider ? new Set(listRecentClaudeProjectSessionIds(resolvedCwd, new Date().toISOString())) : null;
         const knownClaudeProjectMtimes = isClaudeProvider ? listClaudeProjectSessionMtimes(resolvedCwd) : null;
-        const initialClaudeSessionId = isClaudeProvider ? resumeCommandSessionId ?? null : null;
+        const knownCodexSessionMtimes = isCodexProvider && !codexResumeCommandSessionId ? listCodexSessionMtimes() : null;
+        const initialClaudeSessionId = isClaudeProvider
+            ? resumeCommandSessionId ?? null
+            : codexResumeCommandSessionId ?? null;
         const startedAt = new Date().toISOString();
         const record = {
             id,
@@ -778,6 +831,8 @@ export class ProcessManager extends EventEmitter {
             knownClaudeTaskIds: knownClaudeTaskIds ?? undefined,
             claudeTaskDiscoveryTimer: null,
             knownClaudeProjectMtimes: knownClaudeProjectMtimes ?? undefined,
+            knownCodexSessionMtimes: knownCodexSessionMtimes ?? undefined,
+            codexSessionDiscoveryTimer: null,
             approvalStats: { tool: 0, command: 0, file: 0, total: 0 },
             selectedModel: selectedModel ?? null,
             thinkingEffort: normalizeThinkingEffort(opts?.thinkingEffort),
@@ -800,9 +855,14 @@ export class ProcessManager extends EventEmitter {
             });
         }
         this.sessions.set(id, record);
-        this.persist(record);
+        this.persist(record, { forceFullSave: true });
         if (initialClaudeSessionId) {
-            this.claudeHistoryCache = null;
+            if (provider === "codex") {
+                this.codexHistoryCache = null;
+            }
+            else {
+                this.claudeHistoryCache = null;
+            }
         }
         this.cleanupOldSessions();
         const shellArgs = this.buildShellArgs(processedCommand);
@@ -842,6 +902,10 @@ export class ProcessManager extends EventEmitter {
                 clearTimeout(current.claudeTaskDiscoveryTimer);
                 current.claudeTaskDiscoveryTimer = null;
             }
+            if (current.codexSessionDiscoveryTimer) {
+                clearTimeout(current.codexSessionDiscoveryTimer);
+                current.codexSessionDiscoveryTimer = null;
+            }
             if (current.initialInputTimer) {
                 clearTimeout(current.initialInputTimer);
                 current.initialInputTimer = null;
@@ -852,6 +916,7 @@ export class ProcessManager extends EventEmitter {
             }
             current.pendingEscalation = null;
             current.ptyPermissionBlocked = false;
+            this.captureCodexSessionId(current);
             current.status = current.stopRequested ? "stopped" : exitCode === 0 ? "exited" : "failed";
             current.exitCode = current.stopRequested ? null : exitCode;
             current.endedAt = new Date().toISOString();
@@ -972,6 +1037,25 @@ export class ProcessManager extends EventEmitter {
             };
             record.claudeTaskDiscoveryTimer = setTimeout(tryDiscoverClaudeTaskId, 500);
         }
+        if (record.knownCodexSessionMtimes) {
+            const tryDiscoverCodexSessionId = () => {
+                const current = this.sessions.get(id);
+                if (!current || current.status !== "running" || current.claudeSessionId || !current.knownCodexSessionMtimes) {
+                    return;
+                }
+                if (getCodexResumeCommandSessionId(current.command)) {
+                    current.codexSessionDiscoveryTimer = null;
+                    return;
+                }
+                if (this.captureCodexSessionId(current)) {
+                    current.codexSessionDiscoveryTimer = null;
+                    this.persist(current);
+                    return;
+                }
+                current.codexSessionDiscoveryTimer = setTimeout(tryDiscoverCodexSessionId, 1000);
+            };
+            record.codexSessionDiscoveryTimer = setTimeout(tryDiscoverCodexSessionId, 500);
+        }
         return this.snapshot(record);
     }
     list() {
@@ -999,7 +1083,7 @@ export class ProcessManager extends EventEmitter {
         // Cross-reference with wand-managed sessions
         const managedClaudeIds = new Set();
         for (const record of this.sessions.values()) {
-            if (record.claudeSessionId) {
+            if (record.provider === "claude" && record.claudeSessionId) {
                 managedClaudeIds.add(record.claudeSessionId);
             }
         }
@@ -1077,6 +1161,24 @@ export class ProcessManager extends EventEmitter {
         }
         return deleted;
     }
+    captureCodexSessionId(record) {
+        if (record.provider !== "codex" || record.claudeSessionId || !record.knownCodexSessionMtimes) {
+            return false;
+        }
+        const discoveredThreadId = getLatestCodexSessionId({
+            cwd: record.cwd,
+            startedAt: record.startedAt,
+            knownCodexSessionMtimes: record.knownCodexSessionMtimes,
+        });
+        if (!discoveredThreadId) {
+            return false;
+        }
+        record.claudeSessionId = discoveredThreadId;
+        record.knownCodexSessionMtimes.set(discoveredThreadId, Date.now());
+        this.codexHistoryCache = null;
+        process.stderr.write(`[wand] Captured Codex thread ID: ${discoveredThreadId}\n`);
+        return true;
+    }
     get(id) {
         const record = this.sessions.get(id);
         if (!record) {
@@ -1224,6 +1326,10 @@ export class ProcessManager extends EventEmitter {
             clearTimeout(record.claudeTaskDiscoveryTimer);
             record.claudeTaskDiscoveryTimer = null;
         }
+        if (record.codexSessionDiscoveryTimer) {
+            clearTimeout(record.codexSessionDiscoveryTimer);
+            record.codexSessionDiscoveryTimer = null;
+        }
         if (record.initialInputTimer) {
             clearTimeout(record.initialInputTimer);
             record.initialInputTimer = null;
@@ -1250,6 +1356,7 @@ export class ProcessManager extends EventEmitter {
             record.ptyBridge = null;
         }
         // Update lifecycle
+        this.captureCodexSessionId(record);
         this.persist(record);
         return this.snapshot(record);
     }
@@ -1262,6 +1369,10 @@ export class ProcessManager extends EventEmitter {
             clearTimeout(record.claudeTaskDiscoveryTimer);
             record.claudeTaskDiscoveryTimer = null;
         }
+        if (record.codexSessionDiscoveryTimer) {
+            clearTimeout(record.codexSessionDiscoveryTimer);
+            record.codexSessionDiscoveryTimer = null;
+        }
         if (record.initialInputTimer) {
             clearTimeout(record.initialInputTimer);
             record.initialInputTimer = null;
@@ -1298,6 +1409,10 @@ export class ProcessManager extends EventEmitter {
             clearTimeout(record.claudeTaskDiscoveryTimer);
             record.claudeTaskDiscoveryTimer = null;
         }
+        if (record.codexSessionDiscoveryTimer) {
+            clearTimeout(record.codexSessionDiscoveryTimer);
+            record.codexSessionDiscoveryTimer = null;
+        }
         if (record.initialInputTimer) {
             clearTimeout(record.initialInputTimer);
             record.initialInputTimer = null;
@@ -1335,11 +1450,18 @@ export class ProcessManager extends EventEmitter {
         // so a storage failure doesn't leave orphan records in the database.
         this.storage.deleteSession(id);
         this.logger.deleteSession(id);
-        this.deleteClaudeCache(record);
+        if (record.provider === "claude") {
+            this.deleteClaudeCache(record);
+        }
         this.sessions.delete(id);
         this.lastPersistedMessageState.delete(id);
         if (record.claudeSessionId) {
-            this.claudeHistoryCache = null;
+            if (record.provider === "codex") {
+                this.codexHistoryCache = null;
+            }
+            else {
+                this.claudeHistoryCache = null;
+            }
         }
     }
     deleteClaudeCache(record) {
@@ -1488,14 +1610,15 @@ export class ProcessManager extends EventEmitter {
         this.persist(record);
         return this.snapshot(record);
     }
-    persist(record) {
+    persist(record, options) {
         // Update messages from bridge before persisting
         const messages = record.ptyBridge?.getMessages() ?? record.messages;
         if (messages !== record.messages) {
             record.messages = messages;
         }
         const snapshot = this.snapshot(record);
-        const shouldSaveMessages = shouldPersistMessages(this.lastPersistedMessageState.get(record.id), messages);
+        const shouldSaveMessages = options?.forceFullSave === true
+            || shouldPersistMessages(this.lastPersistedMessageState.get(record.id), messages);
         // Persist full messages as soon as the structured conversation changes so
         // service restarts cannot roll the session back to an older tail message.
         if (shouldSaveMessages) {

package/dist/resume-policy.d.ts

@@ -1,3 +1,4 @@
 import { ConversationTurn } from "./types.js";
 export declare function hasRealConversationMessages(messages: ConversationTurn[] | undefined): boolean;
 export declare function getResumeCommandSessionId(command: string): string | null;
+export declare function getCodexResumeCommandSessionId(command: string): string | null;

package/dist/resume-policy.js

@@ -1,5 +1,7 @@
 const REAL_CONVERSATION_MIN_MESSAGES = 2;
-const RESUME_COMMAND_ID_PATTERN = /(?:^|\s)--resume\s+([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})(?:\s|$)/i;
+const UUID_PATTERN = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
+const RESUME_COMMAND_ID_PATTERN = new RegExp(`(?:^|\\s)--resume\\s+(${UUID_PATTERN})(?:\\s|$)`, "i");
+const CODEX_RESUME_COMMAND_ID_PATTERN = new RegExp(`(?:^|\\s)resume\\s+(${UUID_PATTERN})(?:\\s|$)`, "i");
 export function hasRealConversationMessages(messages) {
     if (!messages || messages.length < REAL_CONVERSATION_MIN_MESSAGES) {
         return false;
@@ -14,3 +16,7 @@ export function getResumeCommandSessionId(command) {
     const match = RESUME_COMMAND_ID_PATTERN.exec(command);
     return match?.[1] ?? null;
 }
+export function getCodexResumeCommandSessionId(command) {
+    const match = CODEX_RESUME_COMMAND_ID_PATTERN.exec(command);
+    return match?.[1] ?? null;
+}

package/dist/server-session-routes.js

@@ -130,6 +130,13 @@ function getWorktreeMergePayload(error, fallback) {
 function getLatestSessionSnapshot(processes, structured, storage, id) {
     return getSessionById(processes, structured, id) ?? storage.getSession(id);
 }
+function buildCodexResumeCommand(command, threadId) {
+    const trimmed = command.trim();
+    const withoutExistingResume = trimmed
+        .replace(/\s+resume\s+[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}(?:\s|$)/i, " ")
+        .trim();
+    return `${withoutExistingResume || "codex"} resume ${threadId}`;
+}
 function canMergeSession(snapshot) {
     return Boolean(snapshot.worktreeEnabled && snapshot.worktree?.branch && snapshot.worktree?.path);
 }
@@ -593,28 +600,41 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
                 return;
             }
             if ((existingSession.sessionKind ?? "pty") !== "pty") {
-                res.status(400).json({ error: "结构化会话不支持 Claude CLI resume。" });
+                res.status(400).json({ error: "结构化会话不支持 PTY resume。" });
                 return;
             }
-            if (existingSession.provider && existingSession.provider !== "claude") {
-                res.status(400).json({ error: "只有 Claude provider 支持恢复功能。" });
+            const command = existingSession.command.trim();
+            const provider = existingSession.provider ?? (/^codex\b/.test(command) ? "codex" : "claude");
+            if (provider !== "claude" && provider !== "codex") {
+                res.status(400).json({ error: "只有 Claude 或 Codex provider 支持恢复功能。" });
                 return;
             }
-            const claudeSessionId = existingSession.claudeSessionId;
-            if (!claudeSessionId) {
-                res.status(400).json({ error: "此会话没有 Claude 会话 ID，无法恢复。" });
+            const resumeSessionId = existingSession.claudeSessionId;
+            if (!resumeSessionId) {
+                res.status(400).json({ error: provider === "codex" ? "此会话没有 Codex thread ID，无法恢复。" : "此会话没有 Claude 会话 ID，无法恢复。" });
                 return;
             }
-            const command = existingSession.command.trim();
-            if (!/^claude\b/.test(command)) {
+            if (provider === "claude" && !/^claude\b/.test(command)) {
                 res.status(400).json({ error: "只有 Claude 命令支持恢复功能。" });
                 return;
             }
+            if (provider === "codex") {
+                if (!/^codex\b/.test(command)) {
+                    res.status(400).json({ error: "只有 Codex 命令支持恢复功能。" });
+                    return;
+                }
+                if (!processes.hasCodexSessionFile(resumeSessionId)) {
+                    res.status(400).json({ error: "对应的 Codex 历史会话不存在，无法恢复。" });
+                    return;
+                }
+            }
             const newMode = body.mode ? normalizeMode(body.mode, defaultMode) : normalizeMode(existingSession.mode, defaultMode);
-            const resumeCommand = `${command} --resume ${claudeSessionId}`;
+            const resumeCommand = provider === "codex"
+                ? buildCodexResumeCommand(command, resumeSessionId)
+                : `${command} --resume ${resumeSessionId}`;
             const reqCols = typeof body.cols === "number" && Number.isFinite(body.cols) ? body.cols : undefined;
             const reqRows = typeof body.rows === "number" && Number.isFinite(body.rows) ? body.rows : undefined;
-            const newSnapshot = processes.start(resumeCommand, existingSession.cwd, newMode, undefined, { reuseId: sessionId, cols: reqCols, rows: reqRows });
+            const newSnapshot = processes.start(resumeCommand, existingSession.cwd, newMode, undefined, { reuseId: sessionId, cols: reqCols, rows: reqRows, provider });
             res.status(201).json(newSnapshot);
         }
         catch (error) {

package/dist/types.d.ts

@@ -196,6 +196,10 @@ export interface GitStatusResult {
         shortHash: string;
         subject: string;
     };
+    /** Most recent tag reachable from HEAD (`git describe --tags --abbrev=0`), if any. */
+    latestTag?: string;
+    /** Locally-derived next-version suggestion (patch bump of `latestTag`, or a sane default). */
+    suggestedTag?: string;
     error?: string;
 }
 export interface QuickCommitResult {