taskchef 7.18.0 → 7.19.1

package/.codex-plugin/plugin.json

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

package/README.md

@@ -263,8 +263,19 @@ 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.
+The canonical port is owned by a dashboard initialized in the TaskChef MCP host
+before its tool transport connects. Health identity records an `mcp` launcher,
+and MCP recovery reuses only another exact-compatible MCP-launched dashboard;
+a foreground `taskchef dashboard` process is intentionally standalone so its
+child commands cannot silently inherit an agent-shell sandbox.
 Task and result times are relative through 29 days (with minute detail for the
 first six hours), then use a locale-aware calendar date. Each time is a keyboard-
 accessible toggle for its full locale-aware date and time, and one shared
@@ -275,16 +286,17 @@ revision, so reconnects and non-semantic rewrites do not replay a notice and a
 later task state cannot rewrite an older notice. A notice remains readable if
 its task disappears; selecting it then explains that current details are no
 longer available.
-It does not mutate TaskChef data and prints its local URL.
-When a compatible foreground dashboard already owns port 3210,
-`ensure_dashboard` reuses it but does not take ownership. If an unknown,
-different-workspace, or stale-version process owns the port, TaskChef reports a
-concise conflict and never kills or replaces that process. The foreground CLI
-similarly asks you to stop the listener or choose another `--port`.
+It does not mutate TaskChef data and prints its local URL. A foreground
+dashboard identifies itself as standalone and is never reused on the canonical
+MCP port. If a standalone, unknown, different-workspace, or stale-version
+process owns port 3210, TaskChef reports a concise conflict and never kills or
+replaces that process. The foreground CLI similarly asks you to stop the
+listener or choose another `--port`.
 
 The health endpoint contains only a fixed service marker, health schema,
-TaskChef version, dashboard-server version, and canonical workspace. It exposes
-no task data, credentials, environment variables, process control, or secrets.
+TaskChef version, dashboard-server version, canonical workspace, and launcher.
+It exposes no task data, credentials, environment variables, process control,
+or secrets.
 
 ![TaskChef dashboard identity and version](docs/images/dashboard-identity.jpg)
 
