codex-autorunner 1.0.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

codex_autorunner/static/workspace.js

@@ -1,13 +1,19 @@
 // GENERATED FILE - do not edit directly. Source: static_src/
-import { api, flash } from "./utils.js";
+import { api, confirmModal, flash, setButtonLoading } from "./utils.js";
 import { initAgentControls, getSelectedAgent, getSelectedModel, getSelectedReasoning } from "./agentControls.js";
 import { fetchWorkspace, ingestSpecToTickets, listTickets, fetchWorkspaceTree, uploadWorkspaceFiles, downloadWorkspaceZip, createWorkspaceFolder, writeWorkspace, } from "./workspaceApi.js";
-import { applyDraft, discardDraft, fetchPendingDraft, sendFileChat, interruptFileChat, } from "./fileChat.js";
+import { applyDraft, discardDraft, fetchPendingDraft, sendFileChat, interruptFileChat, newClientTurnId, streamTurnEvents, } from "./fileChat.js";
 import { DocEditor } from "./docEditor.js";
 import { WorkspaceFileBrowser } from "./workspaceFileBrowser.js";
 import { createDocChat } from "./docChatCore.js";
+import { initChatPasteUpload } from "./chatUploads.js";
 import { initDocChatVoice } from "./docChatVoice.js";
 import { renderDiff } from "./diffRenderer.js";
