taskchef 5.8.0 → 5.9.0

package/.codex-plugin/plugin.json

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

package/README.md

@@ -162,6 +162,53 @@ when its metadata is newer than the callback; missing callbacks and other
 anomalies also receive at most one targeted read. Reporting writes nothing and
 never polls.
 
+### Watch the local dashboard
+
+Run a local dashboard when you want the task history to remain visible while
+executors report results:
+
+```sh
+taskchef dashboard
+```
+
+Open the printed capability URL, which starts with `http://127.0.0.1:3210` and
+contains a one-time launch token. Do not share it: the browser exchanges it for
+a local session cookie before loading task data, then removes the token from the
+address bar. Use `--port <number>` to choose another port and `--workspace
+<path>` to override the normal workspace resolution. Press Ctrl+C in the
+terminal to stop the server.
+
+The dashboard:
+
+- orders tasks by their latest semantic or identity update;
+- filters by project and status;
+- shows dismissible notifications when tasks are added or changed;
+- reveals the original instruction, latest semantic result, and task metadata;
+- opens a task's project in Codex on request, while preserving the recorded
+  thread ID for manual task selection.
+
+The server binds only to the numeric IPv4 loopback interface, requires the
+unguessable launch capability before serving instructions or results, validates
+the same task schema as the CLI, retains its last valid snapshot if the log
+becomes invalid, and never writes dispatcher-workspace files. It limits event
+streams and disconnects slow clients instead of buffering snapshots without
+bound. It watches the workspace directory
+so TaskChef's atomic log replacement remains visible, uses a low-frequency file
+metadata check to recover from missed watcher events, and streams snapshots to
+the browser with automatic reconnect. To keep untrusted history from exhausting
+the server or browser, the dashboard rejects logs above 16 MiB, histories above
+2,000 tasks, and unusually large display fields while retaining the last valid
+snapshot. The data CLI remains unaffected by these display limits.
+
+Direct desktop navigation to a recorded thread is not exposed by the supported
+`codex app` CLI, which accepts only a workspace path. A task-level refresh would
+require native Codex metadata tools that are available to the report skill, not
+to a standalone browser page. TaskChef also does not submit replies from the
+dashboard: `codex resume <session> [prompt]` starts an interactive CLI session
+and may execute the prompt immediately, rather than opening a reviewed draft in
+the desktop app. These integrations remain deferred until Codex provides a
+stable task deep link or explicit draft handoff.
+
 ### Manage configured projects
 
 Use `$taskchef-bootstrap` to scan local Codex projects and refresh the managed

package/index.js

@@ -59,6 +59,13 @@ export {
   openWorkspaceInCodex,
 } from "./src/codex-app.js";
 
+export {
+  DashboardMonitor,
+  createDashboardServer,
+  dashboardAuthority,
+  sortTasksByMeaningfulUpdate,
+} from "./src/dashboard.js";
+
 export { createTaskChefMcpServer } from "./src/mcp.js";
 
 export { handleInitialPromptHook } from "./src/hook.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taskchef",
-  "version": "5.8.0",
+  "version": "5.9.0",
   "description": "A non-blocking interactive dispatcher for visible Codex tasks.",
   "license": "MIT",
   "author": "Favo Yang",
