taskchef 7.18.0 → 7.19.0

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "taskchef",
-  "version": "7.18.0",
+  "version": "7.19.0",
   "description": "Dispatch work from a data-only workspace to visible Codex project tasks.",
   "author": {
     "name": "Favo Yang",

package/README.md

@@ -263,6 +263,12 @@ The loopback dashboard watches `tasks.jsonl`, groups current states, and opens
 linked Codex tasks. List snapshots and SSE events carry only the latest
 request/result pair; opening task details fetches the full newest-first activity
 timeline, including clearly labeled interrupted turns.
+Task details also offer **Archive chat** for every linked task whose current
+TaskChef state is not `working`. After confirmation, TaskChef invokes only the
+Codex CLI at the canonical ChatGPT or Codex desktop app location under
+`/Applications`, to archive the exact thread UUID. The Codex chat leaves active chat lists while the TaskChef record
+and its activity timeline remain unchanged. If the bundled CLI is unavailable,
+the dashboard does not fall back to another `codex` executable from `PATH`.
 The header shows the running TaskChef package version reported by the same
 bounded health identity used for compatible-listener checks.
 Task and result times are relative through 29 days (with minute detail for the

package/docs/spec.md

@@ -427,6 +427,17 @@ startup safely. Direct thread navigation
 MUST require a canonical Codex UUIDv7. Otherwise it MAY open the revalidated
 configured project. Project paths from task history MUST be matched against
 current configuration before use.
+The task-detail dashboard MAY offer Codex chat archival only when the stored
+thread ID is a canonical Codex UUID and the current TaskChef state is not
+`working`. It MUST revalidate both conditions for the POST request, require the
+exact loopback origin, and obtain explicit user confirmation in the browser.
+It MUST invoke the `archive` subcommand by directly executing only a Codex CLI
+inside the canonical ChatGPT or Codex desktop application bundle under macOS
+`/Applications`, with the thread UUID as a separate argument. It MUST NOT use a shell, a generic `PATH` fallback, a
+private desktop endpoint, or direct session-file manipulation. Successful
+archival MUST NOT modify dispatcher files or remove the TaskChef task record.
+The UI MUST disclose that spawned descendant chats may also be archived and
+that TaskChef history remains available.
 Snapshot and SSE list payloads MUST omit full `turns` and derived `results`
 history and include `latestTurn`. The bounded per-task detail endpoint MAY
 return the full validated task so the dialog can render the paired timeline newest first.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taskchef",
-  "version": "7.18.0",
+  "version": "7.19.0",
   "description": "A non-blocking interactive dispatcher for visible Codex tasks.",
   "license": "MIT",
   "author": "Favo Yang",

package/src/codex-app.js

@@ -1,14 +1,21 @@
 import { execFile as execFileCallback } from "node:child_process";
-import { access } from "node:fs/promises";
+import { access, realpath } from "node:fs/promises";
 import path from "node:path";
 import { promisify } from "node:util";
 
+import { normalizeCodexThreadId } from "./delegation.js";
+
 const execFile = promisify(execFileCallback);
 const CODEX_COMMAND_TIMEOUT_MS = 10_000;
-const CODEX_THREAD_ID_PATTERN = /^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i;
+const CODEX_ARCHIVE_TIMEOUT_MS = 4_000;
+const CODEX_COMMAND_MAX_BUFFER_BYTES = 64 * 1024;
 
-function runCodex(run, filePath, args) {
-  return run(filePath, args, { timeout: CODEX_COMMAND_TIMEOUT_MS, killSignal: "SIGKILL" });
+function runCodex(run, filePath, args, timeout = CODEX_COMMAND_TIMEOUT_MS) {
+  return run(filePath, args, {
+    timeout,
+    killSignal: "SIGKILL",
+    maxBuffer: CODEX_COMMAND_MAX_BUFFER_BYTES,
+  });
 }
 
 async function executable(filePath) {
@@ -20,15 +27,29 @@ async function executable(filePath) {
   }
 }
 
-function pathCandidates(env) {
+function pathCandidates(env, platform = process.platform) {
   return (env.PATH ?? "")
     .split(path.delimiter)
     .filter(Boolean)
-    .map((directory) => path.join(directory, process.platform === "win32" ? "codex.exe" : "codex"));
+    .map((directory) => path.join(directory, platform === "win32" ? "codex.exe" : "codex"));
 }
 
 function isDesktopBundleCandidate(filePath) {
-  return filePath.includes(`${path.sep}Contents${path.sep}Resources${path.sep}`);
+  if (path.basename(filePath) !== "codex") return false;
+  const resources = path.dirname(filePath);
+  const contents = path.dirname(resources);
+  const application = path.dirname(contents);
+  return path.basename(resources) === "Resources"
+    && path.basename(contents) === "Contents"
+    && new Set(["ChatGPT.app", "Codex.app"]).has(path.basename(application));
+}
+
+function defaultDesktopBundleCandidates(_env, platform) {
+  if (platform !== "darwin") return [];
+  return [
+    "/Applications/ChatGPT.app/Contents/Resources/codex",
+    "/Applications/Codex.app/Contents/Resources/codex",
+  ];
 }
 
 async function supportsAppCommand(filePath, run) {
@@ -40,6 +61,37 @@ async function supportsAppCommand(filePath, run) {
   }
 }
 
+async function supportsArchiveCommand(filePath, run) {
+  try {
+    const { stdout, stderr } = await runCodex(run, filePath, ["archive", "--help"]);
+    return /(?:^|\n)Usage:\s+codex\s+archive(?:\s|$)/.test(`${stdout}\n${stderr}`);
+  } catch {
+    return false;
+  }
+}
+
+export async function discoverBundledCodexCli({
+  candidates = null,
+  env = process.env,
+  platform = process.platform,
+  run = execFile,
+  trustedBundlePaths = null,
+} = {}) {
+  const trustedPaths = trustedBundlePaths ?? defaultDesktopBundleCandidates(env, platform);
+  const trustedCandidates = new Set(trustedPaths.map((candidate) => path.resolve(candidate)));
+  const bundledCandidates = candidates ?? trustedPaths;
+  for (const filePath of new Set(bundledCandidates.map((candidate) => path.resolve(candidate)))) {
+    const executableCandidate = await executable(filePath);
+    const candidate = executableCandidate === null ? null : await realpath(executableCandidate);
+    if (platform === "darwin" && candidate && trustedCandidates.has(candidate)
+      && isDesktopBundleCandidate(candidate)
+      && await supportsArchiveCommand(candidate, run)) {
+      return { path: candidate, source: "desktop-bundle" };
+    }
+  }
+  throw new Error("Chat archiving requires the Codex CLI bundled with the ChatGPT or Codex desktop app");
+}
+
 export async function discoverCodexCli({
   explicit = null,
   env = process.env,
@@ -56,7 +108,7 @@ export async function discoverCodexCli({
   }
 
   const candidates = pathCandidates(env);
-  for (const pathCandidate of candidates.filter(isDesktopBundleCandidate)) {
+  for (const pathCandidate of candidates.filter((candidate) => isDesktopBundleCandidate(candidate))) {
     const candidate = await executable(pathCandidate);
     if (candidate && await supportsAppCommand(candidate, run)) {
       return { path: candidate, source: "desktop-path" };
@@ -89,7 +141,12 @@ export async function openWorkspaceInCodex(workspace, options = {}) {
 }
 
 export function isCodexThreadDeepLinkId(threadId) {
-  return typeof threadId === "string" && CODEX_THREAD_ID_PATTERN.test(threadId);
+  try {
+    normalizeCodexThreadId(threadId);
+    return true;
+  } catch {
+    return false;
+  }
 }
 
 export async function openThreadInCodex(threadId, options = {}) {
@@ -108,3 +165,24 @@ export async function openThreadInCodex(threadId, options = {}) {
   }
   return { status: "requested", mechanism: "codex-deep-link", threadId, url };
 }
+
+export async function archiveThreadInCodex(threadId, options = {}) {
+  if (!isCodexThreadDeepLinkId(threadId)) {
+    throw new Error("Codex thread ID is not supported by chat archiving");
+  }
+  const run = options.run ?? execFile;
+  const cli = options.cli ?? await discoverBundledCodexCli({ run });
+  await runCodex(
+    run,
+    cli.path,
+    ["archive", threadId],
+    options.timeoutMs ?? CODEX_ARCHIVE_TIMEOUT_MS,
+  );
+  return {
+    status: "archived",
+    mechanism: "codex-archive-cli",
+    codexCli: cli.path,
+    codexCliSource: cli.source,
+    threadId,
+  };
+}

package/src/dashboard/actions.js

@@ -15,3 +15,41 @@ export async function openTaskFromControl(event, taskId, {
     control.disabled = false;
   }
 }
+
+export async function archiveTaskFromControl(event, task, {
+  confirmAction = globalThis.confirm,
+  fetchAction = globalThis.fetch,
+  onArchived = () => {},
+  showMessage,
+} = {}) {
+  event.stopPropagation();
+  const accepted = confirmAction(
+    `Archive “${task.title}” in Codex?\n\n`
+    + "The chat will leave active Codex lists, and spawned descendant chats may also be archived. "
+    + "TaskChef history will remain available.",
+  );
+  if (!accepted) return false;
+  const control = event.currentTarget;
+  let archived = false;
+  control.disabled = true;
+  try {
+    const response = await fetchAction(
+      `/api/tasks/${encodeURIComponent(task.id)}/archive-codex`,
+      { method: "POST" },
+    );
+    const result = await response.json();
+    if (!response.ok) {
+      showMessage(result.message ?? "Codex could not archive this chat.");
+      return false;
+    }
+    onArchived(task.threadId);
+    archived = true;
+    showMessage(result.message ?? "Archived the Codex chat. TaskChef history remains available.");
+    return true;
+  } catch {
+    showMessage("Codex chat archiving is temporarily unavailable. Try again.");
+    return false;
+  } finally {
+    if (!archived) control.disabled = false;
+  }
+}

package/src/dashboard/app.js

@@ -1,4 +1,5 @@
 import {
+  canArchiveTask,
   clearNotifications,
   dismissNotification,
   filterTasks,
@@ -15,7 +16,7 @@ import {
   taskStatusLabel,
   turnPresentation,
 } from "./state.js";
-import { openTaskFromControl } from "./actions.js";
+import { archiveTaskFromControl, openTaskFromControl } from "./actions.js";
 import {
   githubReferenceAccessibleLabel,
   githubReferenceDisplayLabels,
@@ -25,6 +26,7 @@ import {
 import { formatRelativeTime, RelativeTimeController, parsedTimestamp } from "./time.js";
 
 const state = {
+  archivedThreadIds: new Set(),
   tasks: [],
   signatures: new Map(),
   notifications: [],
@@ -39,6 +41,7 @@ let copyTaskIdTimer = null;
 const relativeTimes = new RelativeTimeController();
 
 const elements = {
+  archiveTask: document.querySelector("#archive-codex"),
   clearNotifications: document.querySelector("#clear-notifications"),
   closeDialog: document.querySelector("#close-dialog"),
   connectionDot: document.querySelector("#connection-dot"),
@@ -446,6 +449,15 @@ function renderDialog(task) {
     ...detailRow("Updated by", task.updatedBy),
   );
   configureOpenTaskControl(elements.openProject, `Open ${task.title} in Codex`);
+  const canArchive = canArchiveTask(task);
+  const archived = state.archivedThreadIds.has(task.threadId);
+  elements.archiveTask.hidden = !canArchive;
+  elements.archiveTask.disabled = archived;
+  elements.archiveTask.textContent = archived ? "Archived" : "Archive chat";
+  elements.archiveTask.setAttribute(
+    "aria-label",
+    archived ? `${task.title} is archived in Codex` : `Archive ${task.title} in Codex`,
+  );
 }
 
 async function openDialog(task) {
@@ -652,3 +664,14 @@ elements.openProject.addEventListener("click", async (event) => {
   if (!state.selectedTask) return;
   await openTaskFromControl(event, state.selectedTask.id, { showMessage });
 });
+elements.archiveTask.addEventListener("click", async (event) => {
+  const task = state.selectedTask;
+  if (!task || !canArchiveTask(task)) return;
+  await archiveTaskFromControl(event, task, {
+    onArchived: (threadId) => {
+      state.archivedThreadIds.add(threadId);
+      if (state.selectedTask?.id === task.id) renderDialog(state.selectedTask);
+    },
+    showMessage,
+  });
+});

package/src/dashboard/index.html

@@ -113,6 +113,7 @@
           <span>Open task</span>
         </button>
         <button id="copy-task-id" class="secondary-button" type="button" aria-label="Copy Task ID">Copy Task ID</button>
+        <button id="archive-codex" class="danger-button" type="button" aria-label="Archive this chat in Codex" hidden>Archive chat</button>
       </div>
       <nav id="dialog-related-links" class="github-links" aria-label="Related GitHub links" hidden></nav>
       <section>

package/src/dashboard/state.js

@@ -13,6 +13,7 @@ export const STATUS_FILTERS = [
   { value: "completed", label: "Completed" },
   { value: "failed", label: "Failed" },
 ];
+const CODEX_THREAD_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 
 const NOTIFICATION_TITLES = new Map([
   ["created", "Task created"],
@@ -38,6 +39,12 @@ export function taskStatusLabel(task) {
   return task.status === null ? "unresolved" : task.status.replaceAll("_", " ");
 }
 
+export function canArchiveTask(task) {
+  return task.status !== "working"
+    && typeof task.threadId === "string"
+    && CODEX_THREAD_ID_PATTERN.test(task.threadId);
+}
+
 export function latestTurnPresentation(task) {
   const turn = task.latestTurn ?? null;
   const result = turn?.result ?? null;

package/src/dashboard/styles.css

@@ -149,10 +149,11 @@ dialog::backdrop { background: rgb(18 23 21 / 50%); backdrop-filter: blur(2px);
 .dialog-header { display: flex; align-items: flex-start; justify-content: space-between; gap: 20px; }
 .dialog-header h2 { margin-bottom: 12px; font-size: 1.6rem; }
 .dialog-actions { display: flex; gap: 8px; margin-bottom: 26px; }
-.primary-button, .secondary-button { padding: 8px 12px; border-radius: 7px; font-weight: 700; cursor: pointer; }
+.primary-button, .secondary-button, .danger-button { padding: 8px 12px; border-radius: 7px; font-weight: 700; cursor: pointer; }
 .primary-button { border: 1px solid var(--accent); background: var(--accent); color: white; }
 .secondary-button { border: 1px solid var(--border); background: var(--surface); }
-.primary-button:disabled, .secondary-button:disabled { opacity: 0.5; cursor: not-allowed; }
+.danger-button { border: 1px solid var(--danger); background: var(--surface); color: var(--danger); }
+.primary-button:disabled, .secondary-button:disabled, .danger-button:disabled { opacity: 0.5; cursor: not-allowed; }
 dialog section + section { margin-top: 24px; }
 .preserve-lines { white-space: pre-wrap; }
 .result-history { display: grid; gap: 10px; }

package/src/dashboard.js

@@ -6,15 +6,19 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 
 import {
+  archiveThreadInCodex,
+  discoverBundledCodexCli,
   isCodexThreadDeepLinkId,
   openThreadInCodex,
   openWorkspaceInCodex,
 } from "./codex-app.js";
 import {
+  acquireWorkspaceLock,
   canonicalDirectory,
   canonicalGitRoot,
   parseTaskLogContent,
   readConfig,
+  readTask,
 } from "./workspace.js";
 import { DASHBOARD_SERVER_VERSION, TASKCHEF_VERSION } from "./version.js";
 import { taskGitHubProjection } from "./dashboard/github-links.js";
@@ -439,6 +443,8 @@ function publicMonitorError() {
 }
 
 export async function createDashboardServer({
+  archiveThread = archiveThreadInCodex,
+  discoverArchiveCli = discoverBundledCodexCli,
   workspace,
   host = "127.0.0.1",
   maxEventClients = DEFAULT_MAX_EVENT_CLIENTS,
@@ -472,6 +478,7 @@ export async function createDashboardServer({
     throw new Error("dashboard identity exceeds the health response limit");
   }
   const clients = new Set();
+  const archiveRequests = new Set();
   let allowedAuthority;
   let allowedOrigin;
 
@@ -617,6 +624,77 @@ export async function createDashboardServer({
       return;
     }
 
+    const archiveMatch = url.pathname.match(/^\/api\/tasks\/([a-zA-Z0-9._-]+)\/archive-codex$/);
+    if (archiveMatch && method === "POST") {
+      if (request.headers.origin !== allowedOrigin) {
+        sendJson(response, 403, { message: "Dashboard origin validation failed." });
+        return;
+      }
+      const taskId = archiveMatch[1];
+      const visibleTask = monitor.tasks.find((candidate) => candidate.id === taskId);
+      if (!visibleTask) {
+        sendJson(response, 404, { message: "Task not found." });
+        return;
+      }
+      if (!isCodexThreadDeepLinkId(visibleTask.threadId)) {
+        sendJson(response, 409, { message: "This task does not have an archivable Codex chat." });
+        return;
+      }
+      if (visibleTask.status === "working") {
+        sendJson(response, 409, { message: "Working tasks cannot be archived from the dashboard." });
+        return;
+      }
+      if (archiveRequests.has(taskId)) {
+        sendJson(response, 409, { message: "This Codex chat is already being archived." });
+        return;
+      }
+      archiveRequests.add(taskId);
+      let releaseWorkspaceLock = null;
+      try {
+        const cli = await discoverArchiveCli();
+        releaseWorkspaceLock = await acquireWorkspaceLock(monitor.workspace);
+        let task;
+        try {
+          task = await readTask(monitor.workspace, taskId);
+        } catch (error) {
+          if (/^task not found:/.test(error?.message ?? "")) {
+            sendJson(response, 404, { message: "Task not found." });
+            return;
+          }
+          throw error;
+        }
+        if (!isCodexThreadDeepLinkId(task.threadId)) {
+          sendJson(response, 409, { message: "This task does not have an archivable Codex chat." });
+          return;
+        }
+        if (task.status === "working") {
+          sendJson(response, 409, { message: "Working tasks cannot be archived from the dashboard." });
+          return;
+        }
+        await archiveThread(task.threadId, { cli, timeoutMs: 4_000 });
+        sendJson(response, 200, {
+          message: "Archived the Codex chat. TaskChef history remains available.",
+          status: "archived",
+        });
+      } catch (error) {
+        if (error?.killed || error?.code === "ETIMEDOUT") {
+          sendJson(response, 504, { message: "Codex chat archiving timed out. Try again." });
+        } else if (/requires the Codex CLI bundled/i.test(error?.message ?? "")) {
+          sendJson(response, 503, {
+            message: "Chat archiving requires the Codex CLI bundled with the ChatGPT or Codex desktop app.",
+          });
+        } else {
+          sendJson(response, 409, {
+            message: "Codex could not archive this chat. It may be active, already archived, or stored on another host or profile.",
+          });
+        }
+      } finally {
+        await releaseWorkspaceLock?.();
+        archiveRequests.delete(taskId);
+      }
+      return;
+    }
+
     if (method === "POST") {
       sendJson(response, 404, { message: "Not found." });
       return;

package/src/version.js

@@ -4,4 +4,4 @@ const require = createRequire(import.meta.url);
 const packageMetadata = require("../package.json");
 
 export const TASKCHEF_VERSION = packageMetadata.version;
-export const DASHBOARD_SERVER_VERSION = "1";
+export const DASHBOARD_SERVER_VERSION = "2";