taskchef 8.6.2 → 8.7.1

package/src/mcp-app.js

@@ -1,156 +1,274 @@
-import { readFile } from "node:fs/promises";
+import { mkdir, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join } from "node:path";
+import { acquireWorkspaceLock } from "./workspace.js";
+import { writeDurableAtomic } from "./state-store.js";
 import { fileURLToPath } from "node:url";
+import { parse as parseToml } from "smol-toml";
 import { z } from "zod";
-import { DashboardMonitor, UsageSummaryMonitor } from "./dashboard.js";
-import { taskGitHubProjection } from "./dashboard/github-links.js";
-import { createUsageTracker } from "./usage-tracker.js";
-import { isCodexThreadDeepLinkId, openThreadInCodex, openWorkspaceInCodex } from "./codex-app.js";
-import { canonicalDirectory, canonicalGitRoot, manuallyTransitionTask, readConfig } from "./workspace.js";
+import { NextGitHub } from "./next-github.js";
+import { NextNotifications } from "./next-notifications.js";
+import { CodexSessionScanner } from "./codex-session-scanner.js";
+import { isCodexThreadDeepLinkId, openThreadInCodex, openPluginSettingsInCodex } from "./codex-app.js";
+import { TASKCHEF_APP_NAME, TASKCHEF_VERSION } from "./version.js";
 
-export const TASKCHEF_APP_URI = "ui://taskchef/task-board/v2";
+// Release versions separate host UI cache entries; same-version preview edits
+// intentionally keep their URI and use the sidebar's explicit Refresh action.
+export const TASKCHEF_GITHUB_URI = `ui://taskchef/github-settings/v1/${TASKCHEF_VERSION}`;
+export const TASKCHEF_APP_URI = `ui://taskchef/task-board/v3/${TASKCHEF_VERSION}`;
 const RESOURCE_MIME_TYPE = "text/html;profile=mcp-app";
 const htmlPath = fileURLToPath(new URL("./mcp-app/dist/index.html", import.meta.url));
