aimux-cli 0.1.18 → 0.1.20

package/dist/agent-output-parser.js

@@ -1,5 +1,56 @@
+const activityDurationPattern = String.raw `\d+(?:ms|s|m|h)(?:\s+\d+(?:ms|s|m|h))*`;
+const activityForDurationRegex = new RegExp(String.raw `\bfor\s+${activityDurationPattern}(?:$|(?=\s*[·•.)]))`, "i");
+const activityRestForDurationRegex = new RegExp(String.raw `^for\s+${activityDurationPattern}(?:$|(?=\s*[·•.)]))`, "i");
+const activityParentheticalDurationRegex = new RegExp(String.raw `\([^)]*\b${activityDurationPattern}\b[^)]*\)`, "i");
+const activityEllipsisRegex = /\.{3}|…/;
+const activityLeadRegex = /^[\p{Lu}][\p{L}-]{2,}\b/u;
+const looksLikeActivityProgressText = (text) => {
+    const trimmed = text.trim();
+    const lead = trimmed.match(activityLeadRegex)?.[0] ?? "";
+    if (!lead || !/(ed|ing)$/i.test(lead))
+        return false;
+    const rest = trimmed.slice(lead.length).trimStart();
+    if (!(activityRestForDurationRegex.test(rest) ||
+        activityParentheticalDurationRegex.test(rest) ||
+        activityEllipsisRegex.test(rest))) {
+        return false;
+    }
+    return (activityForDurationRegex.test(trimmed) ||
+        activityParentheticalDurationRegex.test(trimmed) ||
+        activityEllipsisRegex.test(trimmed));
+};
+const looksLikeRanCommandText = (text) => {
+    const trimmed = text.trim();
+    return (/^Ran\s+(?:aimux|bash|bun|cat|cd|curl|docker|find|gh|git|grep|ls|mkdir|mv|node|npm|pnpm|python3?|rg|rm|sed|sh|tsc|tsx|vitest|yarn)\b/i.test(trimmed) && !/[.!?]$/.test(trimmed));
+};
+const looksLikeToolActionText = (text) => {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return false;
+    return (/^Bash\([^)]*$/i.test(trimmed) ||
+        /^(?:Bash|BashOutput|Edit|Explore|Glob|Grep|KillBash|LS|MultiEdit|NotebookEdit|Read|Task|TodoWrite|Update|WebFetch|WebSearch|Write)\s*(?:\([^)\n]*\)|\d+[^\n]*(?:ctrl\+o|to expand)|[^\n]*(?:Running in the background|exit code))\s*$/i.test(trimmed) ||
+        /^Background command\s+".+"\s+completed\s+\(exit code\s+\d+\)/i.test(trimmed) ||
+        looksLikeRanCommandText(trimmed) ||
+        /^Searched\s*for\s*\d+\s*patterns?/i.test(trimmed) ||
+        /^Read\s*\d+\s*files?/i.test(trimmed));
+};
+const inferAgentOutputTool = (raw) => {
+    const text = String(raw || "");
+    const hasCodexChrome = /(?:^|\n)\s*(?:│\s*)?>_\s*OpenAI Codex\b/im.test(text) ||
+        /(?:^|\n)\s*gpt-[\w.-]+\b.*(?:~\/|\/|permissions|context\))/im.test(text);
+    const hasClaudeChrome = /(?:^|\n)\s*(?:│\s*)?Claude Code\b/im.test(text) ||
+        /(?:^|\n)\s*claude\b.*(?:~\/|\/|permissions|context\))/im.test(text);
+    if (hasCodexChrome && !hasClaudeChrome) {
+        return "codex";
+    }
+    if (hasClaudeChrome && !hasCodexChrome) {
+        return "claude";
+    }
+    return null;
+};
 export function parseAgentOutput(raw, options = {}) {
-    const tool = (options.tool || "unknown").trim() || "unknown";
+    const requestedTool = (options.tool || "").trim();
+    const tool = requestedTool && requestedTool !== "unknown" ? requestedTool : (inferAgentOutputTool(raw) ?? "unknown");
     const lines = String(raw || "")
         .replace(/\r/g, "")
         .split("\n");
@@ -7,6 +58,7 @@ export function parseAgentOutput(raw, options = {}) {
     let current = null;
     let sawPrompt = false;
     let expectingResponse = false;
+    let lastLineWasDivider = false;
     const flush = () => {
         if (!current)
             return;
@@ -46,16 +98,40 @@ export function parseAgentOutput(raw, options = {}) {
             /^[A-Za-z0-9._-]+@[^ ]+\s+(~\/|\/)/.test(trimmed) ||
             (/^([›>]|▶)\s/.test(trimmed) && /(permissions|cycle|cwd|context)/i.test(trimmed)) ||
             /^⏵⏵\s/.test(trimmed) ||
-            /gpt-|claude|context\)|bypass permissions|shift\+tab|to cycle/i.test(trimmed));
+            /^gpt-[\w.-]+\b.*(?:~\/|\/|context\)|permissions)/i.test(trimmed) ||
+            /^claude\b.*(?:~\/|\/|context\)|permissions)/i.test(trimmed) ||
+            /bypass permissions|shift\+tab|to cycle/i.test(trimmed));
+    };
+    const isCodexUiLine = (line) => {
+        const trimmed = line.trim();
+        return /^│/.test(trimmed) || /^╰/.test(trimmed) || /^╭/.test(trimmed);
     };
     const isStatusLine = (line) => {
         const trimmed = line.trim();
         if (!trimmed)
             return false;
+        const dotBulletText = trimmed.replace(/^•\s?/, "");
+        const starBulletText = trimmed.replace(/^\*\s+/, "");
+        const dashBulletText = trimmed.replace(/^-\s+/, "");
+        const spinnerText = trimmed.replace(/^[✻✽✶]\s+/, "");
+        const conversationBulletText = trimmed.replace(/^(?:•|⏺)\s?/, "");
         return (/^■\s?/.test(trimmed) ||
+            /^⏺\s*$/.test(trimmed) ||
+            /^⏺\s*[\u2500-\u257f\-_=\s]+Bash command\b/i.test(trimmed) ||
+            /^⏺\s*Bash\([^)\n]*terminal-notifier/i.test(trimmed) ||
+            /^└\s+/.test(trimmed) ||
+            looksLikeActivityProgressText(trimmed) ||
             /^•\s?Working\b/.test(trimmed) ||
+            /^•\s?Starting MCP servers\b/.test(trimmed) ||
+            /^•\s?How is Claude doing this session\?\s*\(optional\)/i.test(trimmed) ||
+            looksLikeRanCommandText(trimmed) ||
+            looksLikeToolActionText(trimmed) ||
+            (/^(?:•|⏺)\s?/.test(trimmed) && looksLikeToolActionText(conversationBulletText)) ||
+            (/^•\s?/.test(trimmed) && looksLikeActivityProgressText(dotBulletText)) ||
             /^⏵⏵\s/.test(trimmed) ||
-            /^\*\s+[A-Z][A-Za-z-]+(?:\.\.\.|…)?$/.test(trimmed) ||
+            (/^\*\s+/.test(trimmed) && looksLikeActivityProgressText(starBulletText)) ||
+            (/^-\s+/.test(trimmed) && looksLikeActivityProgressText(dashBulletText)) ||
+            (/^[✻✽✶]\s+/.test(trimmed) && looksLikeActivityProgressText(spinnerText)) ||
             /^[╰└]\s*Tip:/i.test(trimmed) ||
             /^Tip:\s/i.test(trimmed) ||
             /(Plan Mode|default permission mode)/i.test(trimmed) ||
@@ -69,13 +145,43 @@ export function parseAgentOutput(raw, options = {}) {
     };
     const stripPromptMarker = (line) => line.trimStart().replace(/^(›|>|❯)\s?/, "");
     const stripResponseMarker = (line) => line.trimStart().replace(/^(•|⏺)\s?/, "");
-    const stripStatusMarker = (line) => line.trimStart().replace(/^(■|\*\s+)\s?/, "");
+    const stripStatusMarker = (line) => line.trimStart().replace(/^(■|[-*✻✽✶]\s+)\s?/, "");
+    const isCodexPickerSelectionPrompt = (promptText) => {
+        if (tool !== "codex" || sawPrompt || (current?.type !== "response" && current?.type !== "raw"))
+            return false;
+        const activeText = current.lines.join("\n");
+        if (!/(?:Resume a previous session|Choose working directory to resume this session)/i.test(activeText)) {
+            return false;
+        }
+        return /^(?:now|\d+[smhd]\s+ago|\d+\.\s)/i.test(promptText.trim());
+    };
     for (const line of lines) {
         const trimmed = line.trimEnd();
-        if (isDivider(trimmed))
+        if (isCodexUiLine(trimmed)) {
+            lastLineWasDivider = false;
+            pushLine(sawPrompt ? "status" : "meta", trimmed);
             continue;
+        }
+        if (isDivider(trimmed)) {
+            lastLineWasDivider = true;
+            continue;
+        }
         if (isPromptLine(trimmed)) {
             const promptText = stripPromptMarker(trimmed);
+            if (lastLineWasDivider) {
+                if (promptText.trim())
+                    pushLine("status", promptText);
+                lastLineWasDivider = false;
+                expectingResponse = false;
+                continue;
+            }
+            lastLineWasDivider = false;
+            if (isCodexPickerSelectionPrompt(promptText)) {
+                if (promptText.trim())
+                    pushLine("status", promptText);
+                expectingResponse = false;
+                continue;
+            }
             if (!promptText.trim()) {
                 flush();
                 expectingResponse = false;
@@ -83,10 +189,11 @@ export function parseAgentOutput(raw, options = {}) {
             }
             pushLine("prompt", promptText);
             sawPrompt = true;
-            expectingResponse = true;
+            expectingResponse = false;
             continue;
         }
-        if (/^(•|⏺)\s?/.test(trimmed) && !/^•\s?Working\b/.test(trimmed)) {
+        lastLineWasDivider = false;
+        if (/^(•|⏺)\s?/.test(trimmed) && !isStatusLine(trimmed)) {
             pushLine("response", stripResponseMarker(trimmed));
             sawPrompt = true;
             expectingResponse = false;
@@ -110,11 +217,23 @@ export function parseAgentOutput(raw, options = {}) {
             const active = current;
             if (active && active.type !== "raw") {
                 active.lines.push("");
+                if (active.type === "prompt")
+                    expectingResponse = true;
                 continue;
             }
             flush();
             continue;
         }
+        const promptBlock = current;
+        if (promptBlock?.type === "prompt" && !expectingResponse) {
+            promptBlock.lines.push(trimmed);
+            continue;
+        }
+        if (promptBlock?.type === "prompt" && expectingResponse && /^\s+\S/.test(trimmed)) {
+            promptBlock.lines.push(trimmed);
+            expectingResponse = false;
+            continue;
+        }
         if (expectingResponse || current?.type === "response") {
             pushLine("response", trimmed);
             continue;
@@ -132,7 +251,7 @@ export function parseAgentOutput(raw, options = {}) {
     }
     flush();
     return {
-        blocks: normalizeTranscriptBlocks(blocks.filter((block) => block.text.trim().length > 0)),
+        blocks: normalizeTranscriptBlocks(blocks.filter((block) => block.text.trim().length > 0), tool),
         parser: {
             tool,
             version: 1,
@@ -140,8 +259,40 @@ export function parseAgentOutput(raw, options = {}) {
         },
     };
 }
-function normalizeTranscriptBlocks(blocks) {
+function normalizeTranscriptBlocks(blocks, tool) {
     const next = blocks.map((block) => ({ ...block }));
+    const looksLikeFooterStatus = (text) => {
+        return String(text || "")
+            .split("\n")
+            .some((line) => {
+            const trimmed = line.trim();
+            return ((/^([A-Za-z0-9._-]+@[^ ]+|~\/|\/)/.test(trimmed) && /(context\)|%\s|[$#]\s)/.test(trimmed)) ||
+                /^gpt-[\w.-]+\b.*(?:~\/|\/|context\)|permissions)/i.test(trimmed) ||
+                /^claude\b.*(?:~\/|\/|context\)|permissions)/i.test(trimmed) ||
+                /bypass permissions|shift\+tab|to cycle/i.test(trimmed));
+        });
+    };
+    const looksLikeActiveWorkStatus = (text) => String(text || "")
+        .split("\n")
+        .some((line) => {
+        const trimmed = line.trim();
+        return (/\bWorking \(\d+s\b.*\besc to interrupt\b/i.test(trimmed) ||
+            /^Starting MCP servers\b/i.test(trimmed) ||
+            looksLikeActivityProgressText(trimmed));
+    });
+    const normalizedPromptText = (text) => String(text || "")
+        .trim()
+        .replace(/\s+/g, " ");
+    const promptCounts = new Map();
+    for (const block of next) {
+        if (block.type !== "prompt")
+            continue;
+        const normalized = normalizedPromptText(block.text);
+        if (!normalized)
+            continue;
+        promptCounts.set(normalized, (promptCounts.get(normalized) ?? 0) + 1);
+    }
+    const isTemplatePrompt = (text) => /\{[A-Za-z][A-Za-z0-9_-]*\}/.test(text);
     const looksLikeAssistantText = (text) => {
         const trimmed = String(text || "").trim();
         if (!trimmed)
@@ -154,6 +305,26 @@ function normalizeTranscriptBlocks(blocks) {
             return false;
         return /[A-Za-z]/.test(trimmed);
     };
+    const looksLikeRuntimeNoiseText = (text) => {
+        const lines = String(text || "")
+            .split("\n")
+            .map((line) => line.trim())
+            .filter(Boolean);
+        const joined = lines.join("\n");
+        const runtimeLineCount = lines.filter((line) => {
+            return (/^[✢✳✶✻✽·]/.test(line) ||
+                /^\(thinking\)$/i.test(line) ||
+                /^Bash\([^)]*terminal-notifier/i.test(line));
+        }).length;
+        return (runtimeLineCount >= 2 ||
+            /terminal-notifier.*Running/i.test(joined) ||
+            (/terminal-notifier/i.test(joined) && /(?:Bash command|Thiscommandrequiresapproval|Doyouwanttoproceed)/i.test(joined)));
+    };
+    for (const block of next) {
+        if (block.type === "raw" && looksLikeRuntimeNoiseText(block.text)) {
+            block.type = "status";
+        }
+    }
     for (let i = 0; i < next.length; i += 1) {
         const current = next[i];
         if (!current || current.type !== "raw")
@@ -165,8 +336,13 @@ function normalizeTranscriptBlocks(blocks) {
             (following?.type === "prompt" || following?.type === "response");
         const leadingAssistantCarryover = !prev && (following?.type === "prompt" || following?.type === "response" || following?.type === "status");
         const leadingAssistantPrelude = !prev && nextConversationIndex !== -1;
+        const leadingAssistantAfterMetaPrelude = prev?.type === "meta" && nextConversationIndex !== -1;
         const responseContinuation = prev?.type === "response";
-        if ((betweenConversationTurns || leadingAssistantCarryover || leadingAssistantPrelude || responseContinuation) &&
+        if ((betweenConversationTurns ||
+            leadingAssistantCarryover ||
+            leadingAssistantPrelude ||
+            leadingAssistantAfterMetaPrelude ||
+            responseContinuation) &&
             looksLikeAssistantText(current.text)) {
             current.type = "response";
         }
@@ -191,6 +367,34 @@ function normalizeTranscriptBlocks(blocks) {
             block.type = "response";
         }
     }
+    for (let i = 0; i < next.length; i += 1) {
+        const current = next[i];
+        if (!current || current.type !== "prompt")
+            continue;
+        const previous = next[i - 1] || null;
+        const following = next[i + 1] || null;
+        const normalized = normalizedPromptText(current.text);
+        const nextConversationIndex = next.findIndex((block, index) => index > i && (block.type === "prompt" || block.type === "response"));
+        const intervening = next.slice(i + 1, nextConversationIndex === -1 ? undefined : nextConversationIndex);
+        const hasActiveWorkBeforeNextTurn = intervening.some((block) => block.type === "status" && looksLikeActiveWorkStatus(block.text));
+        const repeatedPrompt = (promptCounts.get(normalized) ?? 0) > 1;
+        const templatePrompt = isTemplatePrompt(current.text);
+        const hasPriorConversationTurn = next
+            .slice(0, i)
+            .some((block) => block.type === "prompt" || block.type === "response");
+        const trailingFooterInput = nextConversationIndex === -1 && hasPriorConversationTurn;
+        if (tool === "codex" &&
+            following?.type === "status" &&
+            looksLikeFooterStatus(following.text) &&
+            (!hasActiveWorkBeforeNextTurn || repeatedPrompt || templatePrompt) &&
+            (repeatedPrompt ||
+                templatePrompt ||
+                trailingFooterInput ||
+                previous?.type === "response" ||
+                (previous?.type === "status" && looksLikeActiveWorkStatus(previous.text)))) {
+            current.type = "status";
+        }
+    }
     const merged = [];
     for (const block of next) {
         const previous = merged[merged.length - 1];
@@ -200,30 +404,5 @@ function normalizeTranscriptBlocks(blocks) {
         }
         merged.push(block);
     }
-    return stripTrailingVisiblePrompt(merged);
-}
-function stripTrailingVisiblePrompt(blocks) {
-    const promptIndex = findLastIndex(blocks, (block) => block.type === "prompt");
-    if (promptIndex === -1) {
-        return blocks;
-    }
-    const hasResponseAfterPrompt = blocks.slice(promptIndex + 1).some((block) => block.type === "response");
-    if (hasResponseAfterPrompt) {
-        return blocks;
-    }
-    const trailingBlocks = blocks.slice(promptIndex + 1);
-    const hasOnlyNonConversationTail = trailingBlocks.every((block) => block.type === "status" || block.type === "meta" || block.type === "raw");
-    if (!hasOnlyNonConversationTail) {
-        return blocks;
-    }
-    return blocks.filter((_, index) => index !== promptIndex);
-}
-function findLastIndex(items, predicate) {
-    for (let index = items.length - 1; index >= 0; index -= 1) {
-        if (predicate(items[index])) {
-            return index;
-        }
-    }
-    return -1;
+    return merged;
 }
-//# sourceMappingURL=agent-output-parser.js.map

package/dist/agent-prompt-delivery.js

@@ -116,4 +116,3 @@ export async function deliverTmuxPrompt(opts) {
         return true;
     return waitForTmuxPromptSubmit({ tmuxRuntimeManager, target, draft: prompt, isTargetCurrent });
 }
-//# sourceMappingURL=agent-prompt-delivery.js.map

package/dist/agent-tracker.js

@@ -145,4 +145,3 @@ export class AgentTracker {
 export function getDerivedState(metadata) {
     return metadata?.derived;
 }
-//# sourceMappingURL=agent-tracker.js.map

package/dist/agent-watcher.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=agent-watcher.js.map

package/dist/alert-display.js

@@ -83,4 +83,3 @@ export function contextualizeAlertInput(input, context) {
         worktreePath: input.worktreePath ?? context?.worktreePath,
     };
 }
-//# sourceMappingURL=alert-display.js.map

package/dist/atomic-write.d.ts

@@ -1 +1,16 @@
+/**
+ * Crash-safe write: stage to a temp file, fsync its contents, atomically rename
+ * into place, then fsync the directory so the rename itself survives power loss.
+ * This is the single durable write path for persistent state.
+ */
+export declare function atomicWrite(path: string, data: string | Buffer, options?: {
+    mode?: number;
+}): void;
 export declare function writeJsonAtomic(path: string, value: unknown): void;
+export declare function writeTextAtomic(path: string, text: string): void;
+/**
+ * Move a corrupt/unparseable state file aside (preserving it for diagnosis)
+ * instead of silently letting a reader reset to empty and a later write
+ * overwrite the evidence. Best-effort; returns the quarantine path or null.
+ */
+export declare function quarantineCorruptFile(path: string): string | null;

package/dist/atomic-write.js

@@ -1,9 +1,73 @@
-import { mkdirSync, renameSync, writeFileSync } from "node:fs";
+import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
-export function writeJsonAtomic(path, value) {
+function fsyncDir(dir) {
+    let fd;
+    try {
+        fd = openSync(dir, "r");
+        fsyncSync(fd);
+    }
+    catch {
+        // Directory fsync is unsupported on some filesystems; the renamed file is
+        // still covered by the temp-file fsync above. Best-effort only.
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+    }
+}
+/**
+ * Crash-safe write: stage to a temp file, fsync its contents, atomically rename
+ * into place, then fsync the directory so the rename itself survives power loss.
+ * This is the single durable write path for persistent state.
+ */
+export function atomicWrite(path, data, options) {
     mkdirSync(dirname(path), { recursive: true });
     const tmpPath = `${path}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`;
-    writeFileSync(tmpPath, `${JSON.stringify(value, null, 2)}\n`);
-    renameSync(tmpPath, path);
+    let fd;
+    try {
+        writeFileSync(tmpPath, data, options?.mode !== undefined ? { mode: options.mode } : undefined);
+        fd = openSync(tmpPath, "r");
+        fsyncSync(fd);
+        closeSync(fd);
+        fd = undefined;
+        renameSync(tmpPath, path);
+        fsyncDir(dirname(path));
+    }
+    catch (error) {
+        if (fd !== undefined) {
+            try {
+                closeSync(fd);
+            }
+            catch { }
+        }
+        try {
+            rmSync(tmpPath, { force: true });
+        }
+        catch { }
+        throw error;
+    }
+}
+export function writeJsonAtomic(path, value) {
+    atomicWrite(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+export function writeTextAtomic(path, text) {
+    atomicWrite(path, text);
+}
+/**
+ * Move a corrupt/unparseable state file aside (preserving it for diagnosis)
+ * instead of silently letting a reader reset to empty and a later write
+ * overwrite the evidence. Best-effort; returns the quarantine path or null.
+ */
+export function quarantineCorruptFile(path) {
+    try {
+        if (!existsSync(path))
+            return null;
+        const dest = `${path}.corrupt-${Date.now()}`;
+        renameSync(path, dest);
+        console.error(`aimux: quarantined corrupt state file ${path} -> ${dest}`);
+        return dest;
+    }
+    catch {
+        return null;
+    }
 }
-//# sourceMappingURL=atomic-write.js.map

package/dist/attachment-store.d.ts

@@ -20,9 +20,16 @@ export interface PublicAttachmentRecord {
     source: "path" | "upload";
     contentUrl: string;
 }
+export interface CreateUploadedAttachmentInput {
+    filename: string;
+    mimeType: string;
+    dataBase64: string;
+}
+export declare function createUploadedAttachment(input: CreateUploadedAttachmentInput): PublicAttachmentRecord;
 export declare function getAttachment(id: string): PublicAttachmentRecord | null;
 export declare function getAttachmentContent(id: string): {
     attachment: PublicAttachmentRecord;
     contentPath: string;
     buffer: Buffer;
 } | null;
+export declare function getAttachmentRecord(id: string): AttachmentRecord | null;

package/dist/attachment-store.js

@@ -1,12 +1,55 @@
-import { readFileSync, existsSync } from "node:fs";
-import { join } from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { basename, join } from "node:path";
 import { getAttachmentsDir } from "./paths.js";
+import { atomicWrite, writeJsonAtomic } from "./atomic-write.js";
+const maxUploadBytes = 10 * 1024 * 1024;
+const allowedImageExtensions = new Map([
+    ["image/png", ".png"],
+    ["image/jpeg", ".jpg"],
+    ["image/webp", ".webp"],
+    ["image/gif", ".gif"],
+]);
+export function createUploadedAttachment(input) {
+    const mimeType = input.mimeType.trim().toLowerCase();
+    const extension = allowedImageExtensions.get(mimeType);
+    if (!extension) {
+        throw new Error("unsupported attachment mime type");
+    }
+    const filename = sanitizeFilename(input.filename);
+    const dataBase64 = normalizeBase64(input.dataBase64);
+    const buffer = Buffer.from(dataBase64, "base64");
+    if (buffer.length === 0) {
+        throw new Error("attachment content is required");
+    }
+    if (buffer.length > maxUploadBytes) {
+        throw new Error("attachment exceeds 10 MB");
+    }
+    const attachmentsDir = getAttachmentsDir();
+    mkdirSync(attachmentsDir, { recursive: true });
+    const id = `att_${randomUUID().replaceAll("-", "")}`;
+    const contentPath = join(attachmentsDir, `${id}${extension}`);
+    const record = {
+        id,
+        kind: "image",
+        filename,
+        mimeType,
+        sizeBytes: buffer.length,
+        sha256: createHash("sha256").update(buffer).digest("hex"),
+        createdAt: new Date().toISOString(),
+        source: "upload",
+        contentPath,
+    };
+    atomicWrite(contentPath, buffer);
+    writeJsonAtomic(join(attachmentsDir, `${id}.json`), record);
+    return toPublicAttachment(record);
+}
 export function getAttachment(id) {
-    const record = loadAttachmentRecord(id);
+    const record = getAttachmentRecord(id);
     return record ? toPublicAttachment(record) : null;
 }
 export function getAttachmentContent(id) {
-    const record = loadAttachmentRecord(id);
+    const record = getAttachmentRecord(id);
     if (!record)
         return null;
     return {
@@ -15,10 +58,12 @@ export function getAttachmentContent(id) {
         buffer: readFileSync(record.contentPath),
     };
 }
-function loadAttachmentRecord(id) {
+export function getAttachmentRecord(id) {
     const normalizedId = id.trim();
     if (!normalizedId)
         return null;
+    if (!/^[A-Za-z0-9_-]+$/.test(normalizedId))
+        return null;
     const metadataPath = join(getAttachmentsDir(), `${normalizedId}.json`);
     if (!existsSync(metadataPath)) {
         return null;
@@ -29,6 +74,20 @@ function loadAttachmentRecord(id) {
     }
     return parsed;
 }
+function sanitizeFilename(filename) {
+    const safeName = basename(filename.trim()).replaceAll(/[\\/]/g, "").trim();
+    return safeName || "image";
+}
+function normalizeBase64(dataBase64) {
+    const normalized = dataBase64
+        .trim()
+        .replace(/^data:[^;]+;base64,/, "")
+        .replaceAll(/\s/g, "");
+    if (!/^[A-Za-z0-9+/]*={0,2}$/.test(normalized) || normalized.length % 4 !== 0) {
+        throw new Error("attachment content must be base64");
+    }
+    return normalized;
+}
 function toPublicAttachment(record) {
     return {
         id: record.id,
@@ -42,4 +101,3 @@ function toPublicAttachment(record) {
         contentUrl: `/attachments/${record.id}/content`,
     };
 }
-//# sourceMappingURL=attachment-store.js.map

package/dist/backend-session-discovery.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Best-effort recovery of a claude backend session id from its on-disk
+ * transcript store, for a session whose durable backend id was lost (e.g. a
+ * crash that killed the tmux pane before the id was captured). Returns the
+ * uuid only when the worktree's transcript directory holds exactly one
+ * candidate — an unambiguous match. If the directory is absent, empty, or
+ * holds several transcripts (e.g. the main repo where many agents ran over
+ * time), it refuses and returns null rather than guess the wrong session.
+ * This preserves the "exact id only" safety of the original resume path.
+ */
+export declare function discoverClaudeBackendSessionId(cwd: string, projectsDir?: string): string | null;
+/**
+ * Recover a backend session id from the tool's own on-disk session store when
+ * the durable topology record lost it. Only claude is supported today (codex
+ * carries its id in launch args); returns null for anything else.
+ */
+export declare function discoverBackendSessionId(toolConfigKey: string | undefined, cwd: string | undefined): string | null;

package/dist/backend-session-discovery.js

@@ -0,0 +1,57 @@
+import { existsSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function claudeProjectsDir() {
+    // Mirrors Claude Code's own config location, which honors CLAUDE_CONFIG_DIR.
+    const override = process.env.CLAUDE_CONFIG_DIR?.trim();
+    return join(override ? override : join(homedir(), ".claude"), "projects");
+}
+// Claude encodes a project directory by replacing "/" and "." in the cwd with
+// "-", e.g. /Users/x/.aimux/wt -> -Users-x--aimux-wt.
+function encodeClaudeProjectPath(cwd) {
+    return cwd.replace(/[/.]/g, "-");
+}
+/**
+ * Best-effort recovery of a claude backend session id from its on-disk
+ * transcript store, for a session whose durable backend id was lost (e.g. a
+ * crash that killed the tmux pane before the id was captured). Returns the
+ * uuid only when the worktree's transcript directory holds exactly one
+ * candidate — an unambiguous match. If the directory is absent, empty, or
+ * holds several transcripts (e.g. the main repo where many agents ran over
+ * time), it refuses and returns null rather than guess the wrong session.
+ * This preserves the "exact id only" safety of the original resume path.
+ */
+export function discoverClaudeBackendSessionId(cwd, projectsDir = claudeProjectsDir()) {
+    const dir = join(projectsDir, encodeClaudeProjectPath(cwd));
+    if (!existsSync(dir))
+        return null;
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return null;
+    }
+    const ids = [];
+    for (const entry of entries) {
+        if (!entry.endsWith(".jsonl"))
+            continue;
+        const id = entry.slice(0, -".jsonl".length);
+        if (UUID_RE.test(id))
+            ids.push(id);
+    }
+    return ids.length === 1 ? ids[0] : null;
+}
+/**
+ * Recover a backend session id from the tool's own on-disk session store when
+ * the durable topology record lost it. Only claude is supported today (codex
+ * carries its id in launch args); returns null for anything else.
+ */
+export function discoverBackendSessionId(toolConfigKey, cwd) {
+    if (!cwd || !toolConfigKey)
+        return null;
+    if (toolConfigKey === "claude")
+        return discoverClaudeBackendSessionId(cwd);
+    return null;
+}

package/dist/builtin-metadata-watchers.js

@@ -175,4 +175,3 @@ export function createBuiltinMetadataWatchers(api) {
     debug("registered builtin metadata watchers", "plugin");
     return [planWatcher, statusWatcher, taskWatcher, historyWatcher];
 }
-//# sourceMappingURL=builtin-metadata-watchers.js.map

package/dist/claude-hooks.js

@@ -128,4 +128,3 @@ export function summarizeClaudeStop(payload) {
     const body = pickString(payload.message, object["summary"], object["message"]) ?? "Claude completed its turn.";
     return { subtitle, body };
 }
-//# sourceMappingURL=claude-hooks.js.map