@@ -345,13 +357,15 @@ does not necessarily reload Codex. Then run `$taskchef-dashboard` (or call
 
 - the expected released TaskChef version;
 - the expected dashboard protocol `serverVersion`;
+- the `mcp` dashboard launcher;
 - the canonical TaskChef workspace path;
 - the canonical `http://127.0.0.1:3210/` URL.
 
 The release-install sequence is therefore: install plugin, activate or reload
 the new MCP process, ensure the dashboard, then verify TaskChef version,
-protocol `serverVersion`, canonical workspace, and URL. Exact-compatible
-servers may be reused; unknown listeners remain untouched.
+protocol `serverVersion`, `mcp` launcher, canonical workspace, and URL.
+Exact-compatible MCP servers may be reused; standalone and unknown listeners
+remain untouched.
 
 ## Development
 

package/docs/spec.md

@@ -121,13 +121,16 @@ fields MUST NOT change after recording.
 
 ## Required lifecycle
 
-When the canonical TaskChef MCP server finishes connecting, it MUST invoke the
-same serialized dashboard ensure path once by default. It MUST read the
+Before the canonical TaskChef MCP server connects and exposes its transport, it
+MUST invoke the same serialized dashboard ensure path once by default. It MUST read the
 canonical configuration and skip this only for explicit
 `dashboard.autostart: false`. Initialization failures, invalid workspace state,
 port conflicts, and dashboard errors MUST NOT prevent tool registration or MCP
 availability. They MUST emit only a bounded non-sensitive diagnostic through
 the MCP process logging channel. MCP initialization MUST NOT open a browser.
+If transport connection fails after dashboard startup, the MCP server MUST
+best-effort close both its owned dashboard and partially attached transport,
+then propagate the original connection failure even when cleanup also fails.
 
 At the start of every dispatcher turn, the dispatcher SHOULD call
 `ensure_dashboard` best-effort. Failure MUST NOT block direct TaskChef answers,
@@ -228,6 +231,7 @@ HTTP server; it does not mutate dispatcher workspace files.
 ```text
 { dashboard: {
   action: "started" | "reused",
+  launcher: "mcp",
   url: "http://127.0.0.1:3210/",
   workspace: string,
   taskchefVersion: string,
@@ -235,20 +239,22 @@ HTTP server; it does not mutate dispatcher workspace files.
 } }
 ```
 
-Calls MUST serialize within one MCP process. The first call starts an owned
-dashboard or reuses an exact compatible listener; later and concurrent calls
-are idempotent and report reuse after the single start. The stable default MUST
+MCP initialization MUST complete its best-effort dashboard start before exposing
+the MCP transport. Calls MUST serialize within one MCP process. The first call
+starts an owned dashboard or reuses an exact compatible MCP-launched listener;
+later and concurrent calls are idempotent and report reuse after the single start. The stable default MUST
 bind only to `127.0.0.1:3210` and MUST NOT accept a model-supplied workspace,
 host, or port.
 
 Before reuse, TaskChef MUST query a bounded loopback identity endpoint and
 require the exact fixed service/schema, TaskChef version, dashboard-server
-version, and canonical workspace. An unknown, malformed, different-workspace,
-or stale-version listener MUST produce a concise actionable conflict. TaskChef
+version, canonical workspace, and `mcp` launcher identity. A standalone,
+unknown, malformed, different-workspace, or stale-version listener MUST produce a concise actionable conflict. TaskChef
 MUST NOT kill, replace, signal, or otherwise control that listener. A startup
 failure MUST leave no owned listener. The MCP server MUST close its owned
-dashboard when its transport or process shuts down; it MUST NOT close a reused
-external foreground server.
+dashboard when its transport or process shuts down. This keeps dashboard child
+operations in the MCP host environment and prevents an agent-shell or foreground
+CLI dashboard from being mistaken for the canonical MCP-owned runtime.
 
 The packaged `$taskchef-dashboard` skill MUST call this tool, report `started`
 or `reused`, and return the canonical clickable URL. It MAY use an available
@@ -427,6 +433,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.
@@ -499,6 +516,6 @@ closed.
 Installing or replacing plugin files MUST NOT be described as activating the
 new MCP code. Release verification MUST install the plugin, activate or reload
 the new MCP process, ensure the dashboard, and verify the expected TaskChef
-version, dashboard protocol `serverVersion`, canonical workspace, and canonical
-URL. Exact-compatible listener reuse remains valid; installation MUST NOT be
+version, dashboard protocol `serverVersion`, `mcp` launcher, canonical workspace,
+and canonical URL. Exact-compatible MCP-listener reuse remains valid; installation MUST NOT be
 claimed to reload Codex automatically.

package/docs/workflows.md

@@ -40,11 +40,11 @@ sequenceDiagram
   participant H as Loopback health
   participant S as Dashboard server
   M->>M: Read dashboard.autostart (absent means true)
-  M->>M: Best-effort ensure after MCP connect
+  M->>M: Best-effort ensure before MCP transport connects
   D->>M: ensure_dashboard()
   M->>M: Serialize concurrent ensure calls
   M->>H: GET 127.0.0.1:3210/api/health
-  alt Exact service, versions, and canonical workspace
+  alt Exact service, versions, canonical workspace, and MCP launcher
     H-->>M: Bounded compatible identity
     M-->>D: reused, URL, workspace, versions
   else No listener
@@ -52,7 +52,7 @@ sequenceDiagram
     M->>S: Start in this MCP process on 127.0.0.1:3210
     S-->>M: Owned server
     M-->>D: started, URL, workspace, versions
-  else Unknown, stale, or different workspace
+  else Standalone, unknown, stale, or different workspace
     H-->>M: Missing or incompatible identity
     M-->>D: Actionable conflict, listener untouched
   end
@@ -62,9 +62,10 @@ sequenceDiagram
 ```
 
 When the MCP transport or plugin process closes, it closes only the server it
-started. A compatible foreground `taskchef dashboard` listener may be reused
-but remains owned by that CLI process. No TaskChef path terminates an unknown
-listener or installs OS persistence.
+started. A foreground `taskchef dashboard` listener identifies itself as
+standalone and is never reused as the canonical MCP dashboard, because its
+archive child process may inherit a different host environment. No TaskChef
+path terminates an incompatible listener or installs OS persistence.
 
 Autostart and explicit ensures share the same manager promise, so concurrent
 initialization and recovery calls produce at most one owned listener. An
@@ -79,13 +80,13 @@ The practical release handoff ends in this order:
 1. Install the released plugin.
 2. Activate or reload its new TaskChef MCP process.
 3. Run `$taskchef-dashboard` or call `ensure_dashboard`.
-4. Verify the expected TaskChef version, protocol `serverVersion`, canonical
-   workspace, and canonical URL returned by the dashboard identity.
+4. Verify the expected TaskChef version, protocol `serverVersion`, `mcp`
+   launcher, canonical workspace, and canonical URL returned by the dashboard identity.
 
 Replacing plugin files alone cannot execute autostart because old code remains
 in the already-running MCP process. Installation does not necessarily reload
-Codex. An exact-compatible dashboard may be reused; an unknown listener is
-never terminated or replaced.
+Codex. An exact-compatible MCP dashboard may be reused; a standalone or unknown
+listener is never terminated or replaced.
 
 ## Normal delegation and self-linking
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taskchef",
-  "version": "7.18.0",
+  "version": "7.19.1",
   "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-manager.js

@@ -14,13 +14,14 @@ const DEFAULT_HOST = "127.0.0.1";
 const DEFAULT_PORT = 3210;
 const HEALTH_TIMEOUT_MS = 750;
 
-function expectedIdentity(workspace, taskchefVersion, serverVersion) {
+function expectedIdentity(workspace, taskchefVersion, serverVersion, launcher) {
   return {
     schemaVersion: 1,
     service: "taskchef-dashboard",
     taskchefVersion,
     serverVersion,
     workspace,
+    launcher,
   };
 }
 
@@ -107,6 +108,7 @@ export function createDashboardManager({
   port = DEFAULT_PORT,
   taskchefVersion = TASKCHEF_VERSION,
   serverVersion = DASHBOARD_SERVER_VERSION,
+  launcher = "mcp",
   createServer = createDashboardServer,
   readIdentity = readDashboardIdentity,
 } = {}) {
@@ -117,6 +119,7 @@ export function createDashboardManager({
 
   const publicResult = (action) => ({
     action,
+    launcher,
     url: `http://${dashboardAuthority(host, ownedServer?.port ?? port)}/`,
     workspace: canonicalWorkspace,
     taskchefVersion,
@@ -132,9 +135,12 @@ export function createDashboardManager({
       if (listenerAbsent(error)) return false;
       throw listenerConflict(url, `is occupied but did not return a compatible identity (${error.message}).`);
     }
-    const expected = expectedIdentity(canonicalWorkspace, taskchefVersion, serverVersion);
+    const expected = expectedIdentity(canonicalWorkspace, taskchefVersion, serverVersion, launcher);
     if (!isExactIdentity(identity, expected)) {
-      throw listenerConflict(url, "belongs to an unknown, stale, or different-workspace service.");
+      throw listenerConflict(
+        url,
+        "belongs to an unknown, stale, different-workspace, or differently launched service.",
+      );
     }
     return true;
   };
@@ -150,6 +156,7 @@ export function createDashboardManager({
         port,
         taskchefVersion,
         serverVersion,
+        launcher,
       });
       return publicResult("started");
     } catch (error) {

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,
@@ -446,6 +452,7 @@ export async function createDashboardServer({
   monitorOptions = {},
   openProject = null,
   openThread = null,
+  launcher = "standalone",
   taskchefVersion = TASKCHEF_VERSION,
   serverVersion = DASHBOARD_SERVER_VERSION,
 } = {}) {
@@ -458,6 +465,9 @@ export async function createDashboardServer({
   if (!Number.isInteger(maxEventClients) || maxEventClients < 0) {
     throw new Error("dashboard event-client limit must be a non-negative integer");
   }
+  if (!new Set(["mcp", "standalone"]).has(launcher)) {
+    throw new Error("dashboard launcher must be mcp or standalone");
+  }
   const monitor = new DashboardMonitor(workspace, monitorOptions);
   await monitor.start();
   const identity = Object.freeze({
@@ -466,12 +476,14 @@ export async function createDashboardServer({
     taskchefVersion,
     serverVersion,
     workspace: monitor.workspace,
+    launcher,
   });
   if (Buffer.byteLength(`${JSON.stringify(identity)}\n`) > DASHBOARD_HEALTH_MAX_BYTES) {
     monitor.close();
     throw new Error("dashboard identity exceeds the health response limit");
   }
   const clients = new Set();
+  const archiveRequests = new Set();
   let allowedAuthority;
   let allowedOrigin;
 
@@ -617,6 +629,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/mcp.js

@@ -88,6 +88,7 @@ const preparationSchema = z.object({
 
 const dashboardSchema = z.object({
   action: z.enum(["started", "reused"]),
+  launcher: z.literal("mcp"),
   url: z.string().url(),
   workspace: z.string(),
   taskchefVersion: z.string(),
@@ -163,7 +164,7 @@ export function createTaskChefMcpServer({
     return closePromise;
   };
   server.server.onclose = () => {
-    void dashboardManager.close();
+    void dashboardManager.close().catch(() => {});
   };
 
   server.registerTool(
@@ -171,7 +172,7 @@ export function createTaskChefMcpServer({
     {
       title: "Ensure TaskChef dashboard",
       description:
-        "Best-effort ensure the canonical TaskChef dashboard is available on 127.0.0.1:3210. Starts one dashboard inside this MCP process or reuses only an exact compatible TaskChef dashboard for the same canonical workspace; unknown listeners are never terminated or replaced.",
+        "Best-effort ensure the canonical TaskChef dashboard is available on 127.0.0.1:3210. Starts one dashboard inside this MCP process or reuses only an exact compatible MCP-launched TaskChef dashboard for the same canonical workspace; standalone and unknown listeners are never terminated or replaced.",
       inputSchema: {},
       outputSchema: { dashboard: dashboardSchema },
       annotations: {
@@ -325,8 +326,16 @@ export function createTaskChefMcpServer({
     ...(logDashboardDiagnostic ? { log: logDashboardDiagnostic } : {}),
   });
   server.connect = async (...args) => {
-    await originalConnect(...args);
-    void autostartDashboard();
+    await autostartDashboard();
+    try {
+      await originalConnect(...args);
+    } catch (error) {
+      await Promise.allSettled([
+        Promise.resolve().then(() => dashboardManager.close()),
+        Promise.resolve().then(() => originalClose()),
+      ]);
+      throw error;
+    }
   };
 
   return server;

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 = "3";