-const taskIdSchema = z.string().regex(/^[a-zA-Z0-9._-]+$/).max(512);
-const expectedSchema = z.object({
-  status: z.enum(["working", "needs_input", "completed", "failed"]),
-  turnRef: z.string().nullable(),
-  threadId: z.string().nullable(),
-  updatedAt: z.string().min(1),
-}).strict();
+const taskIdSchema = z.string().uuid();
+
+const DEFAULT_GITHUB_CLIENT_ID = "Iv23likjK80RCtqZFGg8";
+const visibilityFields = { showExec: z.boolean(), showCli: z.boolean(), showArchived: z.boolean() };
+const settingsSchema = z.strictObject({ ...visibilityFields, showCalendarDates: z.boolean(), showCardUsage: z.boolean() });
+const storedSettingsSchema = settingsSchema.extend({ githubClientId: z.string().trim().max(80).regex(/^(?:Iv(?:1\.[A-Za-z0-9]+|[A-Za-z0-9]{10,}))?$/) });
+const settingsDefaults = { showExec: false, showCli: false, showArchived: false, showCalendarDates: false, showCardUsage: true, githubClientId: DEFAULT_GITHUB_CLIENT_ID };
+const settingsProperties = {
+  showCardUsage: { type: "boolean", title: "Show usage on cards", description: "Show token counts and estimated cost on cards and their status popups. Usage remains visible in chat details." },
+  showExec: { type: "boolean", title: "Show exec sessions", description: "Include standalone codex exec runs. Subagents stay hidden." },
+  showCli: { type: "boolean", title: "Show CLI sessions", description: "Include chats started from the Codex CLI." },
+  showCalendarDates: { type: "boolean", title: "Show calendar dates", description: "Show calendar dates and local times instead of relative ages." },
+  showArchived: { type: "boolean", title: "Show archived chats", description: "Show archived chats in their own column and list filter." },
+};
+function publicSettings(values) {
+  return Object.fromEntries(Object.keys(settingsProperties).map(key => [key, values[key]]));
+}
+
+export async function pluginSettingsUrl({ pluginRoot = fileURLToPath(new URL("../", import.meta.url)), codexHome = process.env.CODEX_HOME || join(homedir(), ".codex") } = {}) {
+  // Codex plugin detail links take the catalog file, not the marketplace root.
+  const plugin = basename(dirname(pluginRoot));
+  const marketplace = basename(dirname(dirname(pluginRoot)));
+  try {
+    const config = parseToml(await readFile(join(codexHome, "config.toml"), "utf8"));
+    const source = config.marketplaces?.[marketplace]?.source;
+    if (typeof source === "string" && isAbsolute(source)) {
+      const marketplacePath = join(source, ".agents", "plugins", "marketplace.json");
+      const catalog = JSON.parse(await readFile(marketplacePath, "utf8"));
+      if (catalog.name !== marketplace || !catalog.plugins?.some((entry) => entry.name === plugin)) return null;
+      return `codex://plugins/${encodeURIComponent(plugin)}?${new URLSearchParams({ marketplacePath })}`;
+    }
+  } catch { /* Report unresolved settings navigation when the user requests it. */ }
+  return null;
+}
 
 export function registerTaskChefApp(server, {
-  workspace,
-  createMonitor = (root) => new DashboardMonitor(root),
-  createUsageSummaryMonitor = (root) => new UsageSummaryMonitor(root),
-  createTaskUsageTracker = (root) => createUsageTracker({ workspace: root }),
-  transition = manuallyTransitionTask,
+  createScanner = () => new CodexSessionScanner(),
   openThread = openThreadInCodex,
-  openProject = openWorkspaceInCodex,
-  readConfiguration = readConfig,
+  getSettingsUrl = pluginSettingsUrl,
+  openSettings = openPluginSettingsInCodex,
+  settingsPath = join(homedir(), ".agents", "taskchef-next", "settings.json"),
+  notificationsPath = join(dirname(settingsPath), "notifications.json"),
+  createGitHub = (options) => new NextGitHub(options),
 } = {}) {
-  let monitor;
-  let usageSummaryMonitor;
-  let usageTracker;
-  let starting;
-  let appRevision = 0;
-  async function currentMonitor() {
-    if (!monitor) {
-      starting ??= (async () => {
-        const candidate = createMonitor(workspace);
-        try {
-          await candidate.start();
-          const summary = createUsageSummaryMonitor(candidate.workspace);
-          try { await summary.start(); }
-          catch (error) { summary.close(); throw error; }
-          usageSummaryMonitor = summary;
-          usageTracker = createTaskUsageTracker(candidate.workspace);
-          appRevision = 1;
-          candidate.on?.("snapshot", () => { appRevision += 1; });
-          summary.on?.("change", () => { appRevision += 1; });
-          monitor = candidate;
-          return candidate;
-        } catch (error) {
-          candidate.close();
-          usageSummaryMonitor?.close();
-          usageTracker?.close?.();
-          throw error;
-        }
-      })().finally(() => { starting = null; });
-      return starting;
+  const scanner = createScanner();
+  const notificationStore = new NextNotifications(notificationsPath);
+  const github = createGitHub({ stateDir: dirname(settingsPath) });
+  let boardRevision = 0;
+  let boardSignature;
+  let githubAuth;
+  const turnUsageCache = new Map();
+  const usagePending = new Map();
+  async function boardSnapshot(settings, force = false, scope = { date: "all", taskIds: [] }) {
+    const snapshot = await scanner.refresh({ force });
+    const visibleIds = new Set(scope.taskIds ?? []);
+    const displayTasks = snapshot.tasks.map(task => {
+      if (!visibleIds.has(task.id) || task.pullRequests?.length || !scanner.earlierPullRequest) return task;
+      const earlierPullRequest = scanner.earlierPullRequest(task.id);
+      return earlierPullRequest ? { ...task, earlierPullRequest } : task;
+    });
+    const result = await github.enrich({ ...snapshot, tasks: displayTasks }, settings, { force, scope });
+    githubAuth = result.auth;
+    const visible = new Set(scope.taskIds ?? []);
+    const tasks = [];
+    for (const task of result.snapshot.tasks) {
+      let cached = turnUsageCache.get(task.id);
+      if (cached?.turnId !== task.turnId) { turnUsageCache.delete(task.id); cached = null; }
+      if (result.snapshot.healthy !== false && visible.has(task.id) && scanner.taskUsage && !usagePending.has(task.id)) {
+        // Cold log parsing must not delay the database-backed board response.
+        const turnId = task.turnId;
+        const pending = Promise.resolve().then(() => scanner.taskUsage(task.id)).then(usage => {
+          if (usage && scanner.task(task.id)?.turnId === turnId) turnUsageCache.set(task.id, { turnId, usage: usage.latest });
+        }).catch(() => { /* Optional usage failure never hides a card. */ }).finally(() => usagePending.delete(task.id));
+        usagePending.set(task.id, pending);
+      }
+      tasks.push(cached ? { ...task, turnUsage: cached.usage } : task);
+    }
+    const present = new Set(tasks.map(task => task.id));
+    for (const id of turnUsageCache.keys()) if (!present.has(id)) turnUsageCache.delete(id);
+    result.snapshot = { ...result.snapshot, tasks };
+    const signature = JSON.stringify([result.snapshot.revision, result.snapshot.tasks.map((task) => [task.id, task.status, task.pullRequests, task.earlierPullRequest, task.turnUsage])]);
+    if (signature !== boardSignature) { boardRevision += 1; boardSignature = signature; }
+    return { ...result.snapshot, revision: boardRevision };
+  }
+  async function decoratedTask(task, force = false, includeHistory = false) {
+    if (!task) return task;
+    const settings = await readSettings();
+    if (!includeHistory) {
+      const { snapshot } = await github.enrich({ healthy: true, tasks: [task] }, settings, { force });
+      return snapshot.tasks[0];
     }
-    await monitor.refresh();
-    return monitor;
+    // History is display-only. Opening it fetches missing URLs, not saved statuses.
+    const urls = [...new Map([...(task.detailPullRequests ?? []), ...(task.pullRequests ?? [])].map(pr => [pr.url, pr])).values()];
+    const history = await github.enrich({ healthy: true, tasks: [{ ...task, pullRequests: urls }] }, settings, { force, detail: true });
+    const statuses = new Map(history.snapshot.tasks[0].pullRequests.map(pr => [pr.url, pr]));
+    // Classify only the latest turn, using the results already loaded above.
+    const { snapshot } = await github.enrich({ healthy: true, tasks: [task] }, settings, { force: false, scope: { taskIds: [] } });
+    return { ...snapshot.tasks[0], detailPullRequests: (task.detailPullRequests ?? []).map(pr => statuses.get(pr.url) ?? pr) };
   }
+  async function readSettings() {
+    try {
+      const values = storedSettingsSchema.parse({ ...settingsDefaults, ...JSON.parse(await readFile(settingsPath, "utf8")) });
+      return { ...values, githubClientId: values.githubClientId || DEFAULT_GITHUB_CLIENT_ID };
+    }
+    catch (error) {
+      if (error.code === "ENOENT") return { ...settingsDefaults };
+      throw new Error("TaskChef cannot read settings.json. Repair the file and refresh.");
+    }
+  }
+  server.server.registerCapabilities({ experimental: { "openai/settings": {
+    readTool: "taskchef_settings_read", updateTool: "taskchef_settings_update",
+  } } });
+  server.registerTool("taskchef_settings_read", {
+    title: "Read TaskChef settings", inputSchema: {},
+    outputSchema: { schema: z.record(z.string(), z.unknown()), values: settingsSchema, layout: z.array(z.record(z.string(), z.unknown())) },
+    annotations: { readOnlyHint: true, openWorldHint: false },
+  }, async () => {
+    const values = await readSettings();
+    let connected = false;
+    try { connected = (await github.auth(values.githubClientId, "status")).connected; } catch { /* Keep connection errors in the GitHub dialog. */ }
+    return { content: [], structuredContent: {
+      schema: { type: "object", properties: settingsProperties }, values: publicSettings(values),
+      layout: [{ kind: "group", title: "Chat visibility", items: Object.keys(visibilityFields).map(property => ({ kind: "property", property })) }, { kind: "group", title: "Card display", items: [{ kind: "property", property: "showCalendarDates" }, { kind: "property", property: "showCardUsage" }] }, { kind: "group", title: "GitHub", items: [{ kind: "tool", tool: "taskchef_github_settings", title: connected ? "Manage GitHub" : "Connect GitHub", description: "Sign in, manage repository access, or disconnect this computer." }] }],
+    } };
+  });
+  server.registerTool("taskchef_settings_update", {
+    title: "Update TaskChef settings",
+    inputSchema: { set: settingsSchema.partial().refine((values) => Object.keys(values).length > 0, "Set at least one setting.") },
+    outputSchema: { values: settingsSchema },
+    annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false, idempotentHint: true },
+  }, async ({ set }) => {
+    await mkdir(dirname(settingsPath), { recursive: true, mode: 0o700 });
+    const release = await acquireWorkspaceLock(dirname(settingsPath));
+    try {
+      const values = { ...await readSettings(), ...set };
+      await writeDurableAtomic(settingsPath, JSON.stringify(values));
+      return { content: [], structuredContent: { values: publicSettings(values) } };
+    } finally { await release(); }
+  });
   const originalClose = server.close.bind(server);
-  server.close = async () => {
-    monitor?.close();
-    usageSummaryMonitor?.close();
-    usageTracker?.close?.();
-    await originalClose();
-  };
+  server.close = async () => { scanner.close(); await originalClose(); };
   const appOnly = { ui: { resourceUri: TASKCHEF_APP_URI, visibility: ["app"] } };
-  function appSnapshot() {
-    const snapshot = monitor.snapshot();
-    return { ...snapshot, revision: appRevision, tasks: snapshot.tasks.map((task) => ({
-      ...task,
-      usage: usageSummaryMonitor.project(task),
-    })) };
-  }
   server.registerResource("TaskChef task board", TASKCHEF_APP_URI, {
-    description: "TaskChef sidebar task board",
-    mimeType: RESOURCE_MIME_TYPE,
-  }, async () => ({ contents: [{
-    uri: TASKCHEF_APP_URI,
-    mimeType: RESOURCE_MIME_TYPE,
-    text: await readFile(htmlPath, "utf8"),
+    description: "TaskChef read-only Codex session board", mimeType: RESOURCE_MIME_TYPE,
+    _meta: { ui: { csp: { resourceDomains: ["https:"] } } },
+  }, async () => ({ contents: [{ uri: TASKCHEF_APP_URI, mimeType: RESOURCE_MIME_TYPE, text: await readFile(htmlPath, "utf8"), _meta: { ui: { csp: { resourceDomains: ["https:"] } } } }] }));
+  server.registerResource("TaskChef GitHub settings", TASKCHEF_GITHUB_URI, { mimeType: RESOURCE_MIME_TYPE }, async () => ({ contents: [{
+    uri: TASKCHEF_GITHUB_URI, mimeType: RESOURCE_MIME_TYPE,
+    text: (await readFile(htmlPath, "utf8")).replace('<div id="root"', '<div data-taskchef-page="github" id="root"'),
   }] }));
+  server.registerTool("taskchef_github_settings", {
+    title: "Connect GitHub", inputSchema: {},
+    _meta: { ui: { resourceUri: TASKCHEF_GITHUB_URI } },
+    annotations: { readOnlyHint: true, openWorldHint: false },
+  }, async () => ({ structuredContent: { github: await github.auth((await readSettings()).githubClientId, "status") }, content: [] }));
   server.registerTool("open_taskchef_board", {
-    title: process.env.TASKCHEF_PREVIEW === "1" ? "TaskChef Preview" : "TaskChef",
-    description: "Show the local TaskChef task board in the Codex sidebar.",
-    inputSchema: {},
+    title: TASKCHEF_APP_NAME, description: "Show read-only local Codex session activity in the sidebar.", inputSchema: {},
     _meta: { ui: { resourceUri: TASKCHEF_APP_URI }, "openai/ui": { entrypoints: [{ type: "global" }] } },
     annotations: { readOnlyHint: true, openWorldHint: false },
   }, async () => {
-    await currentMonitor();
-    const snapshot = appSnapshot();
-    return { structuredContent: { taskCount: snapshot.tasks.length }, content: [{ type: "text", text: `TaskChef board: ${snapshot.tasks.length} tasks.` }] };
+    const snapshot = await scanner.refresh();
+    if (!snapshot.healthy) return { structuredContent: { taskCount: 0, error: snapshot.scan.error }, content: [{ type: "text", text: `TaskChef: ${snapshot.scan.error}` }] };
+    return { structuredContent: { taskCount: snapshot.tasks.length }, content: [{ type: "text", text: `TaskChef: ${snapshot.tasks.length} indexed chats. Visibility settings control which chats appear.` }] };
   });
   server.registerTool("taskchef_app_snapshot", {
-    title: "Refresh TaskChef board", description: "Read the local task board.",
-    inputSchema: { revision: z.number().int().nonnegative().optional() }, _meta: appOnly,
+    title: "Refresh TaskChef", description: "Read local Codex session metadata.",
+    inputSchema: { revision: z.number().int().nonnegative().optional(), force: z.boolean().optional(), project: z.string().max(1000).optional(), date: z.enum(["24h", "7d", "all"]).optional(), visibleTaskIds: z.array(taskIdSchema).max(500).optional() }, _meta: appOnly,
     annotations: { readOnlyHint: true, openWorldHint: false },
-  }, async ({ revision }) => {
-    await currentMonitor();
-    void Promise.resolve(usageTracker.preload?.(monitor.tasks)).catch(() => {});
-    if (revision !== undefined && revision === appRevision && monitor.unhealthy === false) {
-      return { structuredContent: { unchanged: true, revision: appRevision }, content: [] };
+  }, async ({ revision, force, project, date, visibleTaskIds }) => {
+    const settings = await readSettings();
+    const settingsUrl = await getSettingsUrl();
+    const { snapshot, notifications } = await notificationStore.reconcile(() => boardSnapshot(settings, force, { project, date: date ?? "all", taskIds: visibleTaskIds ?? [] }), settings);
+    if (!force && revision !== undefined && revision === snapshot.revision && snapshot.healthy !== false) {
+      return { structuredContent: { unchanged: true, revision: snapshot.revision, scan: snapshot.scan, settings: publicSettings(settings), settingsUrl, notifications, github: githubAuth, version: TASKCHEF_VERSION }, content: [] };
     }
-    return { structuredContent: { snapshot: appSnapshot() }, content: [] };
+    return { structuredContent: { snapshot, settings: publicSettings(settings), settingsUrl, notifications, github: githubAuth, version: TASKCHEF_VERSION }, content: [] };
   });
   server.registerTool("taskchef_app_task", {
-    title: "Read TaskChef task", description: "Read one task's details.",
-    inputSchema: { taskId: taskIdSchema }, _meta: appOnly,
+    title: "Read Codex chat metadata", description: "Read one local chat's metadata and its latest recorded request and response.",
+    inputSchema: { taskId: taskIdSchema, refreshGithub: z.boolean().optional() }, _meta: appOnly,
     annotations: { readOnlyHint: true, openWorldHint: false },
-  }, async ({ taskId }) => {
-    const task = (await currentMonitor()).tasks.find((candidate) => candidate.id === taskId);
+  }, async ({ taskId, refreshGithub }) => {
+    const snapshot = await scanner.refresh();
+    if (!snapshot.healthy) throw new Error(snapshot.scan.error);
+    const task = await decoratedTask(await scanner.taskDetail(taskId), refreshGithub === true, true);
     if (!task) throw new Error("Task not found.");
-    const usage = await usageTracker.get(task).catch(() => ({
-      status: "unavailable", reason: "Task usage is temporarily unavailable.", task: null, turns: {},
-    }));
-    return { structuredContent: { task: { ...task, ...taskGitHubProjection(task), usage } }, content: [] };
+    return { structuredContent: { task }, content: [] };
   });
-  server.registerTool("taskchef_app_transition", {
-    title: "Mark TaskChef task", description: "Apply a confirmed manual status transition.",
-    inputSchema: {
-      taskId: taskIdSchema,
-      actionId: z.string().uuid(),
-      expected: expectedSchema,
-      targetStatus: z.enum(["completed", "failed"]),
-    }, _meta: appOnly,
-    annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false },
-  }, async ({ taskId, actionId, expected, targetStatus }) => {
-    const result = await transition(workspace, taskId, { actionId, expected, targetStatus });
-    await (await currentMonitor()).refresh({ force: true });
-    return { structuredContent: { task: { ...result.task, ...taskGitHubProjection(result.task) }, idempotent: result.idempotent }, content: [] };
+  server.registerTool("taskchef_app_image", {
+    title: "Read reply image", description: "Read a local raster image referenced by the selected turn prompt or reply, up to 4 MiB.",
+    inputSchema: { taskId: taskIdSchema, expectedTurnId: z.string().min(1), expectedUrl: z.string().min(1) }, _meta: appOnly,
+    annotations: { readOnlyHint: true, openWorldHint: false },
+  }, async ({ taskId, expectedTurnId, expectedUrl }) => ({
+    structuredContent: { dataUrl: await scanner.taskImage(taskId, expectedTurnId, expectedUrl) }, content: [],
+  }));
+  server.registerTool("taskchef_app_set_scheduled", {
+    title: "Return chat to Scheduled", description: "Acknowledge the latest human turn and return an active scheduled chat to its queue.",
+    inputSchema: { taskId: taskIdSchema, expectedTurnId: z.string().min(1) }, _meta: appOnly,
+    annotations: { readOnlyHint: false, openWorldHint: false },
+  }, async ({ taskId, expectedTurnId }) => ({ structuredContent: { task: await decoratedTask(await scanner.setScheduled(taskId, expectedTurnId)) }, content: [] }));
+  server.registerTool("taskchef_app_set_done", {
+    title: "Mark chat Done in TaskChef", description: "Save or remove a local Done mark. Codex databases are never modified.",
+    inputSchema: { taskId: taskIdSchema, expectedTurnId: z.string().min(1), done: z.boolean() }, _meta: appOnly,
+    annotations: { readOnlyHint: false, openWorldHint: false },
+  }, async ({ taskId, expectedTurnId, done }) => {
+    let mergedPrUrls = [];
+    if (done) {
+      const snapshot = await scanner.refresh({ force: true });
+      if (!snapshot.healthy) throw new Error(snapshot.scan.error);
+      const current = await decoratedTask(scanner.task(taskId));
+      if (!current || current.turnId !== expectedTurnId) throw new Error("Chat changed. Refresh and try again.");
+      mergedPrUrls = (current.pullRequests ?? []).filter(pr => pr.state === "merged").map(pr => pr.url);
+    }
+    const task = await decoratedTask(await scanner.setDone(taskId, expectedTurnId, done, mergedPrUrls));
+    return { structuredContent: { task, notifications: done ? await notificationStore.confirmation(task) : undefined }, content: [] };
+  });
+  for (const [name, resourceUri] of [["taskchef_app_github", TASKCHEF_APP_URI], ["taskchef_github_settings_auth", TASKCHEF_GITHUB_URI]]) server.registerTool(name, {
+    title: "Connect GitHub for PR status", description: "Start device sign-in, check approval, or remove local credentials. Tokens stay in the system credential store.",
+    inputSchema: { action: z.enum(["status", "start", "poll", "disconnect"]) }, _meta: { ui: { resourceUri, visibility: ["app"] } },
+    annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+  }, async ({ action }) => ({ structuredContent: { github: await github.auth((await readSettings()).githubClientId, action) }, content: [] }));
+  server.registerTool("taskchef_app_notifications", {
+    title: "Update TaskChef notifications",
+    inputSchema: { action: z.enum(["read", "read_all", "clear", "error"]), id: z.string().optional(), taskId: taskIdSchema.optional(), operation: z.enum(["open", "done", "move", "copy", "settings"]).optional(), error: z.string().max(1000).optional() },
+    _meta: appOnly, annotations: { readOnlyHint: false, openWorldHint: false },
+  }, async ({ action, id, taskId, operation, error }) => {
+    if (action === "read" && !id) throw new Error("Notification ID required.");
+    if (action === "error" && (!operation || !error)) throw new Error("Operation and error required.");
+    const task = taskId ? scanner.task(taskId) : null;
+    const notifications = await notificationStore.action({ action, id, task, operation, error });
+    return { structuredContent: { notifications }, content: [] };
+  });
+  for (const [name, resourceUri] of [["taskchef_app_open_settings", TASKCHEF_APP_URI], ["taskchef_github_settings_open_plugin", TASKCHEF_GITHUB_URI]]) server.registerTool(name, {
+    title: "Open TaskChef settings", description: "Open this installed plugin's native settings page in Codex.",
+    inputSchema: {}, _meta: { ui: { resourceUri, visibility: ["app"] } },
+    annotations: { readOnlyHint: false, openWorldHint: false },
+  }, async () => {
+    await openSettings(await getSettingsUrl());
+    return { structuredContent: { message: "Requested plugin settings in Codex." }, content: [] };
   });
   server.registerTool("taskchef_app_open_chat", {
-    title: "Open TaskChef chat", description: "Open the task's Codex chat or configured project.",
+    title: "Open Codex chat", description: "Open the selected Codex chat.",
     inputSchema: { taskId: taskIdSchema }, _meta: appOnly,
     annotations: { readOnlyHint: false, openWorldHint: false },
   }, async ({ taskId }) => {
-    const task = (await currentMonitor()).tasks.find((candidate) => candidate.id === taskId);
+    const snapshot = await scanner.refresh();
+    if (!snapshot.healthy) throw new Error(snapshot.scan.error);
+    const task = scanner.task(taskId);
     if (!task) throw new Error("Task not found.");
-    if (isCodexThreadDeepLinkId(task.threadId)) {
-      await openThread(task.threadId);
-      return { structuredContent: { message: "Opened chat in Codex." }, content: [] };
-    }
-    const trusted = (await readConfiguration(workspace, { checkPaths: false })).projects
-      .find((project) => project.path === task.project.path);
-    if (!trusted) throw new Error("This historical task no longer matches a configured project.");
-    const canonicalPath = trusted.isGitRepository
-      ? await canonicalGitRoot(trusted.path) : await canonicalDirectory(trusted.path);
-    if (canonicalPath !== trusted.path) throw new Error("This configured project has moved.");
-    await openProject(canonicalPath);
-    return { structuredContent: { message: "Opened project in Codex. Select the recorded thread there." }, content: [] };
+    if (!isCodexThreadDeepLinkId(task.threadId)) throw new Error("This chat cannot be opened directly.");
+    await openThread(task.threadId);
+    return { structuredContent: { message: "Opened chat in Codex." }, content: [] };
   });
 }

package/src/mcp.js

@@ -1,4 +1,5 @@
 import path from "node:path";
+import { readFileSync } from "node:fs";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
 import {
@@ -20,6 +21,12 @@ import { DASHBOARD_SERVER_VERSION, TASKCHEF_VERSION } from "./version.js";
 import { createUsageTracker } from "./usage-tracker.js";
 import { registerTaskChefApp } from "./mcp-app.js";
 
+const sidebarSvg = readFileSync(new URL("../assets/taskchef-sidebar.svg", import.meta.url), "utf8");
+const sidebarIcons = [["light", "#333333"], ["dark", "#dddddd"]].map(([theme, color]) => ({
+  src: `data:image/svg+xml;base64,${Buffer.from(sidebarSvg.replace("<svg ", `<svg style="color:${color}" `)).toString("base64")}`,
+  mimeType: "image/svg+xml", sizes: ["20x20"], theme,
+}));
+
 const projectSchema = z.object({
   name: z.string(),
   path: z.string(),
@@ -234,7 +241,7 @@ export function createTaskChefMcpServer({
 } = {}) {
   const reportingDestination = `Store lifecycle state and summaries in the configured local TaskChef dashboard log ${JSON.stringify(path.resolve(workspace, "tasks.jsonl"))}. GitHub URLs are stored as references, not published to GitHub. Also triggers local Codex usage tracking in ${JSON.stringify(path.resolve(workspace, ".taskchef-usage.json"))}. Exclude secrets. `;
   const server = new McpServer(
-    { name: "taskchef", version: TASKCHEF_VERSION },
+    { name: "taskchef", version: TASKCHEF_VERSION, icons: sidebarIcons },
     {
       instructions:
         "Prepare with prepare_dispatch, call record_task before creating the Codex task, then create it natively and return immediately. Follow the active TaskChef skill for role-specific sequencing of the identity and state tools.",

package/src/next-cache.js

@@ -0,0 +1,16 @@
+import { mkdir, rename, stat } from "node:fs/promises";
+import { dirname } from "node:path";
+import { acquireWorkspaceLock } from "./workspace.js";
+
+// Serialize migrations between plugin processes. Never replace a newer cache.
+export async function migrateCache(previous, current) {
+  if (!previous || previous === current) return;
+  await mkdir(dirname(current), { recursive: true, mode: 0o700 });
+  const release = await acquireWorkspaceLock(dirname(current));
+  try {
+    try { await stat(current); return; }
+    catch (error) { if (error.code !== "ENOENT") throw error; }
+    try { await rename(previous, current); }
+    catch (error) { if (error.code !== "ENOENT") throw error; }
+  } finally { await release(); }
+}