@co0ontty/wand 1.6.2 → 1.9.0

package/dist/config.js

@@ -16,6 +16,20 @@ export const defaultConfig = () => ({
     allowedCommandPrefixes: [],
     shortcutLogMaxBytes: 10 * 1024 * 1024,
     language: "",
+    uiPreferences: {
+        defaultPanelState: {
+            sessionsDrawerOpen: false,
+            filePanelOpen: false,
+            shortcutsExpanded: false,
+            claudeHistoryExpanded: true,
+            chatMessageExpanded: true,
+            structuredThinkingExpanded: true,
+            structuredToolGroupExpanded: false,
+            structuredInlineToolExpanded: false,
+            structuredTerminalExpanded: false,
+            structuredToolCardExpanded: false,
+        }
+    },
     commandPresets: [
         {
             label: "Claude",
@@ -101,8 +115,26 @@ function normalizeStructuredChatPersona(input) {
         return undefined;
     return { user, assistant };
 }
+function normalizeDefaultPanelState(input) {
+    if (!input || typeof input !== "object")
+        return undefined;
+    const state = input;
+    return {
+        sessionsDrawerOpen: typeof state.sessionsDrawerOpen === "boolean" ? state.sessionsDrawerOpen : undefined,
+        filePanelOpen: typeof state.filePanelOpen === "boolean" ? state.filePanelOpen : undefined,
+        shortcutsExpanded: typeof state.shortcutsExpanded === "boolean" ? state.shortcutsExpanded : undefined,
+        claudeHistoryExpanded: typeof state.claudeHistoryExpanded === "boolean" ? state.claudeHistoryExpanded : undefined,
+        chatMessageExpanded: typeof state.chatMessageExpanded === "boolean" ? state.chatMessageExpanded : undefined,
+        structuredThinkingExpanded: typeof state.structuredThinkingExpanded === "boolean" ? state.structuredThinkingExpanded : undefined,
+        structuredToolGroupExpanded: typeof state.structuredToolGroupExpanded === "boolean" ? state.structuredToolGroupExpanded : undefined,
+        structuredInlineToolExpanded: typeof state.structuredInlineToolExpanded === "boolean" ? state.structuredInlineToolExpanded : undefined,
+        structuredTerminalExpanded: typeof state.structuredTerminalExpanded === "boolean" ? state.structuredTerminalExpanded : undefined,
+        structuredToolCardExpanded: typeof state.structuredToolCardExpanded === "boolean" ? state.structuredToolCardExpanded : undefined,
+    };
+}
 function mergeWithDefaults(input) {
     const defaults = defaultConfig();
+    const normalizedPanelState = normalizeDefaultPanelState(input.uiPreferences?.defaultPanelState);
     return {
         ...defaults,
         ...input,
@@ -132,6 +164,14 @@ function mergeWithDefaults(input) {
             : defaults.commandPresets,
         structuredChatPersona: normalizeStructuredChatPersona(input.structuredChatPersona),
         language: typeof input.language === "string" ? input.language.trim() : defaults.language,
+        uiPreferences: {
+            ...defaults.uiPreferences,
+            ...(input.uiPreferences || {}),
+            defaultPanelState: {
+                ...defaults.uiPreferences?.defaultPanelState,
+                ...(normalizedPanelState || {}),
+            }
+        },
     };
 }
 export function isExecutionMode(value) {

package/dist/git-worktree.d.ts

@@ -0,0 +1,28 @@
+import { SessionSnapshot, WorktreeMergeCheckResult, WorktreeMergeResult } from "./types.js";
+interface WorktreeSetupOptions {
+    cwd: string;
+    sessionId: string;
+}
+interface WorktreeSetupResult {
+    cwd: string;
+    worktreeEnabled: boolean;
+    worktree: NonNullable<SessionSnapshot["worktree"]>;
+}
+interface WorktreeOperationOptions {
+    worktree: NonNullable<SessionSnapshot["worktree"]>;
+}
+interface WorktreeMergeOptions extends WorktreeOperationOptions {
+    targetBranch?: string;
+}
+export declare class WorktreeMergeError extends Error {
+    readonly code: string;
+    readonly result?: Partial<WorktreeMergeResult> | undefined;
+    constructor(code: string, message: string, result?: Partial<WorktreeMergeResult> | undefined);
+}
+export declare function getDefaultBaseBranch(repoRoot: string): string;
+export declare function getWorktreeMergeErrorCode(error: unknown): string | undefined;
+export declare function checkSessionWorktreeMergeability(options: WorktreeMergeOptions): WorktreeMergeCheckResult;
+export declare function cleanupSessionWorktree(options: WorktreeOperationOptions): boolean;
+export declare function mergeSessionWorktree(options: WorktreeMergeOptions): WorktreeMergeResult;
+export declare function prepareSessionWorktree(options: WorktreeSetupOptions): WorktreeSetupResult;
+export {};

package/dist/git-worktree.js

@@ -0,0 +1,287 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import path from "node:path";
+const WORKTREE_MERGE_ERROR_CODES = {
+    MISSING: "WORKTREE_MISSING",
+    DIRTY: "WORKTREE_DIRTY",
+    TARGET_MISSING: "TARGET_BRANCH_MISSING",
+    NOTHING_TO_MERGE: "NOTHING_TO_MERGE",
+    CONFLICT: "WORKTREE_MERGE_CONFLICT",
+    CLEANUP_FAILED: "WORKTREE_CLEANUP_FAILED",
+};
+export class WorktreeMergeError extends Error {
+    code;
+    result;
+    constructor(code, message, result) {
+        super(message);
+        this.code = code;
+        this.result = result;
+        this.name = "WorktreeMergeError";
+    }
+}
+function runGit(args, cwd) {
+    return execFileSync("git", args, {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    }).trim();
+}
+function sanitizeBranchSegment(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 48) || "session";
+}
+function getCurrentBranch(repoRoot) {
+    const branch = runGit(["branch", "--show-current"], repoRoot);
+    return branch || "master";
+}
+function isGitCommandError(error) {
+    return error instanceof Error;
+}
+function getGitCommandMessage(error) {
+    if (isGitCommandError(error)) {
+        return error.stderr?.trim() || error.stdout?.trim() || error.message;
+    }
+    return String(error);
+}
+function refExists(repoRoot, ref) {
+    try {
+        runGit(["rev-parse", "--verify", ref], repoRoot);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getRepoRootFromWorktree(worktreePath) {
+    const repoRoot = runGit(["rev-parse", "--show-toplevel"], worktreePath);
+    if (!repoRoot || !existsSync(repoRoot)) {
+        throw new WorktreeMergeError(WORKTREE_MERGE_ERROR_CODES.MISSING, "Worktree 仓库根目录不存在。", {
+            cleanupDone: false,
+            conflict: false,
+        });
+    }
+    return repoRoot;
+}
+function ensureWorktreePath(worktree) {
+    const worktreePath = path.resolve(worktree.path);
+    if (!existsSync(worktreePath)) {
+        throw new WorktreeMergeError(WORKTREE_MERGE_ERROR_CODES.MISSING, "Worktree 目录不存在，可能已被手动删除。", {
+            cleanupDone: false,
+            conflict: false,
+        });
+    }
+    return worktreePath;
+}
+function getMainRepoRoot(repoRoot) {
+    const commonDir = runGit(["rev-parse", "--git-common-dir"], repoRoot);
+    if (commonDir) {
+        const maybeRoot = path.resolve(repoRoot, commonDir, "..");
+        if (existsSync(maybeRoot)) {
+            return maybeRoot;
+        }
+    }
+    return repoRoot;
+}
+export function getDefaultBaseBranch(repoRoot) {
+    try {
+        const symbolicRef = runGit(["symbolic-ref", "refs/remotes/origin/HEAD"], repoRoot);
+        const match = symbolicRef.match(/^refs\/remotes\/origin\/(.+)$/);
+        if (match && match[1]) {
+            return match[1];
+        }
+    }
+    catch {
+        // ignore and fallback below
+    }
+    const candidates = ["master", "main", getCurrentBranch(repoRoot)];
+    for (const candidate of candidates) {
+        if (candidate && refExists(repoRoot, candidate)) {
+            return candidate;
+        }
+    }
+    return "master";
+}
+function getMainRepoContext(options) {
+    const worktreePath = ensureWorktreePath(options.worktree);
+    const worktreeRepoRoot = getRepoRootFromWorktree(worktreePath);
+    const repoRoot = getMainRepoRoot(worktreeRepoRoot);
+    const sourceBranch = options.worktree.branch;
+    if (!refExists(repoRoot, sourceBranch)) {
+        throw new WorktreeMergeError(WORKTREE_MERGE_ERROR_CODES.MISSING, "Worktree 分支不存在，可能已被手动删除。", {
+            cleanupDone: false,
+            conflict: false,
+        });
+    }
+    const targetBranch = options.targetBranch?.trim() || getDefaultBaseBranch(repoRoot);
+    if (!refExists(repoRoot, targetBranch)) {
+        throw new WorktreeMergeError(WORKTREE_MERGE_ERROR_CODES.TARGET_MISSING, `目标分支不存在：${targetBranch}`, {
+            cleanupDone: false,
+            conflict: false,
+            targetBranch,
+        });
+    }
+    return { repoRoot, worktreePath, sourceBranch, targetBranch };
+}
+function hasUncommittedChanges(worktreePath) {
+    const worktreeRepoRoot = getRepoRootFromWorktree(worktreePath);
+    return runGit(["status", "--porcelain"], worktreeRepoRoot).length > 0;
+}
+function getAheadCount(repoRoot, targetBranch, sourceBranch) {
+    const count = runGit(["rev-list", "--count", `${targetBranch}..${sourceBranch}`], repoRoot);
+    return Number.parseInt(count || "0", 10) || 0;
+}
+function checkConflicts(repoRoot, targetBranch, sourceBranch) {
+    try {
+        runGit(["merge-tree", targetBranch, sourceBranch], repoRoot);
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
+function ensureMergeableContext(options) {
+    const context = getMainRepoContext(options);
+    if (hasUncommittedChanges(context.worktreePath)) {
+        throw new WorktreeMergeError(WORKTREE_MERGE_ERROR_CODES.DIRTY, "Worktree 中仍有未提交改动，请先提交后再合并。", {
+            sourceBranch: context.sourceBranch,
+            targetBranch: context.targetBranch,
+            repoRoot: context.repoRoot,
+            cleanupDone: false,
+            conflict: false,
+        });
+    }
+    const aheadCount = getAheadCount(context.repoRoot, context.targetBranch, context.sourceBranch);
+    if (aheadCount <= 0) {
+        throw new WorktreeMergeError(WORKTREE_MERGE_ERROR_CODES.NOTHING_TO_MERGE, "当前 worktree 没有可合并到主分支的新提交。", {
+            sourceBranch: context.sourceBranch,
+            targetBranch: context.targetBranch,
+            repoRoot: context.repoRoot,
+            cleanupDone: false,
+            conflict: false,
+        });
+    }
+    return { ...context, aheadCount };
+}
+function buildCheckResult(context, aheadCount, hasDirtyChanges, hasConflicts) {
+    const ok = !hasDirtyChanges && aheadCount > 0 && !hasConflicts;
+    return {
+        ok,
+        sourceBranch: context.sourceBranch,
+        targetBranch: context.targetBranch,
+        worktreePath: context.worktreePath,
+        repoRoot: context.repoRoot,
+        hasUncommittedChanges: hasDirtyChanges,
+        aheadCount,
+        hasConflicts,
+        recommendedAction: hasConflicts ? "resolve-conflict" : aheadCount > 0 ? "merge" : "noop",
+        reason: hasDirtyChanges
+            ? "Worktree 中仍有未提交改动。"
+            : aheadCount <= 0
+                ? "当前 worktree 没有可合并的新提交。"
+                : hasConflicts
+                    ? "检测到潜在冲突，请先处理。"
+                    : undefined,
+    };
+}
+function getHeadCommit(repoRoot) {
+    return runGit(["rev-parse", "HEAD"], repoRoot);
+}
+function cleanupMergedWorktree(context) {
+    runGit(["worktree", "remove", context.worktreePath], context.repoRoot);
+    runGit(["branch", "-d", context.sourceBranch], context.repoRoot);
+    return true;
+}
+export function getWorktreeMergeErrorCode(error) {
+    return error instanceof WorktreeMergeError ? error.code : undefined;
+}
+export function checkSessionWorktreeMergeability(options) {
+    const context = getMainRepoContext(options);
+    const hasDirtyChanges = hasUncommittedChanges(context.worktreePath);
+    const aheadCount = getAheadCount(context.repoRoot, context.targetBranch, context.sourceBranch);
+    const hasConflicts = !hasDirtyChanges && aheadCount > 0
+        ? checkConflicts(context.repoRoot, context.targetBranch, context.sourceBranch)
+        : false;
+    return buildCheckResult(context, aheadCount, hasDirtyChanges, hasConflicts);
+}
+export function cleanupSessionWorktree(options) {
+    const context = getMainRepoContext({ worktree: options.worktree });
+    return cleanupMergedWorktree(context);
+}
+export function mergeSessionWorktree(options) {
+    const context = ensureMergeableContext(options);
+    const hasConflicts = checkConflicts(context.repoRoot, context.targetBranch, context.sourceBranch);
+    if (hasConflicts) {
+        throw new WorktreeMergeError(WORKTREE_MERGE_ERROR_CODES.CONFLICT, "合并检测到冲突，请先手动处理。", {
+            sourceBranch: context.sourceBranch,
+            targetBranch: context.targetBranch,
+            repoRoot: context.repoRoot,
+            cleanupDone: false,
+            conflict: true,
+        });
+    }
+    try {
+        runGit(["checkout", context.targetBranch], context.repoRoot);
+        runGit(["merge", "--no-ff", "--no-edit", context.sourceBranch], context.repoRoot);
+    }
+    catch (error) {
+        const message = getGitCommandMessage(error);
+        throw new WorktreeMergeError(WORKTREE_MERGE_ERROR_CODES.CONFLICT, message || "合并失败，可能存在冲突。", {
+            sourceBranch: context.sourceBranch,
+            targetBranch: context.targetBranch,
+            repoRoot: context.repoRoot,
+            cleanupDone: false,
+            conflict: true,
+        });
+    }
+    const mergedAt = new Date().toISOString();
+    const mergeCommit = getHeadCommit(context.repoRoot);
+    try {
+        cleanupMergedWorktree(context);
+        return {
+            ok: true,
+            sourceBranch: context.sourceBranch,
+            targetBranch: context.targetBranch,
+            repoRoot: context.repoRoot,
+            mergeCommit,
+            mergedAt,
+            cleanupDone: true,
+            conflict: false,
+        };
+    }
+    catch (error) {
+        throw new WorktreeMergeError(WORKTREE_MERGE_ERROR_CODES.CLEANUP_FAILED, getGitCommandMessage(error) || "已合并，但清理 worktree 失败。", {
+            sourceBranch: context.sourceBranch,
+            targetBranch: context.targetBranch,
+            repoRoot: context.repoRoot,
+            mergeCommit,
+            mergedAt,
+            cleanupDone: false,
+            conflict: false,
+        });
+    }
+}
+export function prepareSessionWorktree(options) {
+    const resolvedCwd = path.resolve(options.cwd);
+    const repoRoot = runGit(["rev-parse", "--show-toplevel"], resolvedCwd);
+    if (!repoRoot || !existsSync(repoRoot)) {
+        throw new Error("当前目录不在 git 仓库中，无法启用 worktree 模式。");
+    }
+    const baseBranch = getCurrentBranch(repoRoot);
+    const branchSuffix = sanitizeBranchSegment(options.sessionId.split("-")[0] || options.sessionId);
+    const branchName = `wand/${sanitizeBranchSegment(baseBranch)}-${branchSuffix}`;
+    const worktreesRoot = path.join(repoRoot, ".wand-worktrees");
+    const worktreePath = path.join(worktreesRoot, branchName.replace(/\//g, "-"));
+    mkdirSync(worktreesRoot, { recursive: true });
+    runGit(["worktree", "add", "-b", branchName, worktreePath, "HEAD"], repoRoot);
+    return {
+        cwd: worktreePath,
+        worktreeEnabled: true,
+        worktree: {
+            branch: branchName,
+            path: worktreePath,
+        },
+    };
+}

package/dist/message-parser.d.ts

@@ -1,2 +1,2 @@
 import type { ChatMessage } from "./types.js";
-export declare function parseMessages(output: string): ChatMessage[];
+export declare function parseMessages(output: string, command?: string): ChatMessage[];

package/dist/message-parser.js

@@ -1,8 +1,282 @@
 import { stripAnsi, isNoiseLine } from "./pty-text-utils.js";
-export function parseMessages(output) {
+function isCodexCommand(command) {
+    return /^codex\b/.test((command ?? "").trim());
+}
+const CODEX_FOOTER_RE = /\bgpt-\d+(?:\.\d+)?(?:\s+[a-z0-9.-]+)?\s+·\s+\d+%\s+left\s+·\s+(?:\/|~\/).+/i;
+const CODEX_ACTIVITY_RE = /^(?:thinking|working|running|planning|applying|reading|searching|inspecting|reviewing|summarizing|editing|updating|writing|completed)\b/i;
+function stripCodexSegment(raw) {
+    return raw
+        .replace(/\x1b\][^\x07]*(\x07|\x1b\\)/g, "")
+        .replace(/\x1b\[(\d+)C/g, (_match, count) => " ".repeat(Number(count) || 1))
+        .replace(/\x1b\[[0-9;?]*[AB]/g, "\n")
+        .replace(/\x1b\[[0-9;?]*[su]/g, "")
+        .replace(/\x1b\[[0-9;?]*[HfJKr]/g, "\n")
+        .replace(/\x1bM/g, "\n")
+        .replace(/\x1b\[[0-9;?]*[ST]/g, "\n")
+        .replace(/\x1b\[[0-9;?]*[a-zA-Z]/g, "")
+        .replace(/\x1b[><=ePX^_]/g, "")
+        .replace(/[\u00a0\u200b-\u200d\ufeff]/g, " ")
+        // eslint-disable-next-line no-control-regex
+        .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, "")
+        .replace(/[ \t]+\n/g, "\n");
+}
+function normalizeCodexText(text) {
+    return text
+        .replace(/\s+/g, " ")
+        .replace(/[M]+$/g, "")
+        .trim();
+}
+function isLikelyAssistantTailArtifact(longer, shorter) {
+    if (!longer.startsWith(shorter))
+        return false;
+    const suffix = longer.slice(shorter.length);
+    return /^[a-z]{1,4}$/i.test(suffix);
+}
+function parseCodexMessages(output) {
+    const messages = [];
+    function normalizeCodexAssistantLine(line) {
+        return line
+            .replace(/^[•◦·]\s*/, "")
+            .replace(/^⏺\s+/, "")
+            .replace(/^│\s*/, "")
+            .trim();
+    }
+    function normalizeCodexPromptLine(line) {
+        return line
+            .replace(/^›\s*/, "")
+            .replace(/^>\s*/, "")
+            .trim();
+    }
+    function shouldIgnoreCodexLine(line) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return true;
+        if (isNoiseLine(trimmed))
+            return true;
+        if (CODEX_FOOTER_RE.test(trimmed))
+            return true;
+        if (/^[╭╰│┌└┐┘├┤┬┴┼─═]/.test(trimmed))
+            return true;
+        if (/^\[>[0-9;?]*u$/i.test(trimmed))
+            return true;
+        if (/^M+$/i.test(trimmed))
+            return true;
+        if (/^(?:OpenAI Codex|Codex)\b/i.test(trimmed))
+            return true;
+        if (/^(?:tokens?|context window|remaining context|approvals?|sandbox|provider|session id):\s*/i.test(trimmed))
+            return true;
+        if (/^(?:thinking|working)\s*(?:\.\.\.|…)?$/i.test(trimmed))
+            return true;
+        if (/^[•◦·]\s+(?:thinking|working|running|planning|applying|reading|searching|inspecting|reviewing|summarizing|editing|updating|writing|completed)\b/i.test(trimmed))
+            return true;
+        if (/^(?:model|directory|tip|context|cwd|path):\s+/i.test(trimmed))
+            return true;
+        return false;
+    }
+    function extractCodexPromptCandidate(line) {
+        const trimmed = line.trim();
+        if (!/^›(?:\s|$)/.test(trimmed))
+            return null;
+        if (CODEX_FOOTER_RE.test(trimmed))
+            return null;
+        const prompt = normalizeCodexText(normalizeCodexPromptLine(trimmed));
+        if (!prompt || shouldIgnoreCodexLine(prompt))
+            return null;
+        return prompt;
+    }
+    function extractCodexAssistantCandidate(line) {
+        const trimmed = line.trim();
+        if (!/^[•◦·⏺]/.test(trimmed))
+            return null;
+        let assistant = normalizeCodexAssistantLine(trimmed);
+        if (!assistant || /^[•◦·⏺]$/.test(assistant))
+            return null;
+        assistant = assistant.replace(/\s*\(\d+[smh]?\s*•\s*esc to interrupt\)[\s\S]*$/i, "");
+        assistant = assistant.replace(/(?:[a-z]{1,6})?›[\s\S]*$/, "");
+        assistant = assistant.replace(/\s{2,}gpt-\d[\s\S]*$/i, "");
+        assistant = assistant.replace(/\b(?:OpenAI Codex|model:|directory:|Tip:)\b[\s\S]*$/i, "");
+        assistant = normalizeCodexText(assistant);
+        if (!assistant || assistant.length < 2 || CODEX_ACTIVITY_RE.test(assistant) || shouldIgnoreCodexLine(assistant)) {
+            return null;
+        }
+        return assistant;
+    }
+    function extractCodexEchoCandidate(line) {
+        const trimmed = normalizeCodexText(line);
+        if (!trimmed || shouldIgnoreCodexLine(trimmed))
+            return null;
+        if (/^[•◦·⏺›]/.test(trimmed))
+            return null;
+        if (/^[\[\]<>0-9;?]+u?$/i.test(trimmed))
+            return null;
+        if (/^[╭╰│┌└┐┘├┤┬┴┼─═]/.test(trimmed))
+            return null;
+        if (trimmed.length > 500)
+            return null;
+        return trimmed;
+    }
+    function collectCodexCandidates() {
+        const candidates = [];
+        let order = 0;
+        for (const rawSegment of output.replace(/\r\n?/g, "\n").split("\n")) {
+            const cleanedSegment = stripCodexSegment(rawSegment);
+            const pieces = cleanedSegment.split("\n");
+            for (const piece of pieces) {
+                const line = piece.trim();
+                if (!line)
+                    continue;
+                const prompt = extractCodexPromptCandidate(line);
+                if (prompt) {
+                    candidates.push({ kind: "user", order, text: prompt });
+                    order += 1;
+                    continue;
+                }
+                const assistant = extractCodexAssistantCandidate(line);
+                if (assistant) {
+                    candidates.push({ kind: "assistant", order, text: assistant });
+                    order += 1;
+                    continue;
+                }
+                const echo = extractCodexEchoCandidate(line);
+                if (echo) {
+                    candidates.push({ kind: "echo", order, text: echo });
+                    order += 1;
+                }
+            }
+        }
+        return candidates.filter((candidate, index, list) => {
+            const previous = list[index - 1];
+            return !previous || previous.kind !== candidate.kind || previous.text !== candidate.text;
+        });
+    }
+    function coalesceAssistantLines(lines) {
+        const collected = [];
+        for (const line of lines) {
+            const normalized = normalizeCodexText(line);
+            if (!normalized || normalized.length < 2 || shouldIgnoreCodexLine(normalized))
+                continue;
+            const previous = collected[collected.length - 1];
+            if (!previous) {
+                collected.push(normalized);
+                continue;
+            }
+            if (normalized === previous)
+                continue;
+            if (normalized.startsWith(previous)) {
+                collected[collected.length - 1] = normalized;
+                continue;
+            }
+            if (previous.startsWith(normalized)) {
+                if (isLikelyAssistantTailArtifact(previous, normalized)) {
+                    collected[collected.length - 1] = normalized;
+                }
+                continue;
+            }
+            collected.push(normalized);
+        }
+        return collected.join("\n").trim();
+    }
+    function extractVisiblePrompt(lines) {
+        for (let index = 0; index < lines.length; index += 1) {
+            const line = lines[index].trim();
+            if (!line)
+                continue;
+            const inlinePrompt = extractCodexPromptCandidate(line);
+            if (inlinePrompt)
+                return inlinePrompt;
+            if (line === "›") {
+                for (let nextIndex = index + 1; nextIndex < lines.length; nextIndex += 1) {
+                    const nextLine = normalizeCodexText(lines[nextIndex]);
+                    if (!nextLine || CODEX_FOOTER_RE.test(nextLine) || shouldIgnoreCodexLine(nextLine))
+                        continue;
+                    return nextLine;
+                }
+            }
+        }
+        return null;
+    }
+    function extractVisibleAssistantLines(lines) {
+        const assistantLines = [];
+        let collecting = false;
+        for (const rawLine of lines) {
+            const line = rawLine.trim();
+            if (!line) {
+                if (collecting)
+                    break;
+                continue;
+            }
+            const assistant = extractCodexAssistantCandidate(line);
+            if (assistant) {
+                assistantLines.push(assistant);
+                collecting = true;
+                continue;
+            }
+            if (collecting) {
+                if (line === "›" ||
+                    /^›(?:\s|$)/.test(line) ||
+                    CODEX_FOOTER_RE.test(line) ||
+                    shouldIgnoreCodexLine(line)) {
+                    break;
+                }
+                assistantLines.push(normalizeCodexText(line));
+            }
+        }
+        return assistantLines;
+    }
+    const candidates = collectCodexCandidates();
+    const explicitUsers = candidates.filter((candidate) => candidate.kind === "user");
+    const assistantCandidates = candidates.filter((candidate) => candidate.kind === "assistant");
+    const echoCandidates = candidates.filter((candidate) => candidate.kind === "echo");
+    const strippedOutput = stripAnsi(output);
+    const strippedLines = strippedOutput.split("\n").map((line) => line.trimEnd());
+    const visiblePrompt = extractVisiblePrompt(strippedLines);
+    const latestExplicitUser = explicitUsers[explicitUsers.length - 1] ?? null;
+    const echoedUserCandidates = echoCandidates
+        .map((candidate) => candidate.text)
+        .filter((text) => text.length >= 3);
+    const latestEchoUser = [...echoedUserCandidates].reverse().find((text) => text !== visiblePrompt) ?? echoedUserCandidates[echoedUserCandidates.length - 1] ?? null;
+    const currentUser = latestExplicitUser?.text ?? latestEchoUser;
+    const rawAssistantLines = assistantCandidates
+        .filter((candidate) => !latestExplicitUser || candidate.order > latestExplicitUser.order)
+        .map((candidate) => candidate.text);
+    const visibleAssistantFallback = [...strippedOutput.matchAll(/^[ \t]*[•◦·⏺][ \t]*(.+)$/gm)]
+        .map((match) => normalizeCodexText(match[1] ?? ""))
+        .filter((line) => (!!line
+        && !CODEX_ACTIVITY_RE.test(line)
+        && !CODEX_FOOTER_RE.test(line)
+        && !/\b(?:OpenAI Codex|model:|directory:|Tip:|esc to interrupt)\b/i.test(line)));
+    const assistant = coalesceAssistantLines(rawAssistantLines)
+        || coalesceAssistantLines(extractVisibleAssistantLines(strippedLines))
+        || visibleAssistantFallback[visibleAssistantFallback.length - 1]
+        || null;
+    if (currentUser) {
+        messages.push({ role: "user", content: currentUser });
+    }
+    if (assistant) {
+        messages.push({ role: "assistant", content: assistant });
+    }
+    if (!messages.length && latestExplicitUser) {
+        messages.push({ role: "user", content: latestExplicitUser.text });
+    }
+    else if (!messages.length && latestEchoUser) {
+        messages.push({ role: "user", content: latestEchoUser });
+    }
+    const deduped = [];
+    for (const message of messages) {
+        const previous = deduped[deduped.length - 1];
+        if (!previous || previous.role !== message.role || previous.content !== message.content) {
+            deduped.push(message);
+        }
+    }
+    return deduped;
+}
+export function parseMessages(output, command) {
     const messages = [];
     if (!output)
         return messages;
+    if (isCodexCommand(command)) {
+        return parseCodexMessages(output);
+    }
     const stripped = stripAnsi(output).replace(/\r/g, "\n");
     const lines = stripped.split("\n");
     const cleaned = lines.filter((line) => !isNoiseLine(line.trim()));