+import { createSmartRefresh } from "./smartRefresh.js";
+import { subscribe } from "./bus.js";
+import { isRepoHealthy } from "./health.js";
+import { loadPendingTurn, savePendingTurn, clearPendingTurn } from "./turnResume.js";
+import { resumeFileChatTurn } from "./turnEvents.js";
 const state = {
     target: null,
     content: "",
@@ -20,6 +26,7 @@ const state = {
 };
 const WORKSPACE_CHAT_EVENT_LIMIT = 8;
 const WORKSPACE_CHAT_EVENT_MAX = 50;
+const WORKSPACE_PENDING_KEY = "car.workspace.pendingTurn";
 const workspaceChat = createDocChat({
     idPrefix: "workspace-chat",
     storage: { keyPrefix: "car-workspace-chat-", maxMessages: 50, version: 1 },
@@ -43,6 +50,34 @@ const workspaceChat = createDocChat({
     },
 });
 const WORKSPACE_DOC_KINDS = new Set(["active_context", "decisions", "spec"]);
+const WORKSPACE_REFRESH_REASONS = ["initial", "background", "manual"];
+let workspaceRefreshCount = 0;
+let currentTurnEventsController = null;
+function hashString(value) {
+    let hash = 5381;
+    for (let i = 0; i < value.length; i += 1) {
+        hash = (hash * 33) ^ value.charCodeAt(i);
+    }
+    return (hash >>> 0).toString(36);
+}
+function workspaceTreeSignature(nodes) {
+    const parts = [];
+    const walk = (list) => {
+        list.forEach((node) => {
+            parts.push([
+                node.path || "",
+                node.type || "",
+                node.is_pinned ? "1" : "0",
+                node.modified_at || "",
+                node.size ?? "",
+            ].join("|"));
+            if (node.children?.length)
+                walk(node.children);
+        });
+    };
+    walk(nodes || []);
+    return parts.join("::");
+}
 function els() {
     return {
         fileList: document.getElementById("workspace-file-list"),
@@ -52,6 +87,13 @@ function els() {
         statusMobile: document.getElementById("workspace-status-mobile"),
         uploadBtn: document.getElementById("workspace-upload"),
         uploadInput: document.getElementById("workspace-upload-input"),
+        mobileMenuToggle: document.getElementById("workspace-mobile-menu-toggle"),
+        mobileDropdown: document.getElementById("workspace-mobile-dropdown"),
+        mobileUpload: document.getElementById("workspace-mobile-upload"),
+        mobileNewFolder: document.getElementById("workspace-mobile-new-folder"),
+        mobileNewFile: document.getElementById("workspace-mobile-new-file"),
+        mobileDownload: document.getElementById("workspace-mobile-download"),
+        mobileGenerate: document.getElementById("workspace-mobile-generate"),
         newFolderBtn: document.getElementById("workspace-new-folder"),
         newFileBtn: document.getElementById("workspace-new-file"),
         downloadAllBtn: document.getElementById("workspace-download-all"),
@@ -143,6 +185,13 @@ function setStatus(text) {
     if (statusMobile)
         statusMobile.textContent = text;
 }
+function setWorkspaceRefreshing(active) {
+    const { reloadBtn, reloadBtnMobile } = els();
+    workspaceRefreshCount = Math.max(0, workspaceRefreshCount + (active ? 1 : -1));
+    const isRefreshing = workspaceRefreshCount > 0;
+    setButtonLoading(reloadBtn, isRefreshing);
+    setButtonLoading(reloadBtnMobile, isRefreshing);
+}
 function renderPatch() {
     const { patchMain, patchBody, patchSummary, patchMeta, textarea, saveBtn, reloadBtn } = els();
     if (!patchMain || !patchBody)
@@ -187,15 +236,33 @@ function renderPatch() {
 function renderChat() {
     workspaceChat.render();
 }
+function closeMobileMenu() {
+    const dropdown = els().mobileDropdown;
+    if (dropdown)
+        dropdown.classList.add("hidden");
+}
+function toggleMobileMenu() {
+    const dropdown = els().mobileDropdown;
+    if (dropdown)
+        dropdown.classList.toggle("hidden");
+}
 function updateDownloadButton() {
-    const { downloadAllBtn } = els();
-    if (!downloadAllBtn)
-        return;
+    const { downloadAllBtn, mobileDownload } = els();
     const currentPath = state.browser?.getCurrentPath() || "";
     const isRoot = !currentPath;
     const folderName = currentPath.split("/").pop() || "";
-    downloadAllBtn.title = isRoot ? "Download all as ZIP" : `Download ${folderName}/ as ZIP`;
-    downloadAllBtn.onclick = () => downloadWorkspaceZip(isRoot ? undefined : currentPath);
+    const download = () => downloadWorkspaceZip(isRoot ? undefined : currentPath);
+    if (downloadAllBtn) {
+        downloadAllBtn.title = isRoot ? "Download all as ZIP" : `Download ${folderName}/ as ZIP`;
+        downloadAllBtn.onclick = download;
+    }
+    if (mobileDownload) {
+        mobileDownload.textContent = isRoot ? "Download ZIP (all)" : `Download ${folderName || "folder"}`;
+        mobileDownload.onclick = () => {
+            closeMobileMenu();
+            download();
+        };
+    }
 }
 let createMode = null;
 function listFolderPaths(nodes, base = "") {
@@ -272,7 +339,7 @@ async function handleCreateSubmit() {
             flash("File created", "success");
         }
         closeCreateModal();
-        await loadFiles(createMode === "file" ? path : state.target?.path || undefined);
+        await loadFiles(createMode === "file" ? path : state.target?.path || undefined, "manual");
         if (createMode === "file") {
             state.browser?.select(path);
         }
@@ -281,12 +348,45 @@ async function handleCreateSubmit() {
         flash(err.message || "Failed to create item", "error");
     }
 }
-async function loadWorkspaceFile(path) {
-    state.loading = true;
-    setStatus("Loading…");
-    try {
-        const text = await readWorkspaceContent(path);
-        state.content = text;
+const workspaceTreeRefresh = createSmartRefresh({
+    getSignature: (payload) => workspaceTreeSignature(payload.tree || []),
+    render: (payload) => {
+        state.files = payload.tree;
+        const { fileList, fileSelect, breadcrumbs } = els();
+        if (!fileList)
+            return;
+        if (!state.browser) {
+            state.browser = new WorkspaceFileBrowser({
+                container: fileList,
+                selectEl: fileSelect,
+                breadcrumbsEl: breadcrumbs,
+                onSelect: (file) => {
+                    state.target = { path: file.path, isPinned: Boolean(file.is_pinned) };
+                    workspaceChat.setTarget(target());
+                    void refreshWorkspaceFile(file.path, "manual");
+                },
+                onPathChange: () => updateDownloadButton(),
+                onRefresh: () => loadFiles(state.target?.path, "manual"),
+                onConfirm: (message) => window.workspaceConfirm?.(message) ?? confirmModal(message),
+            });
+        }
+        const defaultPath = payload.defaultPath ?? state.target?.path ?? undefined;
+        state.browser.setTree(payload.tree, defaultPath || undefined);
+        updateDownloadButton();
+        if (state.target) {
+            workspaceChat.setTarget(target());
+        }
+    },
+    onSkip: () => {
+        updateDownloadButton();
+    },
+});
+const workspaceContentRefresh = createSmartRefresh({
+    getSignature: (payload) => `${payload.path}::${hashString(payload.content || "")}`,
+    render: async (payload, ctx) => {
+        if (payload.path !== state.target?.path)
+            return;
+        state.content = payload.content;
         if (state.docEditor) {
             state.docEditor.destroy();
         }
@@ -298,9 +398,9 @@ async function loadWorkspaceFile(path) {
             textarea,
             saveButton: saveBtn,
             statusEl: status,
-            onLoad: async () => text,
+            onLoad: async () => payload.content,
             onSave: async (content) => {
-                const saved = await writeWorkspaceContent(path, content);
+                const saved = await writeWorkspaceContent(payload.path, content);
                 state.content = saved;
                 if (saved !== content) {
                     textarea.value = saved;
@@ -309,7 +409,25 @@ async function loadWorkspaceFile(path) {
         });
         await loadPendingDraft();
         renderPatch();
-        setStatus("Loaded");
+        if (ctx.reason !== "background") {
+            setStatus("Loaded");
+        }
+    },
+});
+async function refreshWorkspaceFile(path, reason = "manual") {
+    if (!WORKSPACE_REFRESH_REASONS.includes(reason)) {
+        reason = "manual";
+    }
+    const isInitial = reason === "initial";
+    if (isInitial) {
+        state.loading = true;
+        setStatus("Loading…");
+    }
+    else {
+        setWorkspaceRefreshing(true);
+    }
+    try {
+        await workspaceContentRefresh.refresh(async () => ({ path, content: await readWorkspaceContent(path) }), { reason });
     }
     catch (err) {
         const message = err.message || "Failed to load workspace file";
@@ -318,6 +436,9 @@ async function loadWorkspaceFile(path) {
     }
     finally {
         state.loading = false;
+        if (!isInitial) {
+            setWorkspaceRefreshing(false);
+        }
     }
 }
 async function loadPendingDraft() {
@@ -327,7 +448,7 @@ async function loadPendingDraft() {
 async function reloadWorkspace() {
     if (!state.target)
         return;
-    await loadWorkspaceFile(state.target.path);
+    await refreshWorkspaceFile(state.target.path, "manual");
 }
 async function maybeShowGenerate() {
     try {
@@ -340,9 +461,12 @@ async function maybeShowGenerate() {
     catch {
         state.hasTickets = true;
     }
-    const btn = els().generateBtn;
-    if (btn)
-        btn.classList.toggle("hidden", state.hasTickets);
+    const { generateBtn, mobileGenerate } = els();
+    const hidden = state.hasTickets;
+    if (generateBtn)
+        generateBtn.classList.toggle("hidden", hidden);
+    if (mobileGenerate)
+        mobileGenerate.classList.toggle("hidden", hidden);
 }
 async function generateTickets() {
     try {
@@ -360,7 +484,7 @@ async function applyWorkspaceDraft() {
     try {
         const isStale = Boolean(state.draft?.is_stale);
         if (isStale) {
-            const confirmForce = window.confirm("This draft is stale because the file changed after it was created. Force apply anyway?");
+            const confirmForce = await confirmModal("This draft is stale because the file changed after it was created. Force apply anyway?");
             if (!confirmForce)
                 return;
         }
@@ -393,6 +517,138 @@ async function discardWorkspaceDraft() {
         flash(err.message || "Failed to discard draft", "error");
     }
 }
+function clearTurnEventsStream() {
+    if (currentTurnEventsController) {
+        try {
+            currentTurnEventsController.abort();
+        }
+        catch {
+            // ignore
+        }
+        currentTurnEventsController = null;
+    }
+}
+function clearPendingTurnState() {
+    clearTurnEventsStream();
+    clearPendingTurn(WORKSPACE_PENDING_KEY);
+}
+function maybeStartTurnEventsFromUpdate(update) {
+    const meta = update;
+    const threadId = typeof meta.thread_id === "string" ? meta.thread_id : "";
+    const turnId = typeof meta.turn_id === "string" ? meta.turn_id : "";
+    const agent = typeof meta.agent === "string" ? meta.agent : undefined;
+    if (!threadId || !turnId)
+        return;
+    clearTurnEventsStream();
+    currentTurnEventsController = streamTurnEvents({ agent, threadId, turnId }, {
+        onEvent: (event) => {
+            workspaceChat.applyAppEvent(event);
+            workspaceChat.renderEvents();
+            workspaceChat.render();
+        },
+    });
+}
+function applyChatUpdate(update) {
+    const hasDraft = update.has_draft ?? update.hasDraft;
+    if (hasDraft === false) {
+        state.draft = null;
+        if (typeof update.content === "string") {
+            state.content = update.content;
+            const textarea = els().textarea;
+            if (textarea)
+                textarea.value = state.content;
+        }
+        renderPatch();
+    }
+    else if (hasDraft === true || update.patch || update.content) {
+        state.draft = {
+            target: target(),
+            content: update.content || "",
+            patch: update.patch || "",
+            agent_message: update.agent_message,
+            created_at: update.created_at,
+            base_hash: update.base_hash,
+            current_hash: update.current_hash,
+            is_stale: Boolean(update.is_stale),
+        };
+        renderPatch();
+    }
+    if (update.message || update.agent_message) {
+        const text = update.message || update.agent_message || "";
+        if (text)
+            workspaceChat.addAssistantMessage(text);
+    }
+    workspaceChat.render();
+}
+function applyFinalResult(result) {
+    const chatState = workspaceChat.state;
+    const status = String(result.status || "");
+    if (status === "ok") {
+        applyChatUpdate(result);
+        chatState.status = "done";
+        chatState.error = "";
+        chatState.streamText = "";
+        clearPendingTurnState();
+        renderChat();
+        return;
+    }
+    if (status === "error") {
+        const detail = String(result.detail || "Chat failed");
+        chatState.status = "error";
+        chatState.error = detail;
+        renderChat();
+        flash(detail, "error");
+        clearPendingTurnState();
+        return;
+    }
+    if (status === "interrupted") {
+        chatState.status = "interrupted";
+        chatState.error = "";
+        chatState.streamText = "";
+        renderChat();
+        clearPendingTurnState();
+    }
+}
+async function resumePendingWorkspaceTurn() {
+    const pending = loadPendingTurn(WORKSPACE_PENDING_KEY);
+    if (!pending)
+        return;
+    const chatState = workspaceChat.state;
+    chatState.status = "running";
+    chatState.statusText = "Recovering previous turn…";
+    workspaceChat.render();
+    workspaceChat.renderMessages();
+    try {
+        const outcome = await resumeFileChatTurn(pending.clientTurnId, {
+            onEvent: (event) => {
+                workspaceChat.applyAppEvent(event);
+                workspaceChat.renderEvents();
+                workspaceChat.render();
+            },
+            onResult: (result) => applyFinalResult(result),
+            onError: (msg) => {
+                chatState.statusText = msg;
+                renderChat();
+            },
+        });
+        currentTurnEventsController = outcome.controller;
+        if (outcome.lastResult && outcome.lastResult.status) {
+            applyFinalResult(outcome.lastResult);
+            return;
+        }
+        // If still running but no event stream yet, poll again shortly.
+        if (!outcome.controller) {
+            window.setTimeout(() => {
+                void resumePendingWorkspaceTurn();
+            }, 1000);
+        }
+    }
+    catch (err) {
+        const msg = err.message || "Failed to resume turn";
+        chatState.statusText = msg;
+        renderChat();
+    }
+}
 async function sendChat() {
     const { chatInput, chatSend, chatCancel } = els();
     const message = (chatInput?.value || "").trim();
@@ -407,6 +663,7 @@ async function sendChat() {
     chatState.error = "";
     chatState.statusText = "queued";
     chatState.streamText = "";
+    chatState.contextUsagePercent = null;
     workspaceChat.clearEvents();
     workspaceChat.addUserMessage(message);
     renderChat();
@@ -414,6 +671,14 @@ async function sendChat() {
         chatInput.value = "";
     chatSend?.setAttribute("disabled", "true");
     chatCancel?.classList.remove("hidden");
+    clearTurnEventsStream();
+    const clientTurnId = newClientTurnId("workspace");
+    savePendingTurn(WORKSPACE_PENDING_KEY, {
+        clientTurnId,
+        message,
+        startedAtMs: Date.now(),
+        target: target(),
+    });
     const agent = getSelectedAgent();
     const model = getSelectedModel(agent) || undefined;
     const reasoning = getSelectedReasoning(agent) || undefined;
@@ -432,43 +697,20 @@ async function sendChat() {
                 workspaceChat.applyAppEvent(event);
                 workspaceChat.renderEvents();
             },
-            onUpdate: (update) => {
-                const hasDraft = update.has_draft ?? update.hasDraft;
-                if (hasDraft === false) {
-                    chatState.draft = null;
-                    if (typeof update.content === "string") {
-                        state.content = update.content;
-                        const textarea = els().textarea;
-                        if (textarea)
-                            textarea.value = state.content;
-                    }
-                    renderPatch();
-                }
-                else if (hasDraft === true || update.patch || update.content) {
-                    state.draft = {
-                        target: target(),
-                        content: update.content || "",
-                        patch: update.patch || "",
-                        agent_message: update.agent_message,
-                        created_at: update.created_at,
-                        base_hash: update.base_hash,
-                        current_hash: update.current_hash,
-                        is_stale: Boolean(update.is_stale),
-                    };
-                    renderPatch();
-                }
-                if (update.message || update.agent_message) {
-                    const text = update.message || update.agent_message || "";
-                    if (text)
-                        workspaceChat.addAssistantMessage(text);
-                }
+            onTokenUsage: (percent) => {
+                chatState.contextUsagePercent = percent;
                 renderChat();
             },
+            onUpdate: (update) => {
+                applyChatUpdate(update);
+                maybeStartTurnEventsFromUpdate(update);
+            },
             onError: (msg) => {
                 chatState.status = "error";
                 chatState.error = msg;
                 renderChat();
                 flash(msg, "error");
+                clearPendingTurnState();
             },
             onInterrupted: (msg) => {
                 chatState.status = "interrupted";
@@ -476,6 +718,7 @@ async function sendChat() {
                 chatState.streamText = "";
                 renderChat();
                 flash(msg, "info");
+                clearPendingTurnState();
             },
             onDone: () => {
                 if (chatState.streamText) {
@@ -484,8 +727,9 @@ async function sendChat() {
                 }
                 chatState.status = "done";
                 renderChat();
+                clearPendingTurnState();
             },
-        }, { agent, model, reasoning });
+        }, { agent, model, reasoning, clientTurnId });
     }
     catch (err) {
         const msg = err.message || "Chat failed";
@@ -494,6 +738,7 @@ async function sendChat() {
         chatStateLocal.error = msg;
         renderChat();
         flash(msg, "error");
+        clearPendingTurnState();
     }
     finally {
         chatSend?.removeAttribute("disabled");
@@ -515,7 +760,9 @@ async function cancelChat() {
     }
     chatState.status = "interrupted";
     chatState.streamText = "";
+    chatState.contextUsagePercent = null;
     renderChat();
+    clearPendingTurnState();
 }
 async function resetThread() {
     if (!state.target)
@@ -528,7 +775,9 @@ async function resetThread() {
         const chatState = workspaceChat.state;
         chatState.messages = [];
         chatState.streamText = "";
+        chatState.contextUsagePercent = null;
         workspaceChat.clearEvents();
+        clearPendingTurnState();
         renderChat();
         flash("New workspace chat thread", "success");
     }
@@ -536,36 +785,25 @@ async function resetThread() {
         flash(err.message || "Failed to reset thread", "error");
     }
 }
-async function loadFiles(defaultPath) {
-    const tree = await fetchWorkspaceTree();
-    state.files = tree;
-    const { fileList, fileSelect, breadcrumbs } = els();
-    if (!fileList)
-        return;
-    if (!state.browser) {
-        state.browser = new WorkspaceFileBrowser({
-            container: fileList,
-            selectEl: fileSelect,
-            breadcrumbsEl: breadcrumbs,
-            onSelect: (file) => {
-                state.target = { path: file.path, isPinned: Boolean(file.is_pinned) };
-                workspaceChat.setTarget(target());
-                void loadWorkspaceFile(file.path);
-            },
-            onPathChange: () => updateDownloadButton(),
-            onRefresh: () => loadFiles(state.target?.path),
-            onConfirm: (message) => window.workspaceConfirm?.(message) ??
-                Promise.resolve(confirm(message)),
-        });
+async function loadFiles(defaultPath, reason = "manual") {
+    if (!WORKSPACE_REFRESH_REASONS.includes(reason)) {
+        reason = "manual";
+    }
+    const isInitial = reason === "initial";
+    if (!isInitial) {
+        setWorkspaceRefreshing(true);
     }
-    state.browser.setTree(tree, defaultPath || state.target?.path || undefined);
-    updateDownloadButton();
-    if (state.target) {
-        workspaceChat.setTarget(target());
+    try {
+        await workspaceTreeRefresh.refresh(async () => ({ tree: await fetchWorkspaceTree(), defaultPath }), { reason });
+    }
+    finally {
+        if (!isInitial) {
+            setWorkspaceRefreshing(false);
+        }
     }
 }
 export async function initWorkspace() {
-    const { generateBtn, uploadBtn, uploadInput, newFolderBtn, saveBtn, saveBtnMobile, reloadBtn, reloadBtnMobile, patchApply, patchDiscard, patchReload, chatSend, chatCancel, chatNewThread, } = els();
+    const { generateBtn, uploadBtn, uploadInput, mobileMenuToggle, mobileDropdown, mobileUpload, mobileNewFolder, mobileNewFile, mobileDownload, mobileGenerate, newFolderBtn, saveBtn, saveBtnMobile, reloadBtn, reloadBtnMobile, patchApply, patchDiscard, patchReload, chatSend, chatCancel, chatNewThread, } = els();
     if (!document.getElementById("workspace"))
         return;
     initAgentControls({
@@ -578,10 +816,11 @@ export async function initWorkspace() {
         inputId: "workspace-chat-input",
     });
     await maybeShowGenerate();
-    await loadFiles();
+    await loadFiles(undefined, "initial");
     workspaceChat.setTarget(target());
+    void resumePendingWorkspaceTurn();
     const reloadEverything = async () => {
-        await loadFiles(state.target?.path);
+        await loadFiles(state.target?.path, "manual");
         await reloadWorkspace();
     };
     saveBtn?.addEventListener("click", () => void state.docEditor?.save(true));
@@ -597,7 +836,7 @@ export async function initWorkspace() {
         try {
             await uploadWorkspaceFiles(files, subdir || undefined);
             flash(`Uploaded ${files.length} file${files.length === 1 ? "" : "s"}`, "success");
-            await loadFiles(state.target?.path);
+            await loadFiles(state.target?.path, "manual");
         }
         catch (err) {
             flash(err.message || "Upload failed", "error");
@@ -606,6 +845,54 @@ export async function initWorkspace() {
             uploadInput.value = "";
         }
     });
+    // Mobile action sheet
+    const handleMobileToggle = (evt) => {
+        evt.preventDefault();
+        evt.stopPropagation();
+        toggleMobileMenu();
+    };
+    mobileMenuToggle?.addEventListener("pointerdown", handleMobileToggle);
+    mobileMenuToggle?.addEventListener("click", (evt) => {
+        evt.preventDefault(); // swallow synthetic click after pointerdown
+    });
+    mobileMenuToggle?.addEventListener("keydown", (evt) => {
+        if (evt.key === "Enter" || evt.key === " ") {
+            handleMobileToggle(evt);
+        }
+    });
+    document.addEventListener("pointerdown", (evt) => {
+        if (!mobileDropdown || mobileDropdown.classList.contains("hidden"))
+            return;
+        if (evt.target instanceof Node && mobileDropdown.contains(evt.target))
+            return;
+        closeMobileMenu();
+    });
+    document.addEventListener("keydown", (evt) => {
+        if (evt.key === "Escape" && mobileDropdown && !mobileDropdown.classList.contains("hidden")) {
+            closeMobileMenu();
+        }
+    });
+    mobileUpload?.addEventListener("click", () => {
+        closeMobileMenu();
+        uploadInput?.click();
+    });
+    mobileNewFolder?.addEventListener("click", () => {
+        closeMobileMenu();
+        openCreateModal("folder");
+    });
+    mobileNewFile?.addEventListener("click", () => {
+        closeMobileMenu();
+        openCreateModal("file");
+    });
+    mobileDownload?.addEventListener("click", () => {
+        closeMobileMenu();
+        const currentPath = state.browser?.getCurrentPath() || "";
+        downloadWorkspaceZip(currentPath || undefined);
+    });
+    mobileGenerate?.addEventListener("click", () => {
+        closeMobileMenu();
+        void generateTickets();
+    });
     newFolderBtn?.addEventListener("click", () => openCreateModal("folder"));
     els().newFileBtn?.addEventListener("click", () => openCreateModal("file"));
     generateBtn?.addEventListener("click", () => void generateTickets());
@@ -623,6 +910,13 @@ export async function initWorkspace() {
                 void sendChat();
             }
         });
+        initChatPasteUpload({
+            textarea: chatInput,
+            basePath: "/api/filebox",
+            box: "inbox",
+            insertStyle: "both",
+            pathPrefix: ".codex-autorunner/filebox",
+        });
     }
     const { createModal, createClose, createCancel, createSubmit } = els();
     createClose?.addEventListener("click", () => closeCreateModal());
@@ -669,4 +963,17 @@ export async function initWorkspace() {
         if (evt.target === confirmModal)
             closeConfirm(false);
     });
+    subscribe("repo:health", (payload) => {
+        const status = payload?.status || "";
+        if (status !== "ok" && status !== "degraded")
+            return;
+        if (!isRepoHealthy())
+            return;
+        void loadFiles(state.target?.path, "background");
+        const textarea = els().textarea;
+        const hasLocalEdits = textarea ? textarea.value !== state.content : false;
+        if (state.target && !state.draft && !hasLocalEdits) {
+            void refreshWorkspaceFile(state.target.path, "background");
+        }
+    });
 }