taskchef 7.17.1 → 7.19.0

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "taskchef",
-  "version": "7.17.1",
+  "version": "7.19.0",
   "description": "Dispatch work from a data-only workspace to visible Codex project tasks.",
   "author": {
     "name": "Favo Yang",
@@ -31,7 +31,7 @@
     "defaultPrompt": [
       "$taskchef-bootstrap Set up TaskChef and index my local Codex projects.",
       "$taskchef-delegate Do X in Y project.",
-      "Start and open the TaskChef dashboard.",
+      "$taskchef-dashboard Ensure and open the TaskChef dashboard.",
       "$taskchef-copilot Summarize recent delegated work and tell me what needs attention."
     ],
     "brandColor": "#D97706",

package/README.md

@@ -31,7 +31,7 @@ codex plugin add taskchef@favoyang-plugins
 npm install --global taskchef
 ```
 
-The plugin provides four skills and a local MCP server. The npm installation
+The plugin provides five skills and a local MCP server. The npm installation
 puts the `taskchef` CLI on `PATH`. TaskChef installs no hooks, schedules,
 daemons, login items, system services, or background identity search and needs
 no elevated permissions.
@@ -48,7 +48,7 @@ The canonical workspace is `~/.agents/taskchef`. TaskChef owns only:
 
 ```text
 AGENTS.md       managed dispatcher instructions plus user additions
-taskchef.json   schema-2 Codex project index and delegation metadata
+taskchef.json   schema-2 Codex project index, dashboard preference, and delegation metadata
 tasks.jsonl     one task snapshot per line (schema 9; schema 4-8 migration supported)
 ```
 
@@ -129,9 +129,10 @@ correlation marker. That skill reads the executor's own `CODEX_THREAD_ID`, self-
 reports lifecycle state. Independent outcomes may become separate executors;
 dependent work should stay together.
 
-At the start of every dispatcher turn, the managed workspace instructions ask
-the MCP server to best-effort ensure the dashboard. A startup failure never
-blocks an answer, report, or delegation. Every dispatcher response ends with
+Activating the TaskChef MCP process best-effort ensures the dashboard by
+default. The managed workspace instructions also retry it at the start of each
+dispatcher turn. A startup failure never blocks MCP tools, an answer, report,
+or delegation. Every dispatcher response ends with
 the stable [TaskChef Dashboard](http://127.0.0.1:3210/) link; a created-task
 directive remains on the preceding line so dispatch still returns immediately.
 
@@ -219,13 +220,14 @@ eight-character prefix.
 
 ## Dashboard
 
-Ask the dispatcher to make the dashboard available and open it:
+Use the packaged recovery skill to make the dashboard available and open it:
 
 ```text
-Start and open the TaskChef dashboard.
+$taskchef-dashboard Ensure and open the TaskChef dashboard.
 ```
 
-Dispatcher turns call the input-free `ensure_dashboard` MCP tool. It starts at
+MCP activation and `$taskchef-dashboard` call the input-free `ensure_dashboard`
+MCP tool. It starts at
 most one dashboard inside the existing TaskChef MCP process on
 `127.0.0.1:3210`, or reuses a listener only when its bounded `/api/health`
 identity proves the exact TaskChef/dashboard-server version and the same
@@ -233,8 +235,22 @@ canonical workspace. The response says `started` or `reused` and includes the
 stable URL, canonical workspace, and versions.
 
 The in-process dashboard closes with the MCP process. Closing Codex or reloading
-the plugin may therefore stop the dashboard; the next dispatcher turn restores
-it. TaskChef adds no OS-persistent component.
+the plugin may therefore stop the dashboard; activating the next TaskChef MCP
+process normally restores it. TaskChef adds no OS-persistent component.
+
+Autostart is enabled when `dashboard` is absent and in new workspaces. To opt
+out, add this optional exact object to `taskchef.json` while retaining its other
+fields:
+
+```json
+"dashboard": { "autostart": false }
+```
+
+The manual `$taskchef-dashboard` recovery skill remains available when
+autostart is disabled or fails. It reports whether the compatible dashboard was
+started or reused and always returns its canonical clickable URL. It may open
+the returned localhost URL in an available in-app browser, but browser failure
+does not make dashboard recovery fail.
 
 For manual development, run the foreground CLI:
 
@@ -247,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
@@ -322,6 +344,21 @@ codex plugin marketplace upgrade favoyang-plugins
 codex plugin add taskchef@favoyang-plugins
 ```
 
+Replacing or installing plugin files cannot execute autostart by itself. After
+installation, activate or reload the new TaskChef MCP process; installation
+does not necessarily reload Codex. Then run `$taskchef-dashboard` (or call
+`ensure_dashboard`) and verify the returned dashboard identity has all of:
+
+- the expected released TaskChef version;
+- the expected dashboard protocol `serverVersion`;
+- 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.
+
 ## Development
 
 ```sh

package/assets/taskchef-dispatcher-instructions.md

@@ -6,10 +6,8 @@ This folder is the canonical per-user TaskChef dispatcher workspace.
 - Early in every dispatcher turn, best-effort call the TaskChef
   `ensure_dashboard` MCP tool. Dashboard startup failure must not block direct
   TaskChef answers, reporting, or delegation.
-- A request to start or open the TaskChef dashboard is TaskChef maintenance,
-  not delegated project work. Call `ensure_dashboard`, then open or navigate to
-  its returned URL when an in-app browser capability is available. Otherwise,
-  return the URL as a clickable link.
+- A request to start, recover, or open the TaskChef dashboard is TaskChef
+  maintenance, not delegated project work. Use `$taskchef-dashboard`.
 - Use `$taskchef-bootstrap` when initializing or refreshing this workspace,
   changing or listing its configured projects, running TaskChef doctor,
   or repairing its managed instructions.

package/docs/firstmate-taskchef-comparison.md

@@ -70,7 +70,7 @@ responsibility until an outcome is landed, transferred, or safely preserved.
 | Dimension | TaskChef 7 | FirstMate at `038d0f7` |
 | --- | --- | --- |
 | Primary goal | Put multi-project work into the right visible Codex task and make it findable later. | Let one person direct a supervised crew across projects through one liaison. |
-| Product form | Codex plugin: four skills, local MCP server, data CLI, and loopback dashboard. | Cloneable agent distribution: instructions, internal skills, scripts, policies, and private on-disk state. |
+| Product form | Codex plugin: five skills, local MCP server, data CLI, and loopback dashboard. | Cloneable agent distribution: instructions, internal skills, scripts, policies, and private on-disk state. |
 | Runtime | Native Codex desktop tasks are the executors and live source of truth. | Harness-driven workers in tmux by default, with documented alternative session backends; Codex can be a harness, but Codex desktop is not a runtime backend. |
 | Coordinator lifetime | Dispatcher returns immediately and does not supervise. | First mate remains active and uses watcher/guard mechanisms to supervise meaningful events. |
 | Project isolation | Delegates to the configured Codex project; isolation follows native Codex/project behavior. | Ship and scout workers require separate Treehouse- or backend-managed worktrees. |
@@ -219,7 +219,7 @@ harness adapter.
 | --- | --- | --- |
 | Codex | Built around native Codex projects, tasks, thread reads, and desktop deep links. | Codex is one verified harness; desktop tasks are not its worker runtime. |
 | GitHub | Configured repository URLs aid routing; delivery remains the executor project's concern. | GitHub CLI, PR state, and configured delivery modes are part of supervised shipping workflows. |
-| Skills | Four plugin skills with narrow bootstrap, delegate, executor, and conversational coordination responsibilities. | Internal firstmate-only skills plus standalone public skills; AGENTS.md routes conditional procedures. |
+| Skills | Five plugin skills with narrow bootstrap, dashboard recovery, delegate, executor, and conversational coordination responsibilities. | Internal firstmate-only skills plus standalone public skills; AGENTS.md routes conditional procedures. |
 | MCP | Four primary local TaskChef tools plus one deprecated compatibility alias own deterministic identity and state writes. | FirstMate describes itself as an agent distribution rather than an MCP product; deterministic behavior lives largely in scripts. |
 | Runtime extensions | Extend plugin skills/MCP/CLI/dashboard or compose native Codex capabilities. | Add or verify harness adapters, session backends, dispatch profiles, operational scripts, and optional integrations. |
 

package/docs/spec.md

@@ -29,7 +29,7 @@ is dated research, not contract.
 | **Turn reference** | Required lifecycle identity for one executor prompt. It is the native Codex turn ID when available, otherwise a retained client-generated UUID. |
 | **Current turn ID** | Optional Codex metadata for the reported prompt; null when native turn reading is unavailable. |
 | **Dashboard** | The loopback, read-only UI derived from validated workspace snapshots and bounded native actions. |
-| **Skill** | One packaged agent procedure: `taskchef-bootstrap`, `taskchef-delegate`, `taskchef-executor`, or `taskchef-copilot`. |
+| **Skill** | One packaged agent procedure: `taskchef-bootstrap`, `taskchef-dashboard`, `taskchef-delegate`, `taskchef-executor`, or `taskchef-copilot`. |
 
 ## Components and ownership
 
@@ -43,6 +43,9 @@ is dated research, not contract.
 - `taskchef-copilot` MUST own conversational outcome explanation, attention,
   and next-action recommendations. It MUST use cached normalized briefs by
   default and MUST NOT poll or persist inferred state.
+- `taskchef-dashboard` MUST own manual dashboard ensure and recovery. It MUST
+  NOT dispatch work or inspect task outcomes, and browser navigation failure
+  MUST NOT suppress the returned dashboard URL.
 - The MCP server MUST expose `ensure_dashboard`, four primary lifecycle tools,
   and the deprecated `report_result` compatibility alias specified below.
 - The CLI MAY administer and inspect the workspace, but MUST NOT provide a
@@ -56,7 +59,8 @@ is dated research, not contract.
 TaskChef MUST manage only `AGENTS.md`, `taskchef.json`, and `tasks.jsonl`
 inside the dispatcher workspace. It MUST preserve unrelated paths.
 
-`taskchef.json` MUST have schema version 2 and exactly:
+`taskchef.json` MUST have schema version 2, the following required fields, and
+an optional exact `dashboard` object:
 
 ```json
 {
@@ -71,6 +75,11 @@ Names and paths MUST be unique. Git projects MUST be exact Git roots.
 Repository URLs MUST canonicalize to `https://github.com/<owner>/<repository>`
 and be case-insensitively deduplicated.
 
+When present, `dashboard` MUST contain exactly boolean `autostart`. Its absence
+is backward-compatible and means `true`; new workspaces SHOULD write
+`{"autostart": true}`. `false` disables MCP-lifecycle autostart but MUST NOT
+disable the explicit `ensure_dashboard` tool.
+
 `tasks.jsonl` MUST contain zero or more newline-terminated schema-4 through
 schema-9 records, one per line. Schemas 4 through 8 are supported
 migration/read formats; every new record and state mutation MUST write schema 9. Other schemas
@@ -112,6 +121,14 @@ 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
+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.
+
 At the start of every dispatcher turn, the dispatcher SHOULD call
 `ensure_dashboard` best-effort. Failure MUST NOT block direct TaskChef answers,
 reporting, or delegation. Every dispatcher final response MUST end with the
@@ -233,6 +250,11 @@ 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.
 
+The packaged `$taskchef-dashboard` skill MUST call this tool, report `started`
+or `reused`, and return the canonical clickable URL. It MAY use an available
+in-app browser when permitted; absent or blocked browser navigation MUST fall
+back to the link without failing. It MUST NOT inspect task outcomes or dispatch.
+
 **Annotations:** `readOnlyHint: false`, `destructiveHint: false`,
 `openWorldHint: false`.
 
@@ -405,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.
@@ -473,3 +506,10 @@ system services, cron jobs, hooks, privileged components, or elevated/system
 permissions for dashboard availability. Availability is best-effort while the
 owning Codex/plugin MCP process is alive and is not guaranteed while Codex is
 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
+claimed to reload Codex automatically.

package/docs/workflows.md

@@ -13,6 +13,7 @@ research.
 | `skills/taskchef-delegate/SKILL.md` | Split, route, record-before-create, create, return. |
 | `skills/taskchef-executor/SKILL.md` | Own, self-link, execute, and report every executor turn. |
 | `skills/taskchef-bootstrap/SKILL.md` | Initialize the workspace and maintain the Codex project index. |
+| `skills/taskchef-dashboard/SKILL.md` | Ensure or recover the canonical dashboard and return its URL. |
 | `skills/taskchef-copilot/SKILL.md` | Explain normalized cached briefs and coordinate safe next actions. |
 | `src/mcp.js` | Dashboard ensure, four primary lifecycle tools, one deprecated alias, shutdown ownership, and MCP annotations. |
 | `src/delegation.js` | UUID marker, concise executor-skill invocation shape, and creation-failure handling. |
@@ -27,9 +28,9 @@ per-user default.
 
 ## Dispatcher dashboard lifecycle
 
-The generated managed `AGENTS.md` block makes dashboard maintenance a
-best-effort prelude to every dispatcher turn and keeps response ordering
-centralized instead of duplicating it across delegate/copilot skills.
+MCP activation makes dashboard maintenance a best-effort lifecycle action. The
+generated managed `AGENTS.md` block also retries it before dispatcher turns and
+keeps response ordering centralized instead of duplicating it across skills.
 
 ```mermaid
 sequenceDiagram
@@ -38,6 +39,8 @@ sequenceDiagram
   participant M as TaskChef MCP
   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
   D->>M: ensure_dashboard()
   M->>M: Serialize concurrent ensure calls
   M->>H: GET 127.0.0.1:3210/api/health
@@ -63,6 +66,27 @@ 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.
 
+Autostart and explicit ensures share the same manager promise, so concurrent
+initialization and recovery calls produce at most one owned listener. An
+explicit `dashboard.autostart: false` skips only activation-time ensure. Any
+failure is reduced to a fixed stderr diagnostic; tool registration and MCP
+availability continue. Activation never opens a browser.
+
+## Release-install verification
+
+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.
+
+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.
+
 ## Normal delegation and self-linking
 
 The dispatcher uses native Codex project discovery for routing and MCP for

package/index.js

@@ -5,6 +5,7 @@ export {
   canonicalDirectory,
   canonicalGitRoot,
   doctorWorkspace,
+  dashboardAutostartEnabled,
   ensureWorkspaceInstructions,
   filterTasks,
   importProjects,
@@ -74,4 +75,4 @@ export {
 
 export { DASHBOARD_SERVER_VERSION, TASKCHEF_VERSION } from "./src/version.js";
 
-export { createTaskChefMcpServer } from "./src/mcp.js";
+export { createDashboardAutostart, createTaskChefMcpServer } from "./src/mcp.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taskchef",
-  "version": "7.17.1",
+  "version": "7.19.0",
   "description": "A non-blocking interactive dispatcher for visible Codex tasks.",
   "license": "MIT",
   "author": "Favo Yang",
@@ -36,6 +36,7 @@
     "scripts/e2e-benchmark.js",
     "src",
     "skills/taskchef-bootstrap",
+    "skills/taskchef-dashboard",
     "skills/taskchef-delegate",
     "skills/taskchef-executor",
     "skills/taskchef-copilot"

package/skills/taskchef-bootstrap/SKILL.md

@@ -160,5 +160,8 @@ Example managed-workspace import entry:
 }
 ```
 
-TaskChef accepts configuration schema version 2 only. `githubRepos` is always
-an array; unsupported configuration is rejected without being rewritten.
+TaskChef accepts configuration schema version 2 only. Its optional exact
+`dashboard` object contains boolean `autostart`; absence means enabled and
+`false` opts out of MCP-lifecycle dashboard startup without disabling manual
+`$taskchef-dashboard` recovery. `githubRepos` is always an array; unsupported
+configuration is rejected without being rewritten.

package/skills/taskchef-dashboard/SKILL.md

@@ -0,0 +1,20 @@
+---
+name: taskchef-dashboard
+description: "Ensure and recover the canonical TaskChef dashboard. Use when the user asks to start, restore, open, or get the link for the TaskChef dashboard. Do not use to dispatch work or inspect task outcomes."
+---
+
+# TaskChef Dashboard
+
+Maintain only the canonical TaskChef dashboard.
+
+1. Call the TaskChef `ensure_dashboard` MCP tool with its empty input. Do not
+   supply a workspace, host, or port.
+2. Report whether the returned `action` is `started` or `reused` and provide
+   the returned canonical URL as a clickable link.
+3. If the user asked to open the dashboard and an in-app browser navigation
+   capability is available and permits the returned localhost URL, open or
+   navigate to it. Browser absence, refusal, or blocked localhost navigation is
+   non-fatal: still return the clickable URL and the ensure result.
+
+Do not dispatch project work, read task briefs, inspect executor outcomes, poll,
+start a separate foreground CLI server, or modify TaskChef workspace files.

package/skills/taskchef-dashboard/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "TaskChef Dashboard"
+  short_description: "Start or recover the TaskChef dashboard"
+  default_prompt: "Use $taskchef-dashboard to ensure the TaskChef dashboard is available and give me its link."

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/mcp.js

@@ -6,6 +6,8 @@ import {
   recordTask,
   reportTaskState,
   reportTaskResult,
+  dashboardAutostartEnabled,
+  readConfig,
 } from "./workspace.js";
 import { parseTaskChefMarker } from "./delegation.js";
 import { createDashboardManager } from "./dashboard-manager.js";
@@ -99,6 +101,39 @@ function toolResult(key, value, message) {
   };
 }
 
+function dashboardAutostartDiagnostic(error) {
+  const message = typeof error?.message === "string" ? error.message : "";
+  if (error?.code === "EADDRINUSE" || /port conflict|already in use/i.test(message)) {
+    return "TaskChef dashboard autostart skipped: port 127.0.0.1:3210 is unavailable; the listener was left untouched.";
+  }
+  if (/configuration|workspace|task log/i.test(message)) {
+    return "TaskChef dashboard autostart skipped: the canonical workspace is not ready.";
+  }
+  return "TaskChef dashboard autostart skipped: the dashboard could not be started.";
+}
+
+export function createDashboardAutostart({
+  workspace,
+  dashboardManager,
+  readConfiguration = readConfig,
+  log = (message) => process.stderr.write(`${message}\n`),
+} = {}) {
+  let startPromise = null;
+  return async () => {
+    startPromise ??= (async () => {
+      try {
+        const config = await readConfiguration(workspace, { checkPaths: false });
+        if (!dashboardAutostartEnabled(config)) return { action: "disabled" };
+        return await dashboardManager.ensure();
+      } catch (error) {
+        try { log(dashboardAutostartDiagnostic(error)); } catch {}
+        return { action: "failed" };
+      }
+    })();
+    return startPromise;
+  };
+}
+
 export function createTaskChefMcpServer({
   workspace = resolveWorkspacePath().workspace,
   prepare = prepareDispatch,
@@ -107,6 +142,8 @@ export function createTaskChefMcpServer({
   reportState = reportTaskState,
   link = linkTask,
   dashboardManager = createDashboardManager({ workspace }),
+  readConfiguration = readConfig,
+  logDashboardDiagnostic,
 } = {}) {
   const server = new McpServer(
     { name: "taskchef", version: TASKCHEF_VERSION },
@@ -280,5 +317,17 @@ export function createTaskChefMcpServer({
     },
   );
 
+  const originalConnect = server.connect.bind(server);
+  const autostartDashboard = createDashboardAutostart({
+    workspace,
+    dashboardManager,
+    readConfiguration,
+    ...(logDashboardDiagnostic ? { log: logDashboardDiagnostic } : {}),
+  });
+  server.connect = async (...args) => {
+    await originalConnect(...args);
+    void autostartDashboard();
+  };
+
   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 = "2";

package/src/workspace.js

@@ -43,7 +43,8 @@ const PREVIOUS_TASK_SCHEMA_VERSION = 8;
 const FIRST_TURN_HISTORY_TASK_SCHEMA_VERSION = 7;
 const LEGACY_RESULTS_TASK_SCHEMA_VERSION = 6;
 const FIRST_SELF_LINKING_TASK_SCHEMA_VERSION = 4;
-const CONFIG_FIELDS = new Set(["schemaVersion", "projects"]);
+const CONFIG_FIELDS = new Set(["schemaVersion", "projects", "dashboard"]);
+const DASHBOARD_CONFIG_FIELDS = new Set(["autostart"]);
 const PROJECT_FIELDS = new Set([
   "name",
   "path",
@@ -533,16 +534,36 @@ async function inspectProject(input, index = 0) {
 }
 
 export async function validateConfig(config, { checkPaths = true } = {}) {
-  requireExactFields(config, CONFIG_FIELDS, "taskchef.json");
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    throw new Error("taskchef.json must be an object");
+  }
+  const unexpected = Object.keys(config).find((key) => !CONFIG_FIELDS.has(key));
+  if (unexpected) throw new Error(`taskchef.json has unsupported field: ${unexpected}`);
+  for (const required of ["schemaVersion", "projects"]) {
+    if (!(required in config)) throw new Error(`taskchef.json is missing field: ${required}`);
+  }
   if (config.schemaVersion !== CURRENT_CONFIG_SCHEMA_VERSION) {
     throw new Error("unsupported configuration schemaVersion");
   }
+  let dashboard;
+  if ("dashboard" in config) {
+    requireExactFields(config.dashboard, DASHBOARD_CONFIG_FIELDS, "taskchef.json.dashboard");
+    if (typeof config.dashboard.autostart !== "boolean") {
+      throw new Error("taskchef.json.dashboard.autostart must be a boolean");
+    }
+    dashboard = { autostart: config.dashboard.autostart };
+  }
   return {
     schemaVersion: CURRENT_CONFIG_SCHEMA_VERSION,
     projects: await normalizeProjects(config.projects, { checkPaths }),
+    ...(dashboard ? { dashboard } : {}),
   };
 }
 
+export function dashboardAutostartEnabled(config) {
+  return config?.dashboard?.autostart !== false;
+}
+
 async function ensureDispatchFile(workspaceRoot) {
   const filePath = path.join(workspaceRoot, DISPATCH_FILE_NAME);
   const exists = await managedRegularFileExists(filePath);
@@ -569,7 +590,11 @@ export async function initializeWorkspace(workspaceRoot) {
     const configExists = await managedRegularFileExists(configPath);
     const config = configExists
       ? await readConfig(root, { checkPaths: false })
-      : { schemaVersion: CURRENT_CONFIG_SCHEMA_VERSION, projects: [] };
+      : {
+        schemaVersion: CURRENT_CONFIG_SCHEMA_VERSION,
+        projects: [],
+        dashboard: { autostart: true },
+      };
     const dispatchPath = path.join(root, DISPATCH_FILE_NAME);
     if (configExists && (await managedRegularFileExists(dispatchPath))) {
       await readDispatchesUnlocked(root);
@@ -638,7 +663,7 @@ export async function addProject(workspaceRoot, input) {
     const project = await inspectProject(input);
     assertWorkspaceOutsideProject(root, project.path);
     const updated = await validateConfig({
-      schemaVersion: CURRENT_CONFIG_SCHEMA_VERSION,
+      ...config,
       projects: [...config.projects, project],
     });
     await writeJsonAtomic(path.join(root, "taskchef.json"), updated);
@@ -676,7 +701,7 @@ export async function importProjects(workspaceRoot, inputs, { replace = false }
       else projects[index] = project;
     }
     const config = await validateConfig({
-      schemaVersion: CURRENT_CONFIG_SCHEMA_VERSION,
+      ...current,
       projects,
     });
     await writeJsonAtomic(path.join(root, "taskchef.json"), config);
@@ -700,7 +725,7 @@ export async function removeProject(workspaceRoot, name) {
     const [project] = config.projects.slice(index, index + 1);
     const projects = config.projects.filter((_, projectIndex) => projectIndex !== index);
     await writeJsonAtomic(path.join(root, "taskchef.json"), {
-      schemaVersion: CURRENT_CONFIG_SCHEMA_VERSION,
+      ...config,
       projects,
     });
     return { project };