@@ -45,7 +45,7 @@
   "scripts": {
     "benchmark:dispatch": "node scripts/benchmark-dispatch-prepare.js",
     "benchmark:e2e": "node scripts/e2e-benchmark.js",
-    "test": "node --test tests/taskchef.test.js"
+    "test": "node --test tests/*.test.js"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",

package/src/cli.js

@@ -2,6 +2,7 @@ import { access, readFile, realpath } from "node:fs/promises";
 import path from "node:path";
 
 import { openWorkspaceInCodex } from "./codex-app.js";
+import { createDashboardServer } from "./dashboard.js";
 import { resolveWorkspacePath } from "./workspace-path.js";
 
 import {
@@ -409,11 +410,51 @@ async function taskSummary(args) {
   return 0;
 }
 
+function dashboardPort(args) {
+  const value = option(args, "--port", "3210");
+  if (!/^\d+$/.test(value)) throw new Error("--port must be an integer from 0 to 65535");
+  const port = Number(value);
+  if (port > 65_535) throw new Error("--port must be an integer from 0 to 65535");
+  return port;
+}
+
+async function dashboard(args) {
+  validateCommandArgs(args, 1, {
+    values: ["--port", "--workspace"],
+    switches: ["--json"],
+  });
+  const server = await createDashboardServer({
+    workspace: workspaceRoot(args),
+    port: dashboardPort(args),
+  });
+  print({
+    schemaVersion: 1,
+    url: server.url,
+    workspace: server.monitor.workspace,
+  }, args, (value) => [
+    `TaskChef dashboard: ${value.url}`,
+    `Workspace: ${value.workspace}`,
+    "Press Ctrl+C to stop.",
+  ].join("\n"));
+
+  let stop;
+  await new Promise((resolve) => {
+    stop = resolve;
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+  });
+  process.off("SIGINT", stop);
+  process.off("SIGTERM", stop);
+  await server.close();
+  return 0;
+}
+
 function usage() {
   process.stdout.write(`TaskChef workspace utility
 
 Usage:
   taskchef help
+  taskchef dashboard [--port <number>] [--json] [--workspace <path>]
   taskchef doctor [--json] [--workspace <path>]
   taskchef workspace path [--json] [--workspace <path>]
   taskchef workspace init [--register-codex] [--codex-cli <path>] [--json] [--workspace <path>]
@@ -435,6 +476,8 @@ Project import reads a JSON
 array from a file, or from standard input when the source is '-' or omitted.
 Workspace resolution precedence is --workspace, TASKCHEF_WORKSPACE, then
 ~/.agents/taskchef.
+The dashboard binds to 127.0.0.1 and reads the canonical task log without
+modifying dispatcher-workspace files.
 `);
 }
 
@@ -443,6 +486,7 @@ export async function runCli(args) {
     usage();
     return 0;
   }
+  if (args[0] === "dashboard") return dashboard(args);
   if (args[0] === "doctor") return doctor(args);
   if (args[0] === "workspace" && args[1] === "path") return workspacePath(args);
   if (args[0] === "workspace" && args[1] === "init") return initialize(args);

package/src/dashboard/app.js

@@ -0,0 +1,255 @@
+import {
+  findCurrentTask,
+  reconcileNotifications,
+} from "./state.js";
+
+const state = {
+  tasks: [],
+  signatures: new Map(),
+  notifications: [],
+  initialized: false,
+  selectedTask: null,
+};
+
+const elements = {
+  clearNotifications: document.querySelector("#clear-notifications"),
+  closeDialog: document.querySelector("#close-dialog"),
+  connectionDot: document.querySelector("#connection-dot"),
+  connectionLabel: document.querySelector("#connection-label"),
+  copyThreadId: document.querySelector("#copy-thread-id"),
+  dashboardMessage: document.querySelector("#dashboard-message"),
+  dialog: document.querySelector("#task-dialog"),
+  dialogInstruction: document.querySelector("#dialog-instruction"),
+  dialogMetadata: document.querySelector("#dialog-metadata"),
+  dialogProject: document.querySelector("#dialog-project"),
+  dialogSummary: document.querySelector("#dialog-summary"),
+  dialogTitle: document.querySelector("#dialog-title"),
+  emptyState: document.querySelector("#empty-state"),
+  notifications: document.querySelector("#notifications"),
+  openProject: document.querySelector("#open-project"),
+  projectFilter: document.querySelector("#project-filter"),
+  statusFilter: document.querySelector("#status-filter"),
+  taskCount: document.querySelector("#task-count"),
+  taskList: document.querySelector("#task-list"),
+  toastList: document.querySelector("#toast-list"),
+};
+
+function statusLabel(task) {
+  return task.status === null ? "unresolved" : task.status.replaceAll("_", " ");
+}
+
+function formatTime(value) {
+  if (!value) return "—";
+  return new Intl.DateTimeFormat(undefined, {
+    dateStyle: "medium",
+    timeStyle: "short",
+  }).format(new Date(value));
+}
+
+function setConnection(connected) {
+  elements.connectionDot.classList.toggle("connected", connected);
+  elements.connectionLabel.textContent = connected ? "Live" : "Reconnecting…";
+}
+
+function replaceOptions(select, values, allLabel) {
+  const selected = select.value;
+  select.replaceChildren();
+  const all = document.createElement("option");
+  all.value = "";
+  all.textContent = allLabel;
+  select.append(all);
+  for (const value of values) {
+    const option = document.createElement("option");
+    option.value = value;
+    option.textContent = value;
+    select.append(option);
+  }
+  if (values.includes(selected)) select.value = selected;
+}
+
+function notificationToast(notification) {
+  const task = findCurrentTask(state.tasks, notification.taskId);
+  if (!task) return null;
+  const toast = document.createElement("div");
+  toast.className = "toast";
+  const text = document.createElement("button");
+  text.type = "button";
+  text.className = "toast-content";
+  const title = document.createElement("strong");
+  title.textContent = notification.kind === "new" ? "New task" : "Task updated";
+  const description = document.createElement("span");
+  description.textContent = `${task.title} · ${statusLabel(task)}`;
+  text.append(title, description);
+  text.addEventListener("click", () => {
+    const current = findCurrentTask(state.tasks, notification.taskId);
+    if (current) openDialog(current);
+    else showMessage("This task is no longer present in the current snapshot.");
+  });
+  const dismiss = document.createElement("button");
+  dismiss.type = "button";
+  dismiss.className = "icon-button";
+  dismiss.setAttribute("aria-label", `Dismiss notification for ${task.title}`);
+  dismiss.textContent = "×";
+  dismiss.addEventListener("click", () => {
+    state.notifications = state.notifications.filter(({ id }) => id !== notification.id);
+    renderNotifications();
+  });
+  toast.append(text, dismiss);
+  return toast;
+}
+
+function renderNotifications() {
+  elements.toastList.replaceChildren(
+    ...state.notifications.map(notificationToast).filter(Boolean),
+  );
+  elements.notifications.hidden = state.notifications.length === 0;
+}
+
+function detailRow(term, value) {
+  const dt = document.createElement("dt");
+  dt.textContent = term;
+  const dd = document.createElement("dd");
+  dd.textContent = value ?? "—";
+  return [dt, dd];
+}
+
+function openDialog(task) {
+  state.selectedTask = task;
+  elements.dialogProject.textContent = task.project.name;
+  elements.dialogTitle.textContent = task.title;
+  elements.dialogSummary.textContent = task.summary ?? "No semantic result has been reported yet.";
+  elements.dialogInstruction.textContent = task.instruction;
+  elements.copyThreadId.disabled = !task.threadId;
+  elements.dialogMetadata.replaceChildren(
+    ...detailRow("Status", statusLabel(task)),
+    ...detailRow("Task ID", task.id),
+    ...detailRow("Thread ID", task.threadId),
+    ...detailRow("Turn ID", task.turnId),
+    ...detailRow("Project path", task.project.path),
+    ...detailRow("Created", formatTime(task.createdAt)),
+    ...detailRow("Updated", formatTime(task.updatedAt ?? task.createdAt)),
+    ...detailRow("Updated by", task.updatedBy),
+  );
+  if (!elements.dialog.open) elements.dialog.showModal();
+}
+
+function taskCard(task) {
+  const article = document.createElement("article");
+  article.className = "task-card";
+  const heading = document.createElement("div");
+  heading.className = "task-heading";
+  const title = document.createElement("button");
+  title.type = "button";
+  title.className = "task-title";
+  title.textContent = task.title;
+  title.addEventListener("click", () => openDialog(task));
+  const badge = document.createElement("span");
+  badge.className = `status status-${task.status ?? "unresolved"}`;
+  badge.textContent = statusLabel(task);
+  heading.append(title, badge);
+  const project = document.createElement("p");
+  project.className = "task-project";
+  project.textContent = task.project.name;
+  const summary = document.createElement("p");
+  summary.className = "task-summary";
+  summary.textContent = task.summary ?? "No semantic result reported yet.";
+  const time = document.createElement("time");
+  time.dateTime = task.updatedAt ?? task.createdAt;
+  time.textContent = `Updated ${formatTime(task.updatedAt ?? task.createdAt)}`;
+  article.append(heading, project, summary, time);
+  return article;
+}
+
+function render() {
+  const project = elements.projectFilter.value;
+  const status = elements.statusFilter.value;
+  const visible = state.tasks.filter((task) =>
+    (!project || task.project.name === project)
+    && (!status || statusLabel(task) === status));
+  elements.taskList.replaceChildren(...visible.map(taskCard));
+  elements.emptyState.hidden = visible.length > 0;
+  elements.taskCount.textContent = `${visible.length} of ${state.tasks.length} task${state.tasks.length === 1 ? "" : "s"}`;
+}
+
+function applySnapshot(snapshot) {
+  const reconciled = reconcileNotifications({
+    initialized: state.initialized,
+    notifications: state.notifications,
+    signatures: state.signatures,
+  }, snapshot.tasks, snapshot.revision);
+  state.tasks = snapshot.tasks;
+  state.signatures = reconciled.signatures;
+  state.notifications = reconciled.notifications;
+  state.initialized = true;
+  if (snapshot.healthy === false) {
+    showMessage("The task log is temporarily unavailable. Showing the last valid snapshot.");
+  } else {
+    elements.dashboardMessage.hidden = true;
+  }
+  replaceOptions(
+    elements.projectFilter,
+    [...new Set(state.tasks.map((task) => task.project.name))].sort(),
+    "All projects",
+  );
+  replaceOptions(
+    elements.statusFilter,
+    [...new Set(state.tasks.map(statusLabel))].sort(),
+    "All statuses",
+  );
+  if (state.selectedTask) {
+    const updated = state.tasks.find((task) => task.id === state.selectedTask.id);
+    if (updated && elements.dialog.open) openDialog(updated);
+  }
+  renderNotifications();
+  render();
+}
+
+function showMessage(message) {
+  elements.dashboardMessage.textContent = message;
+  elements.dashboardMessage.hidden = false;
+}
+
+const events = new EventSource("/api/events");
+events.addEventListener("open", () => setConnection(true));
+events.addEventListener("error", () => setConnection(false));
+events.addEventListener("snapshot", (event) => {
+  setConnection(true);
+  applySnapshot(JSON.parse(event.data));
+});
+events.addEventListener("dashboard-error", (event) => {
+  showMessage(JSON.parse(event.data).message);
+});
+
+elements.projectFilter.addEventListener("change", render);
+elements.statusFilter.addEventListener("change", render);
+elements.clearNotifications.addEventListener("click", () => {
+  state.notifications = [];
+  renderNotifications();
+});
+elements.closeDialog.addEventListener("click", () => elements.dialog.close());
+elements.dialog.addEventListener("click", (event) => {
+  if (event.target === elements.dialog) elements.dialog.close();
+});
+elements.copyThreadId.addEventListener("click", async () => {
+  if (!state.selectedTask?.threadId) return;
+  try {
+    await navigator.clipboard.writeText(state.selectedTask.threadId);
+    elements.copyThreadId.textContent = "Copied";
+    setTimeout(() => { elements.copyThreadId.textContent = "Copy thread ID"; }, 1_500);
+  } catch {
+    showMessage("Clipboard access is unavailable. Copy the thread ID from the metadata below.");
+  }
+});
+elements.openProject.addEventListener("click", async () => {
+  if (!state.selectedTask) return;
+  elements.openProject.disabled = true;
+  try {
+    const response = await fetch(`/api/tasks/${encodeURIComponent(state.selectedTask.id)}/open-project`, {
+      method: "POST",
+    });
+    const result = await response.json();
+    showMessage(result.message);
+  } finally {
+    elements.openProject.disabled = false;
+  }
+});

package/src/dashboard/index.html

@@ -0,0 +1,86 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <meta name="color-scheme" content="light dark">
+    <title>TaskChef dashboard</title>
+    <link rel="stylesheet" href="/styles.css">
+    <script src="/app.js" type="module"></script>
+  </head>
+  <body>
+    <header class="site-header">
+      <div>
+        <p class="eyebrow">TaskChef</p>
+        <h1>Task dashboard</h1>
+        <p class="subtitle">Latest delegated work, updated as TaskChef reports change.</p>
+      </div>
+      <div class="connection" role="status" aria-live="polite">
+        <span id="connection-dot" class="connection-dot"></span>
+        <span id="connection-label">Connecting…</span>
+      </div>
+    </header>
+
+    <main>
+      <section class="toolbar" aria-label="Task filters">
+        <label>
+          Project
+          <select id="project-filter">
+            <option value="">All projects</option>
+          </select>
+        </label>
+        <label>
+          Status
+          <select id="status-filter">
+            <option value="">All statuses</option>
+          </select>
+        </label>
+        <p id="task-count" class="task-count" aria-live="polite"></p>
+      </section>
+
+      <div id="dashboard-message" class="dashboard-message" role="status" hidden></div>
+      <section aria-labelledby="tasks-heading">
+        <h2 id="tasks-heading" class="visually-hidden">Tasks</h2>
+        <div id="task-list" class="task-list"></div>
+        <div id="empty-state" class="empty-state" hidden>
+          <h2>No tasks match these filters</h2>
+          <p>Choose a different project or status to see more work.</p>
+        </div>
+      </section>
+    </main>
+
+    <aside id="notifications" class="notifications" aria-label="Task notifications" hidden>
+      <div class="notifications-heading">
+        <strong>Updates</strong>
+        <button id="clear-notifications" class="text-button" type="button">Clear all</button>
+      </div>
+      <div id="toast-list" class="toast-list" aria-live="polite"></div>
+    </aside>
+
+    <dialog id="task-dialog" aria-labelledby="dialog-title">
+      <div class="dialog-header">
+        <div>
+          <p id="dialog-project" class="eyebrow"></p>
+          <h2 id="dialog-title"></h2>
+        </div>
+        <button id="close-dialog" class="icon-button" type="button" aria-label="Close task details">×</button>
+      </div>
+      <div class="dialog-actions">
+        <button id="open-project" class="primary-button" type="button">Open project in Codex</button>
+        <button id="copy-thread-id" class="secondary-button" type="button">Copy thread ID</button>
+      </div>
+      <section>
+        <h3>Result</h3>
+        <p id="dialog-summary" class="preserve-lines"></p>
+      </section>
+      <section>
+        <h3>Original instruction</h3>
+        <pre id="dialog-instruction"></pre>
+      </section>
+      <section>
+        <h3>Metadata</h3>
+        <dl id="dialog-metadata" class="metadata"></dl>
+      </section>
+    </dialog>
+  </body>
+</html>

package/src/dashboard/state.js

@@ -0,0 +1,40 @@
+export const MAX_NOTIFICATIONS = 50;
+
+export function taskSignature(task) {
+  return JSON.stringify([
+    task.threadId,
+    task.status,
+    task.summary,
+    task.turnId,
+    task.updatedAt,
+    task.updatedBy,
+  ]);
+}
+
+export function findCurrentTask(tasks, taskId) {
+  return tasks.find((task) => task.id === taskId) ?? null;
+}
+
+export function reconcileNotifications(
+  { initialized, notifications, signatures },
+  tasks,
+  revision,
+) {
+  const nextSignatures = new Map(tasks.map((task) => [task.id, taskSignature(task)]));
+  if (!initialized) return { notifications, signatures: nextSignatures };
+  const additions = [];
+  for (const task of tasks) {
+    let kind = null;
+    if (!signatures.has(task.id)) kind = "new";
+    else if (signatures.get(task.id) !== nextSignatures.get(task.id)) kind = "changed";
+    if (kind) additions.push({
+      id: `${revision}:${task.id}`,
+      kind,
+      taskId: task.id,
+    });
+  }
+  return {
+    notifications: [...additions, ...notifications].slice(0, MAX_NOTIFICATIONS),
+    signatures: nextSignatures,
+  };
+}

package/src/dashboard/styles.css

@@ -0,0 +1,147 @@
+:root {
+  color-scheme: light;
+  --background: #f5f4f0;
+  --surface: #ffffff;
+  --surface-muted: #eeece6;
+  --text: #1d211f;
+  --muted: #626964;
+  --border: #d8d7d1;
+  --accent: #215f4a;
+  --accent-soft: #dcebe4;
+  --danger: #8b3a35;
+  --warning: #8a5c17;
+  --shadow: 0 12px 30px rgb(24 33 29 / 10%);
+  font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+}
+
+* { box-sizing: border-box; }
+
+body {
+  margin: 0;
+  background: var(--background);
+  color: var(--text);
+  line-height: 1.5;
+}
+
+button, select { font: inherit; }
+button { color: inherit; }
+
+.site-header, main {
+  width: min(1080px, calc(100% - 40px));
+  margin-inline: auto;
+}
+
+.site-header {
+  display: flex;
+  align-items: flex-end;
+  justify-content: space-between;
+  gap: 24px;
+  padding-block: 48px 28px;
+  border-bottom: 1px solid var(--border);
+}
+
+h1, h2, h3, p { margin-top: 0; }
+h1 { margin-bottom: 6px; font-size: clamp(2rem, 5vw, 3.4rem); line-height: 1; letter-spacing: -0.04em; }
+h2 { line-height: 1.2; }
+h3 { margin-bottom: 8px; font-size: 0.84rem; letter-spacing: 0.08em; text-transform: uppercase; color: var(--muted); }
+
+.eyebrow { margin-bottom: 10px; color: var(--accent); font-size: 0.78rem; font-weight: 750; letter-spacing: 0.15em; text-transform: uppercase; }
+.subtitle, .task-project, time { color: var(--muted); }
+.subtitle { margin-bottom: 0; }
+
+.connection { display: flex; align-items: center; gap: 8px; color: var(--muted); font-size: 0.9rem; }
+.connection-dot { width: 9px; height: 9px; border-radius: 50%; background: var(--warning); }
+.connection-dot.connected { background: var(--accent); box-shadow: 0 0 0 4px var(--accent-soft); }
+
+main { padding-block: 28px 80px; }
+
+.toolbar {
+  display: flex;
+  align-items: flex-end;
+  gap: 16px;
+  margin-bottom: 22px;
+}
+
+label { display: grid; gap: 6px; color: var(--muted); font-size: 0.78rem; font-weight: 700; letter-spacing: 0.04em; text-transform: uppercase; }
+select { min-width: 180px; padding: 9px 34px 9px 11px; border: 1px solid var(--border); border-radius: 7px; background: var(--surface); color: var(--text); }
+.task-count { margin: 0 0 9px auto; color: var(--muted); font-size: 0.9rem; }
+
+.task-list { display: grid; gap: 12px; }
+.task-card { padding: 20px 22px; border: 1px solid var(--border); border-radius: 10px; background: var(--surface); box-shadow: 0 1px 0 rgb(0 0 0 / 2%); }
+.task-heading { display: flex; align-items: flex-start; justify-content: space-between; gap: 18px; }
+.task-title { padding: 0; border: 0; background: none; font-size: 1.08rem; font-weight: 720; text-align: left; cursor: pointer; }
+.task-title:hover { color: var(--accent); text-decoration: underline; text-underline-offset: 3px; }
+.task-project { margin: 3px 0 12px; font-size: 0.86rem; }
+.task-summary { max-width: 78ch; margin-bottom: 14px; }
+time { font-size: 0.78rem; }
+
+.status { flex: none; padding: 4px 9px; border-radius: 999px; background: var(--surface-muted); color: var(--muted); font-size: 0.72rem; font-weight: 750; text-transform: capitalize; }
+.status-completed { background: var(--accent-soft); color: var(--accent); }
+.status-failed { background: #f3dfdd; color: var(--danger); }
+.status-needs_input { background: #f4e9ce; color: var(--warning); }
+
+.empty-state { padding: 60px 20px; border: 1px dashed var(--border); border-radius: 10px; text-align: center; color: var(--muted); }
+.empty-state h2 { margin-bottom: 6px; color: var(--text); }
+
+.dashboard-message { margin-bottom: 18px; padding: 11px 14px; border: 1px solid #d8c58e; border-radius: 7px; background: #fff7de; color: #604613; }
+
+.notifications { position: fixed; right: 20px; bottom: 20px; z-index: 3; width: min(380px, calc(100vw - 40px)); padding: 14px; border: 1px solid var(--border); border-radius: 10px; background: var(--surface); box-shadow: var(--shadow); }
+.notifications-heading { display: flex; justify-content: space-between; align-items: center; margin-bottom: 8px; }
+.toast-list { display: grid; gap: 7px; max-height: 50vh; overflow: auto; }
+.toast { display: flex; align-items: flex-start; gap: 8px; padding: 10px; border-radius: 7px; background: var(--surface-muted); }
+.toast-content { display: grid; flex: 1; gap: 2px; padding: 0; border: 0; background: none; text-align: left; cursor: pointer; }
+.toast-content span { color: var(--muted); font-size: 0.85rem; }
+
+.text-button, .icon-button { border: 0; background: none; cursor: pointer; }
+.text-button { color: var(--accent); font-size: 0.82rem; font-weight: 700; }
+.icon-button { padding: 0 4px; color: var(--muted); font-size: 1.4rem; line-height: 1; }
+
+dialog { width: min(760px, calc(100vw - 32px)); max-height: min(82vh, 900px); padding: 28px; border: 1px solid var(--border); border-radius: 12px; background: var(--surface); color: var(--text); box-shadow: var(--shadow); }
+dialog::backdrop { background: rgb(18 23 21 / 50%); backdrop-filter: blur(2px); }
+.dialog-header { display: flex; 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 { 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; }
+dialog section + section { margin-top: 24px; }
+.preserve-lines { white-space: pre-wrap; }
+pre { max-height: 280px; margin: 0; padding: 14px; overflow: auto; border-radius: 7px; background: var(--surface-muted); white-space: pre-wrap; overflow-wrap: anywhere; font: 0.86rem/1.55 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; }
+.metadata { display: grid; grid-template-columns: minmax(100px, 150px) 1fr; margin: 0; font-size: 0.88rem; }
+.metadata dt, .metadata dd { padding: 7px 0; border-bottom: 1px solid var(--border); overflow-wrap: anywhere; }
+.metadata dt { color: var(--muted); }
+.metadata dd { margin: 0; }
+
+.visually-hidden { position: absolute; width: 1px; height: 1px; padding: 0; margin: -1px; overflow: hidden; clip: rect(0, 0, 0, 0); white-space: nowrap; border: 0; }
+:focus-visible { outline: 3px solid rgb(33 95 74 / 35%); outline-offset: 3px; }
+
+@media (max-width: 650px) {
+  .site-header { align-items: flex-start; padding-top: 32px; }
+  .toolbar { align-items: stretch; flex-direction: column; }
+  .toolbar label, .toolbar select { width: 100%; }
+  .task-count { margin: 0; }
+  .task-heading { align-items: flex-start; }
+  .dialog-actions { align-items: stretch; flex-direction: column; }
+  .metadata { grid-template-columns: 1fr; }
+  .metadata dt { padding-bottom: 0; border-bottom: 0; }
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    color-scheme: dark;
+    --background: #181b19;
+    --surface: #222624;
+    --surface-muted: #2d322f;
+    --text: #edf1ee;
+    --muted: #aeb7b1;
+    --border: #3d4440;
+    --accent: #7dc1a4;
+    --accent-soft: #244436;
+    --danger: #ef9991;
+    --warning: #e4bd77;
+  }
+  .dashboard-message { border-color: #66592e; background: #38321d; color: #f1d98c; }
+  .status-failed { background: #4e2927; }
+  .status-needs_input { background: #4c3b20; }
+}

package/src/dashboard.js

@@ -0,0 +1,597 @@
+import { randomBytes } from "node:crypto";
+import { EventEmitter } from "node:events";
+import { constants, watch } from "node:fs";
+import { open, readFile, realpath, stat } from "node:fs/promises";
+import http from "node:http";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { openWorkspaceInCodex } from "./codex-app.js";
+import {
+  canonicalDirectory,
+  canonicalGitRoot,
+  parseTaskLogContent,
+  readConfig,
+} from "./workspace.js";
+
+const TASKS_FILE_NAME = "tasks.jsonl";
+const STATIC_ROOT = fileURLToPath(new URL("./dashboard/", import.meta.url));
+const LOOPBACK_HOSTS = new Set(["127.0.0.1", "::1"]);
+const DEFAULT_MAX_FILE_BYTES = 16 * 1024 * 1024;
+const DEFAULT_MAX_TASKS = 2_000;
+const DEFAULT_MAX_EVENT_CLIENTS = 16;
+const CONTENT_SECURITY_POLICY = [
+  "default-src 'self'",
+  "base-uri 'none'",
+  "connect-src 'self'",
+  "form-action 'none'",
+  "frame-ancestors 'none'",
+  "img-src 'self' data:",
+  "object-src 'none'",
+  "script-src 'self'",
+  "style-src 'self'",
+].join("; ");
+
+const STATIC_FILES = new Map([
+  ["/", ["index.html", "text/html; charset=utf-8"]],
+  ["/app.js", ["app.js", "text/javascript; charset=utf-8"]],
+  ["/state.js", ["state.js", "text/javascript; charset=utf-8"]],
+  ["/styles.css", ["styles.css", "text/css; charset=utf-8"]],
+]);
+
+export function dashboardAuthority(host, port) {
+  const address = host === "::1" ? "[::1]" : host;
+  return port === 80 ? address : `${address}:${port}`;
+}
+
+function meaningfulUpdateTime(task, observedUpdateTimes) {
+  return Math.max(
+    Date.parse(task.updatedAt ?? task.createdAt),
+    observedUpdateTimes.get(task.id) ?? Number.NEGATIVE_INFINITY,
+  );
+}
+
+export function sortTasksByMeaningfulUpdate(tasks, observedUpdateTimes = new Map()) {
+  return tasks
+    .map((task, index) => ({ task, index }))
+    .sort((left, right) =>
+      meaningfulUpdateTime(right.task, observedUpdateTimes)
+      - meaningfulUpdateTime(left.task, observedUpdateTimes)
+      || left.index - right.index)
+    .map(({ task }) => task);
+}
+
+function taskFingerprint(tasks) {
+  return JSON.stringify(tasks);
+}
+
+async function fileFingerprint(filePath) {
+  const details = await stat(filePath);
+  return statFingerprint(details);
+}
+
+function statFingerprint(details) {
+  return `${details.dev}:${details.ino}:${details.size}:${details.mtimeMs}`;
+}
+
+export async function readBoundedTaskLog(filePath, maximumBytes, { afterOpen = null } = {}) {
+  const flags = constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0);
+  const handle = await open(filePath, flags);
+  try {
+    const before = await handle.stat();
+    if (!before.isFile()) throw new Error("task log is not a regular file");
+    if (afterOpen) await afterOpen();
+    const chunks = [];
+    let total = 0;
+    while (total <= maximumBytes) {
+      const buffer = Buffer.alloc(Math.min(64 * 1024, maximumBytes + 1 - total));
+      const { bytesRead } = await handle.read(buffer, 0, buffer.length, null);
+      if (bytesRead === 0) break;
+      chunks.push(buffer.subarray(0, bytesRead));
+      total += bytesRead;
+    }
+    if (total > maximumBytes) {
+      throw new Error(`task log exceeds the dashboard limit of ${maximumBytes} bytes`);
+    }
+    const after = await handle.stat();
+    if (statFingerprint(before) !== statFingerprint(after)) {
+      throw new Error("task log changed while the dashboard was reading it");
+    }
+    return {
+      content: Buffer.concat(chunks, total).toString("utf8"),
+      fingerprint: statFingerprint(after),
+    };
+  } finally {
+    await handle.close();
+  }
+}
+
+function boundedText(value, maximum, name) {
+  if (value !== null && value !== undefined && String(value).length > maximum) {
+    throw new Error(`${name} exceeds the dashboard display limit`);
+  }
+}
+
+function assertDashboardTaskBounds(tasks, maximumTasks) {
+  if (tasks.length > maximumTasks) {
+    throw new Error(`task log exceeds the dashboard limit of ${maximumTasks} tasks`);
+  }
+  for (const [index, task] of tasks.entries()) {
+    const name = `task ${index + 1}`;
+    boundedText(task.id, 512, `${name} ID`);
+    boundedText(task.title, 1_000, `${name} title`);
+    boundedText(task.instruction, 250_000, `${name} instruction`);
+    boundedText(task.summary, 2_000, `${name} summary`);
+    boundedText(task.threadId, 512, `${name} thread ID`);
+    boundedText(task.turnId, 512, `${name} turn ID`);
+    boundedText(task.project.name, 1_000, `${name} project name`);
+    boundedText(task.project.path, 8_192, `${name} project path`);
+    boundedText(task.project.description, 4_000, `${name} project description`);
+    if (task.project.githubRepos.length > 100) {
+      throw new Error(`${name} has too many GitHub repositories for the dashboard`);
+    }
+    for (const repository of task.project.githubRepos) {
+      boundedText(repository, 2_048, `${name} GitHub repository`);
+    }
+  }
+}
+
+export class DashboardMonitor extends EventEmitter {
+  constructor(workspace, {
+    debounceMs = 75,
+    fingerprint = fileFingerprint,
+    maxFileBytes = DEFAULT_MAX_FILE_BYTES,
+    maxTasks = DEFAULT_MAX_TASKS,
+    readSnapshot = null,
+    pollIntervalMs = 5_000,
+    watchDirectory = watch,
+    watchReconnectMs = 1_000,
+  } = {}) {
+    super();
+    this.workspace = workspace;
+    this.debounceMs = debounceMs;
+    this.pollIntervalMs = pollIntervalMs;
+    this.watchDirectory = watchDirectory;
+    this.watchReconnectMs = watchReconnectMs;
+    this.fingerprint = fingerprint;
+    this.maxFileBytes = maxFileBytes;
+    this.maxTasks = maxTasks;
+    this.readSnapshot = readSnapshot ?? (async () => {
+      const snapshot = await readBoundedTaskLog(this.tasksFile, this.maxFileBytes);
+      return {
+        fingerprint: snapshot.fingerprint,
+        tasks: await parseTaskLogContent(this.workspace, snapshot.content),
+      };
+    });
+    this.tasks = [];
+    this.revision = 0;
+    this.started = false;
+    this.currentFingerprint = null;
+    this.currentTaskFingerprint = null;
+    this.unhealthy = false;
+    this.observedUpdateTimes = new Map();
+    this.refreshPromise = null;
+    this.refreshQueued = false;
+    this.watcher = null;
+    this.debounceTimer = null;
+    this.pollTimer = null;
+    this.reconnectTimer = null;
+  }
+
+  snapshot() {
+    return {
+      schemaVersion: 1,
+      revision: this.revision,
+      generatedAt: new Date().toISOString(),
+      healthy: !this.unhealthy,
+      tasks: this.tasks,
+    };
+  }
+
+  async start() {
+    if (this.started) return this.snapshot();
+    this.workspace = await realpath(path.resolve(this.workspace));
+    this.tasksFile = path.join(this.workspace, TASKS_FILE_NAME);
+    await this.refresh({ force: true });
+    if (this.revision === 0) throw new Error("dashboard could not read a valid task log");
+    this.started = true;
+    this.startWatcher();
+    this.pollTimer = setInterval(() => this.refresh(), this.pollIntervalMs);
+    this.pollTimer.unref?.();
+    return this.snapshot();
+  }
+
+  startWatcher() {
+    if (!this.started || this.watcher) return;
+    try {
+      this.watcher = this.watchDirectory(this.workspace, { persistent: false }, (_event, fileName) => {
+        if (fileName !== null && String(fileName) !== TASKS_FILE_NAME) return;
+        clearTimeout(this.debounceTimer);
+        this.debounceTimer = setTimeout(() => this.refresh({ force: true }), this.debounceMs);
+        this.debounceTimer.unref?.();
+      });
+      this.watcher.on("error", (error) => {
+        this.emit("watcherError", error);
+        this.watcher?.close();
+        this.watcher = null;
+        this.scheduleWatcherReconnect();
+      });
+    } catch (error) {
+      this.emit("watcherError", error);
+      this.scheduleWatcherReconnect();
+    }
+  }
+
+  scheduleWatcherReconnect() {
+    if (!this.started || this.reconnectTimer) return;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.startWatcher();
+      this.refresh({ force: true });
+    }, this.watchReconnectMs);
+    this.reconnectTimer.unref?.();
+  }
+
+  async refresh({ force = false } = {}) {
+    if (this.refreshPromise) {
+      this.refreshQueued ||= force;
+      return this.refreshPromise;
+    }
+    this.refreshPromise = this.refreshOnce({ force }).finally(async () => {
+      this.refreshPromise = null;
+      if (this.refreshQueued) {
+        this.refreshQueued = false;
+        await this.refresh({ force: true });
+      }
+    });
+    return this.refreshPromise;
+  }
+
+  async refreshOnce({ force }) {
+    try {
+      const observed = await this.fingerprint(this.tasksFile);
+      if (!force && observed === this.currentFingerprint) return false;
+      const snapshot = await this.readSnapshot();
+      assertDashboardTaskBounds(snapshot.tasks, this.maxTasks);
+      const after = await this.fingerprint(this.tasksFile);
+      if (snapshot.fingerprint !== after) {
+        this.refreshQueued = true;
+        return false;
+      }
+      const previous = new Map(this.tasks.map((task) => [task.id, task]));
+      const currentIds = new Set(snapshot.tasks.map((task) => task.id));
+      for (const taskId of this.observedUpdateTimes.keys()) {
+        if (!currentIds.has(taskId)) this.observedUpdateTimes.delete(taskId);
+      }
+      const observedAt = Date.now();
+      for (const task of snapshot.tasks) {
+        const former = previous.get(task.id);
+        if (former && JSON.stringify(former) !== JSON.stringify(task)) {
+          this.observedUpdateTimes.set(task.id, observedAt);
+        }
+      }
+      const tasks = sortTasksByMeaningfulUpdate(snapshot.tasks, this.observedUpdateTimes);
+      const nextTaskFingerprint = taskFingerprint(tasks);
+      this.currentFingerprint = after;
+      if (nextTaskFingerprint === this.currentTaskFingerprint) {
+        if (this.unhealthy) {
+          this.unhealthy = false;
+          this.emit("snapshot", this.snapshot());
+        }
+        return false;
+      }
+      this.tasks = tasks;
+      this.currentTaskFingerprint = nextTaskFingerprint;
+      this.revision += 1;
+      this.unhealthy = false;
+      this.emit("snapshot", this.snapshot());
+      return true;
+    } catch (error) {
+      if (!this.unhealthy) this.emit("monitorError", error);
+      this.unhealthy = true;
+      return false;
+    }
+  }
+
+  close() {
+    this.started = false;
+    this.watcher?.close();
+    clearTimeout(this.debounceTimer);
+    clearTimeout(this.reconnectTimer);
+    clearInterval(this.pollTimer);
+    this.watcher = null;
+  }
+}
+
+function securityHeaders(contentType) {
+  return {
+    "Cache-Control": "no-store",
+    "Content-Security-Policy": CONTENT_SECURITY_POLICY,
+    "Content-Type": contentType,
+    "Cross-Origin-Opener-Policy": "same-origin",
+    "Referrer-Policy": "no-referrer",
+    "X-Content-Type-Options": "nosniff",
+    "X-Frame-Options": "DENY",
+  };
+}
+
+function sendJson(response, status, value) {
+  response.writeHead(status, securityHeaders("application/json; charset=utf-8"));
+  response.end(`${JSON.stringify(value)}\n`);
+}
+
+function ssePayload(event, value) {
+  return `event: ${event}\ndata: ${JSON.stringify(value)}\n\n`;
+}
+
+export function writeSseEvent(response, event, value) {
+  return response.write(ssePayload(event, value));
+}
+
+export function createSseClient(response, {
+  drainTimeoutMs = 5_000,
+  onClose = () => {},
+} = {}) {
+  let blocked = false;
+  let closed = false;
+  let drainTimer = null;
+  let queuedPayload = null;
+  const drained = () => {
+    blocked = false;
+    clearTimeout(drainTimer);
+    drainTimer = null;
+    const payload = queuedPayload;
+    queuedPayload = null;
+    if (payload !== null) client.write(payload);
+  };
+  const client = {
+    get blocked() { return blocked; },
+    write(payload) {
+      if (closed) return false;
+      if (blocked) {
+        queuedPayload = payload;
+        return false;
+      }
+      const accepted = response.write(payload);
+      if (!accepted) {
+        blocked = true;
+        response.once("drain", drained);
+        drainTimer = setTimeout(() => client.close(), drainTimeoutMs);
+        drainTimer.unref?.();
+      }
+      return accepted;
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      clearTimeout(drainTimer);
+      queuedPayload = null;
+      response.off("drain", drained);
+      response.destroy();
+      onClose();
+    },
+  };
+  return client;
+}
+
+function requestSessionCookie(request, cookieName) {
+  return request.headers.cookie
+    ?.split(";")
+    .map((part) => part.trim())
+    .find((part) => part.startsWith(`${cookieName}=`))
+    ?.slice(cookieName.length + 1) ?? null;
+}
+
+function publicMonitorError() {
+  return {
+    message: "The task log is temporarily unavailable. Showing the last valid snapshot.",
+  };
+}
+
+export async function createDashboardServer({
+  workspace,
+  host = "127.0.0.1",
+  maxEventClients = DEFAULT_MAX_EVENT_CLIENTS,
+  port = 3210,
+  monitorOptions = {},
+  openProject = null,
+} = {}) {
+  if (!LOOPBACK_HOSTS.has(host)) {
+    throw new Error("dashboard host must be a loopback address");
+  }
+  if (!Number.isInteger(port) || port < 0 || port > 65_535) {
+    throw new Error("dashboard port must be an integer from 0 to 65535");
+  }
+  if (!Number.isInteger(maxEventClients) || maxEventClients < 0) {
+    throw new Error("dashboard event-client limit must be a non-negative integer");
+  }
+  const monitor = new DashboardMonitor(workspace, monitorOptions);
+  await monitor.start();
+  const clients = new Set();
+  const capabilityToken = randomBytes(32).toString("base64url");
+  let launchToken = capabilityToken;
+  const sessionToken = randomBytes(32).toString("base64url");
+  const sessionCookieName = `taskchef_session_${randomBytes(12).toString("hex")}`;
+  let allowedAuthority;
+  let allowedOrigin;
+
+  const broadcast = (event, value) => {
+    const payload = ssePayload(event, value);
+    for (const client of clients) client.write(payload);
+  };
+  const snapshotListener = (snapshot) => broadcast("snapshot", snapshot);
+  const errorListener = () => broadcast("dashboard-error", publicMonitorError());
+  monitor.on("snapshot", snapshotListener);
+  monitor.on("monitorError", errorListener);
+
+  const handleRequest = async (request, response) => {
+    const method = request.method ?? "GET";
+    let url;
+    try {
+      url = new URL(request.url ?? "/", "http://localhost");
+    } catch {
+      sendJson(response, 400, { message: "Malformed request target." });
+      return;
+    }
+    if (request.headers.host !== allowedAuthority) {
+      sendJson(response, 421, { message: "Misdirected request." });
+      return;
+    }
+    const authenticated = requestSessionCookie(request, sessionCookieName) === sessionToken;
+    if (
+      (method === "GET" || method === "HEAD")
+      && launchToken !== null
+      && url.pathname === "/"
+      && url.searchParams.get("token") === launchToken
+    ) {
+      launchToken = null;
+      response.writeHead(303, {
+        ...securityHeaders("text/plain; charset=utf-8"),
+        Location: "/",
+        "Set-Cookie": `${sessionCookieName}=${sessionToken}; HttpOnly; SameSite=Strict; Path=/`,
+      });
+      response.end("Opening TaskChef dashboard.\n");
+      return;
+    }
+    if (!authenticated) {
+      sendJson(response, 401, { message: "Dashboard launch capability required." });
+      return;
+    }
+    if (method !== "GET" && method !== "HEAD" && method !== "POST") {
+      response.writeHead(405, { Allow: "GET, HEAD, POST" });
+      response.end();
+      return;
+    }
+
+    if (url.pathname === "/api/snapshot" && (method === "GET" || method === "HEAD")) {
+      if (method === "HEAD") {
+        response.writeHead(200, securityHeaders("application/json; charset=utf-8"));
+        response.end();
+      } else {
+        sendJson(response, 200, monitor.snapshot());
+      }
+      return;
+    }
+
+    if (url.pathname === "/api/events" && method === "GET") {
+      if (clients.size >= maxEventClients) {
+        sendJson(response, 503, { message: "Dashboard event-stream limit reached." });
+        return;
+      }
+      response.writeHead(200, {
+        ...securityHeaders("text/event-stream; charset=utf-8"),
+        Connection: "keep-alive",
+      });
+      let client;
+      client = createSseClient(response, {
+        onClose: () => {
+          clearInterval(client.heartbeat);
+          clients.delete(client);
+        },
+      });
+      clients.add(client);
+      client.write(`retry: 2000\n\n${ssePayload("snapshot", monitor.snapshot())}`);
+      client.heartbeat = setInterval(() => {
+        if (!client.blocked) client.write(": heartbeat\n\n");
+      }, 15_000);
+      const { heartbeat } = client;
+      heartbeat.unref?.();
+      request.on("close", () => client.close());
+      response.on("error", () => client.close());
+      return;
+    }
+
+    const taskMatch = url.pathname.match(/^\/api\/tasks\/([a-zA-Z0-9._-]+)\/open-project$/);
+    if (taskMatch && method === "POST") {
+      if (request.headers.origin !== allowedOrigin) {
+        sendJson(response, 403, { message: "Dashboard session validation failed." });
+        return;
+      }
+      const task = monitor.tasks.find((candidate) => candidate.id === taskMatch[1]);
+      if (!task) {
+        sendJson(response, 404, { message: "Task not found." });
+        return;
+      }
+      try {
+        const trustedProject = (await readConfig(monitor.workspace, { checkPaths: false })).projects
+          .find((project) => project.path === task.project.path);
+        if (!trustedProject) {
+          sendJson(response, 409, {
+            message: "This historical task no longer matches a configured project.",
+          });
+          return;
+        }
+        const canonicalProjectPath = trustedProject.isGitRepository
+          ? await canonicalGitRoot(trustedProject.path)
+          : await canonicalDirectory(trustedProject.path);
+        if (canonicalProjectPath !== trustedProject.path) {
+          sendJson(response, 409, {
+            message: "This configured project has moved. Repair the TaskChef project first.",
+          });
+          return;
+        }
+        if (openProject) await openProject(canonicalProjectPath);
+        else await openWorkspaceInCodex(canonicalProjectPath);
+        sendJson(response, 202, {
+          message: "Opened the project in Codex. Select the recorded task there.",
+        });
+      } catch {
+        sendJson(response, 503, {
+          message: "Codex could not be opened. Run codex app with the project path instead.",
+        });
+      }
+      return;
+    }
+
+    if (method === "POST") {
+      sendJson(response, 404, { message: "Not found." });
+      return;
+    }
+
+    const staticFile = STATIC_FILES.get(url.pathname);
+    if (!staticFile) {
+      sendJson(response, 404, { message: "Not found." });
+      return;
+    }
+    const [fileName, contentType] = staticFile;
+    const body = await readFile(path.join(STATIC_ROOT, fileName));
+    response.writeHead(200, securityHeaders(contentType));
+    response.end(method === "HEAD" ? undefined : body);
+  };
+
+  const server = http.createServer((request, response) => {
+    handleRequest(request, response).catch(() => {
+      if (response.headersSent) response.destroy();
+      else sendJson(response, 500, { message: "Dashboard request failed." });
+    });
+  });
+
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, host, resolve);
+  }).catch((error) => {
+    monitor.close();
+    throw error;
+  });
+
+  const address = server.address();
+  const boundPort = typeof address === "object" && address ? address.port : port;
+  allowedAuthority = dashboardAuthority(host, boundPort);
+  allowedOrigin = `http://${allowedAuthority}`;
+  return {
+    host,
+    port: boundPort,
+    origin: allowedOrigin,
+    url: `${allowedOrigin}/?token=${encodeURIComponent(capabilityToken)}`,
+    monitor,
+    get eventClientCount() { return clients.size; },
+    async close() {
+      monitor.off("snapshot", snapshotListener);
+      monitor.off("monitorError", errorListener);
+      monitor.close();
+      for (const client of clients) client.close();
+      await new Promise((resolve, reject) => server.close((error) =>
+        error ? reject(error) : resolve()));
+    },
+  };
+}

package/src/workspace.js

@@ -852,13 +852,8 @@ async function validateDispatchShape(
   return normalized;
 }
 
-async function readDispatchRecordsUnlocked(root) {
+async function parseDispatchRecordsUnlocked(root, content) {
   await readConfig(root, { checkPaths: false });
-  const filePath = path.join(root, DISPATCH_FILE_NAME);
-  if (!(await managedRegularFileExists(filePath))) {
-    throw new Error(`task log does not exist: ${filePath}`);
-  }
-  const content = await readFile(filePath, "utf8");
   if (content.length > 0 && !content.endsWith("\n")) {
     throw new Error(`${DISPATCH_FILE_NAME} must end with a newline`);
   }
@@ -895,6 +890,14 @@ async function readDispatchRecordsUnlocked(root) {
   return records;
 }
 
+async function readDispatchRecordsUnlocked(root) {
+  const filePath = path.join(root, DISPATCH_FILE_NAME);
+  if (!(await managedRegularFileExists(filePath))) {
+    throw new Error(`task log does not exist: ${filePath}`);
+  }
+  return parseDispatchRecordsUnlocked(root, await readFile(filePath, "utf8"));
+}
+
 async function readDispatchesUnlocked(root) {
   return (await readDispatchRecordsUnlocked(root)).map((record) => record.normalized);
 }
@@ -904,6 +907,12 @@ export async function listTasks(workspaceRoot) {
   return readDispatchesUnlocked(root);
 }
 
+export async function parseTaskLogContent(workspaceRoot, content) {
+  const root = await realpath(path.resolve(workspaceRoot));
+  if (typeof content !== "string") throw new Error("task log content must be a string");
+  return (await parseDispatchRecordsUnlocked(root, content)).map((record) => record.normalized);
+}
+
 export async function recordTask(workspaceRoot, input, { now } = {}) {
   requireExactFields(input, RECORD_DISPATCH_FIELDS, "task input");
   const root = await realpath(path.resolve(workspaceRoot));
@@ -942,7 +951,7 @@ export async function recordTask(workspaceRoot, input, { now } = {}) {
   });
 }
 
-export async function resolveTask(workspaceRoot, taskId, threadId) {
+export async function resolveTask(workspaceRoot, taskId, threadId, { now } = {}) {
   const id = requireSafeId(taskId, "taskId");
   const durableThreadId = normalizeDurableThreadId(threadId);
   const root = await realpath(path.resolve(workspaceRoot));
@@ -962,9 +971,19 @@ export async function resolveTask(workspaceRoot, taskId, threadId) {
     if (dispatches.some((item) => item.threadId === durableThreadId)) {
       throw new Error(`threadId is already recorded: ${durableThreadId}`);
     }
-    const resolved = { ...dispatch, threadId: durableThreadId };
+    const currentRecord = records[index];
+    const resolved = currentRecord.raw.schemaVersion === CURRENT_TASK_SCHEMA_VERSION
+      ? await validateDispatchShape({
+        ...dispatch,
+        threadId: durableThreadId,
+        updatedAt: now ?? new Date().toISOString(),
+        updatedBy: "dispatcher",
+      })
+      : { ...dispatch, threadId: durableThreadId };
     const lines = records.map((record, recordIndex) => recordIndex === index
-      ? JSON.stringify({ ...record.raw, threadId: durableThreadId })
+      ? currentRecord.raw.schemaVersion === CURRENT_TASK_SCHEMA_VERSION
+        ? dispatchLineWithState(resolved, {})
+        : JSON.stringify({ ...record.raw, threadId: durableThreadId })
       : record.line);
     await writeDispatchLinesAtomic(root, lines);
     return resolved;