taskchef 8.3.0 → 8.3.1

package/src/dashboard-session-process.js

@@ -1,174 +1,83 @@
 import { realpath } from "node:fs/promises";
 
 import { createDashboardServer } from "./dashboard.js";
-import {
-  dashboardHandoffMetadata,
-  dashboardOwnerMetadata,
-  validDashboardControlSecret,
-  writeDashboardHandoff,
-  writeDashboardOwner,
-} from "./dashboard-ownership.js";
-import {
-  MAX_DASHBOARD_SESSION_PIDS,
-  createDashboardSessionLease,
-  validSessionPid,
-} from "./dashboard-session.js";
+import { createDashboardSessionLease, validSessionPid } from "./dashboard-session.js";
 import { DASHBOARD_SERVER_VERSION, TASKCHEF_VERSION } from "./version.js";
 
 export async function runDashboardSessionProcess({
   workspace = process.env.TASKCHEF_DASHBOARD_WORKSPACE,
   host = process.env.TASKCHEF_DASHBOARD_HOST ?? "127.0.0.1",
   port = Number(process.env.TASKCHEF_DASHBOARD_PORT ?? 3210),
-  secret = process.env.TASKCHEF_DASHBOARD_SECRET,
   sessionPid = Number(process.env.TASKCHEF_DASHBOARD_SESSION_PID),
-  sessionPids,
   taskchefVersion = TASKCHEF_VERSION,
   serverVersion = DASHBOARD_SERVER_VERSION,
   createServer = createDashboardServer,
-  writeOwner = writeDashboardOwner,
-  writeHandoff = writeDashboardHandoff,
   createLease = createDashboardSessionLease,
   processObject = process,
   signal,
   checkIntervalMs = Number(process.env.TASKCHEF_DASHBOARD_CHECK_INTERVAL_MS ?? 1_000),
   exitGraceMs = Number(process.env.TASKCHEF_DASHBOARD_EXIT_GRACE_MS ?? 15_000),
 } = {}) {
-  if (processObject.env) delete processObject.env.TASKCHEF_DASHBOARD_SECRET;
-  sessionPids ??= JSON.parse(process.env.TASKCHEF_DASHBOARD_SESSION_PIDS ?? "[]");
-  if (!workspace) throw new Error("dashboard session workspace is required");
-  if (!validDashboardControlSecret(secret)) {
-    throw new Error("dashboard session control credential is invalid");
+  if (processObject.env) {
+    delete processObject.env.TASKCHEF_DASHBOARD_SECRET;
+    delete processObject.env.TASKCHEF_DASHBOARD_SESSION_PIDS;
   }
+  if (!workspace) throw new Error("dashboard session workspace is required");
   if (!validSessionPid(sessionPid)) throw new Error("dashboard session PID is invalid");
-  if (!Array.isArray(sessionPids) || sessionPids.length > MAX_DASHBOARD_SESSION_PIDS
-      || sessionPids.some((pid) => !validSessionPid(pid))
-      || new Set([sessionPid, ...sessionPids]).size > MAX_DASHBOARD_SESSION_PIDS) {
-    throw new Error("dashboard transferred session PIDs are invalid");
-  }
 
   const canonicalWorkspace = await realpath(workspace);
   let server = null;
   let lease = null;
   let closePromise = null;
+  let closeChain = Promise.resolve();
+  let closedLease = null;
+  let closedServer = null;
   let closing = false;
-  let publishingOwner = false;
-  let deferredClose = null;
   const abortError = () => Object.assign(new Error("dashboard session startup was cancelled"), {
     code: "TASKCHEF_DASHBOARD_START_TIMEOUT",
   });
-  const startupClosedError = () => Object.assign(
-    new Error("dashboard session closed during startup"),
-    { code: "TASKCHEF_DASHBOARD_START_EXIT" },
-  );
   const removeListeners = () => {
     processObject.off("SIGINT", close);
     processObject.off("SIGTERM", close);
   };
-  const performClose = async () => {
-    let cleanupError = null;
-    try {
-      lease?.close();
-    } catch (error) {
-      cleanupError = error;
-    }
-    await server?.close();
-    if (cleanupError) throw cleanupError;
-  };
   const close = () => {
     closing = true;
-    if (!closePromise && publishingOwner) {
-      closePromise = new Promise((resolve, reject) => {
-        deferredClose = { resolve, reject };
-      }).finally(removeListeners);
-    } else if (!closePromise) {
-      closePromise = performClose().finally(removeListeners);
-    }
+    closePromise = closeChain.then(async () => {
+      let failure = null;
+      if (lease && lease !== closedLease) {
+        closedLease = lease;
+        try { lease.close(); } catch (error) { failure = error; }
+      }
+      if (server && server !== closedServer) {
+        closedServer = server;
+        try { await server.close(); } catch (error) { failure ??= error; }
+      }
+      if (failure) throw failure;
+    }).finally(removeListeners);
+    closeChain = closePromise.catch(() => {});
     return closePromise;
   };
-  const onAbort = () => {
-    void close().catch(() => {});
-  };
+  const onAbort = () => { void close().catch(() => {}); };
   if (signal?.aborted) throw abortError();
   signal?.addEventListener("abort", onAbort, { once: true });
   processObject.once("SIGINT", close);
   processObject.once("SIGTERM", close);
-  const control = {
-    secret,
-    onShutdown: close,
-    onSession: (pid) => {
-      if (closing) {
-        throw Object.assign(new Error("dashboard session is retiring"), {
-          code: "TASKCHEF_DASHBOARD_SESSION_RETIRING",
-        });
-      }
-      lease.register(pid);
-    },
-    onHandoff: (pid) => {
-      if (closing) {
-        throw Object.assign(new Error("dashboard session is retiring"), {
-          code: "TASKCHEF_DASHBOARD_SESSION_RETIRING",
-        });
-      }
-      lease.register(pid);
-      return lease.snapshot();
-    },
-    onHandoffFinalized: ({ id, pids }) => writeHandoff(
-      canonicalWorkspace,
-      dashboardHandoffMetadata({
-        workspace: canonicalWorkspace,
-        host,
-        port: server.port,
-        taskchefVersion,
-        serverVersion,
-        id,
-        pids,
-        secret,
-      }),
-    ),
-  };
 
   try {
-    server = await createServer({
-      workspace: canonicalWorkspace,
-      host,
-      port,
-      taskchefVersion,
-      serverVersion,
-      launcher: "session",
-      control,
-    });
-    if (closing) {
-      closePromise = null;
-      if (signal?.aborted) throw abortError();
-      throw startupClosedError();
-    }
+    const control = {
+      onShutdown: close,
+      onSession: (pid) => {
+        if (closing) throw Object.assign(new Error("dashboard session is retiring"), {
+          code: "TASKCHEF_DASHBOARD_SESSION_RETIRING",
+        });
+        lease.register(pid);
+      },
+    };
+    server = await createServer({ workspace: canonicalWorkspace, host, port,
+      taskchefVersion, serverVersion, launcher: "session", control });
+    if (closing || signal?.aborted) throw abortError();
     lease = createLease({ initialPid: sessionPid, checkIntervalMs, exitGraceMs, onExpire: close });
-    for (const pid of sessionPids) lease.register(pid);
-    publishingOwner = true;
-    try {
-      await writeOwner(canonicalWorkspace, dashboardOwnerMetadata({
-        workspace: canonicalWorkspace,
-        host,
-        port: server.port,
-        taskchefVersion,
-        serverVersion,
-        launcher: "session",
-        secret,
-      }), { signal });
-    } finally {
-      publishingOwner = false;
-      if (deferredClose) {
-        const pending = deferredClose;
-        deferredClose = null;
-        void performClose().then(pending.resolve, pending.reject);
-      }
-    }
-    if (closing) {
-      await closePromise;
-      if (signal?.aborted) throw abortError();
-      throw startupClosedError();
-    }
-    if (signal?.aborted) throw abortError();
+    if (closing || signal?.aborted) throw abortError();
     signal?.removeEventListener("abort", onAbort);
     return { server, lease, close };
   } catch (error) {

package/src/dashboard-session.js

@@ -1,7 +1,6 @@
 const DEFAULT_CHECK_INTERVAL_MS = 1_000;
 const DEFAULT_EXIT_GRACE_MS = 15_000;
 export const MAX_DASHBOARD_SESSION_PIDS = 64;
-export const MAX_TRANSFERRED_DASHBOARD_SESSION_PIDS = MAX_DASHBOARD_SESSION_PIDS - 1;
 
 export function processIsAlive(pid, processObject = process) {
   try {
@@ -77,10 +76,6 @@ export function createDashboardSessionLease({
       pids.add(pid);
       absentSince = null;
     },
-    snapshot() {
-      activePids();
-      return [...pids];
-    },
     tick,
     close() {
       if (timer) clearInterval(timer);

package/src/dashboard.js

@@ -31,22 +31,11 @@ import { createUsageTracker } from "./usage-tracker.js";
 import { readCcusageRuntimeInfo, readUsageStore, usageStorePath } from "./usage.js";
 import { reportedWorkSummary } from "./reported-work.js";
 import {
-  MAX_DASHBOARD_SESSION_PIDS,
-  MAX_TRANSFERRED_DASHBOARD_SESSION_PIDS,
-  validSessionPid,
-} from "./dashboard-session.js";
-import {
-  DASHBOARD_CONTROL_CHALLENGE_PATH,
-  DASHBOARD_CONTROL_HANDOFF_COMMIT_PATH,
   DASHBOARD_CONTROL_SESSION_PATH,
-  DASHBOARD_CONTROL_HANDOFF_PATH,
   DASHBOARD_CONTROL_SHUTDOWN_PATH,
-  createDashboardControlNonce,
-  dashboardControlProof,
-  validDashboardControlNonce,
-  validDashboardControlSecret,
-  verifyDashboardControlProof,
-} from "./dashboard-ownership.js";
+  exactDashboardIdentity,
+  validDashboardControlRequest,
+} from "./dashboard-control.js";
 
 const TASKS_FILE_NAME = "tasks.jsonl";
 const STATIC_ROOT = fileURLToPath(new URL("./dashboard/", import.meta.url));
@@ -57,11 +46,6 @@ const DEFAULT_MAX_FILE_BYTES = 16 * 1024 * 1024;
 const DEFAULT_MAX_TASKS = 2_000;
 const DEFAULT_MAX_EVENT_CLIENTS = 16;
 const DEFAULT_CALCULATING_USAGE_STALE_MS = 120_000;
-const DASHBOARD_HANDOFF_PREPARE_TTL_MS = 5_000;
-const DASHBOARD_HANDOFF_COMMIT_GRACE_MS = 250;
-const DASHBOARD_HANDOFF_COMMIT_RETRY_MS = 1_000;
-const DASHBOARD_CONTROL_NONCE_LIMIT = 4_096;
-const DASHBOARD_CONTROL_NONCE_TTL_MS = 5 * 60_000;
 const MAX_MANUAL_TRANSITION_BODY_BYTES = 4 * 1024;
 export const DASHBOARD_HEALTH_PATH = "/api/health";
 export const DASHBOARD_HEALTH_MAX_BYTES = 8 * 1024;
@@ -792,33 +776,6 @@ function publicMonitorError() {
   };
 }
 
-export function createDashboardControlReplayCache({
-  maximum = DASHBOARD_CONTROL_NONCE_LIMIT,
-  ttlMs = DASHBOARD_CONTROL_NONCE_TTL_MS,
-  now = Date.now,
-} = {}) {
-  if (!Number.isSafeInteger(maximum) || maximum <= 0) {
-    throw new Error("dashboard control replay limit must be a positive integer");
-  }
-  if (!Number.isFinite(ttlMs) || ttlMs <= 0 || typeof now !== "function") {
-    throw new Error("dashboard control replay window is invalid");
-  }
-  const entries = new Map();
-  return {
-    accept(nonce) {
-      const timestamp = now();
-      for (const [candidate, expiresAt] of entries) {
-        if (expiresAt > timestamp) break;
-        entries.delete(candidate);
-      }
-      if (entries.has(nonce) || entries.size >= maximum) return false;
-      entries.set(nonce, timestamp + ttlMs);
-      return true;
-    },
-    get size() { return entries.size; },
-  };
-}
-
 export async function createDashboardServer({
   archiveEnabled = CODEX_CHAT_ARCHIVE_ENABLED,
   archiveThread = archiveThreadInCodex,
@@ -840,7 +797,6 @@ export async function createDashboardServer({
   resolveUsageProvider = readCcusageRuntimeInfo,
   updateRole = updateModelRole,
   control = null,
-  controlReplayCache = createDashboardControlReplayCache(),
 } = {}) {
   if (!LOOPBACK_HOSTS.has(host)) {
     throw new Error("dashboard host must be a loopback address");
@@ -858,11 +814,9 @@ export async function createDashboardServer({
     throw new Error("dashboard launcher must be mcp, session, or standalone");
   }
   if (control !== null && (!new Set(["mcp", "session"]).has(launcher)
-      || !validDashboardControlSecret(control?.secret)
       || typeof control?.onShutdown !== "function"
-      || (launcher === "session" && (typeof control?.onSession !== "function"
-        || typeof control?.onHandoff !== "function")))) {
-    throw new Error("dashboard control requires a valid TaskChef ownership controller");
+      || (launcher === "session" && typeof control?.onSession !== "function"))) {
+    throw new Error("dashboard control requires TaskChef session callbacks");
   }
   let requestHandler = (_request, response) => {
     sendJson(response, 503, { message: "TaskChef dashboard is initializing." });
@@ -908,8 +862,6 @@ export async function createDashboardServer({
   const clients = new Set();
   const archiveRequests = new Set();
   let usageProviderPromise = null;
-  let controlHandoff = null;
-  let controlHandoffTimer = null;
 
   const broadcast = (event, value) => {
     const payload = ssePayload(event, value);
@@ -970,37 +922,29 @@ export async function createDashboardServer({
       return;
     }
 
-    if (url.pathname === DASHBOARD_CONTROL_CHALLENGE_PATH && method === "GET") {
-      const nonce = url.searchParams.get("nonce");
-      if (!control || !validDashboardControlNonce(nonce)) {
-        sendJson(response, control ? 400 : 404, { message: "Not found." });
-        return;
-      }
-      sendJson(response, 200, {
-        schemaVersion: 1,
-        nonce,
-        proof: dashboardControlProof(control.secret, "challenge", nonce),
-      });
-      return;
-    }
-
     if (url.pathname === DASHBOARD_CONTROL_SHUTDOWN_PATH && method === "POST") {
       if (!control) {
         sendJson(response, 404, { message: "Not found." });
         return;
       }
+      if (!validDashboardControlRequest(request, {
+        authority: allowedAuthority, origin: allowedOrigin, action: "shutdown",
+      })) {
+        sendJson(response, 403, { message: "Dashboard control request was refused." });
+        return;
+      }
       const body = await readBoundedJsonBody(request);
-      const nonce = body?.nonce;
-      if (!verifyDashboardControlProof(control.secret, "shutdown", nonce, body?.proof)) {
-        sendJson(response, 403, { message: "Dashboard control authentication failed." });
+      if (!body || Object.keys(body).length !== 2 || body.reason !== "version-replacement"
+          || !("expectedIdentity" in body)) {
+        sendJson(response, 400, { message: "Dashboard shutdown request was malformed." });
         return;
       }
-      if (!controlReplayCache.accept(nonce)) {
-        sendJson(response, 409, { message: "Dashboard control credential was already used." });
+      if (!exactDashboardIdentity(identity, body.expectedIdentity)) {
+        sendJson(response, 409, { schemaVersion: 1, accepted: false, reason: "identity-mismatch" });
         return;
       }
       sendJson(response, 202, { schemaVersion: 1, accepted: true });
-      setImmediate(() => { void control.onShutdown().catch(() => {}); });
+      setImmediate(() => { void Promise.resolve(control.onShutdown()).catch(() => {}); });
       return;
     }
 
@@ -1009,25 +953,21 @@ export async function createDashboardServer({
         sendJson(response, 404, { message: "Not found." });
         return;
       }
-      const body = await readBoundedJsonBody(request);
-      const nonce = body?.nonce;
-      const pid = body?.pid;
-      if (!Number.isSafeInteger(pid) || pid <= 1
-          || !verifyDashboardControlProof(
-            control.secret, `session:${pid}`, nonce, body?.proof,
-          )) {
-        sendJson(response, 403, { message: "Dashboard control authentication failed." });
+      if (!validDashboardControlRequest(request, {
+        authority: allowedAuthority, origin: allowedOrigin, action: "session",
+      })) {
+        sendJson(response, 403, { message: "Dashboard control request was refused." });
         return;
       }
-      if (controlHandoff) {
-        sendJson(response, 409, {
-          message: "Dashboard handoff is already in progress.",
-          reason: "retiring",
-        });
+      const body = await readBoundedJsonBody(request);
+      const pid = body?.pid;
+      if (!body || Object.keys(body).length !== 2 || !Number.isSafeInteger(pid) || pid <= 1
+          || !("expectedIdentity" in body)) {
+        sendJson(response, 400, { message: "Dashboard session request was malformed." });
         return;
       }
-      if (!controlReplayCache.accept(nonce)) {
-        sendJson(response, 409, { message: "Dashboard control credential was already used." });
+      if (!exactDashboardIdentity(identity, body.expectedIdentity)) {
+        sendJson(response, 409, { schemaVersion: 1, accepted: false, reason: "identity-mismatch" });
         return;
       }
       try {
@@ -1035,8 +975,6 @@ export async function createDashboardServer({
         sendJson(response, 200, {
           schemaVersion: 1,
           accepted: true,
-          nonce,
-          proof: dashboardControlProof(control.secret, `session-accepted:${pid}`, nonce),
         });
       } catch (error) {
         sendJson(response, 409, {
@@ -1049,197 +987,6 @@ export async function createDashboardServer({
       return;
     }
 
-    if (url.pathname === DASHBOARD_CONTROL_HANDOFF_PATH && method === "POST") {
-      if (!control || typeof control.onHandoff !== "function") {
-        sendJson(response, 404, { message: "Not found." });
-        return;
-      }
-      const body = await readBoundedJsonBody(request);
-      const nonce = body?.nonce;
-      const pid = body?.pid;
-      if (!Number.isSafeInteger(pid) || pid <= 1
-          || !verifyDashboardControlProof(
-            control.secret, `handoff:${pid}`, nonce, body?.proof,
-          )) {
-        sendJson(response, 403, { message: "Dashboard control authentication failed." });
-        return;
-      }
-      if (!controlReplayCache.accept(nonce)) {
-        sendJson(response, 409, { message: "Dashboard control credential was already used." });
-        return;
-      }
-      if (controlHandoff) {
-        if (controlHandoff.pending || controlHandoff.finalizing || controlHandoff.finalized) {
-          sendJson(response, 409, {
-            message: "Dashboard handoff is already in progress.",
-            reason: "retiring",
-          });
-          return;
-        }
-        try {
-          const pids = controlHandoff.participants.has(pid)
-            ? controlHandoff.pids
-            : await control.onHandoff(pid);
-          if (!Array.isArray(pids) || pids.length > MAX_DASHBOARD_SESSION_PIDS
-              || pids.some((value) => !validSessionPid(value))
-              || new Set(pids).size !== pids.length
-              || !pids.includes(pid)) {
-            throw new Error("dashboard handoff returned invalid session leases");
-          }
-          controlHandoff.pids = pids;
-          controlHandoff.participants.add(pid);
-          const { id } = controlHandoff;
-          sendJson(response, 200, {
-            schemaVersion: 1,
-            accepted: true,
-            id,
-            pids,
-            nonce,
-            proof: dashboardControlProof(
-              control.secret,
-              `handoff-prepared:${pid}:${id}:${JSON.stringify(pids)}`,
-              nonce,
-            ),
-          });
-        } catch {
-          sendJson(response, 409, {
-            message: "Dashboard handoff was refused.",
-            reason: "refused",
-          });
-        }
-        return;
-      }
-      controlHandoff = { pid, pending: true, committed: false };
-      try {
-        const pids = await control.onHandoff(pid);
-        if (!Array.isArray(pids) || pids.length > MAX_DASHBOARD_SESSION_PIDS
-            || pids.some((value) => !validSessionPid(value))
-            || new Set(pids).size !== pids.length
-            || !pids.includes(pid)) {
-          throw new Error("dashboard handoff returned invalid session leases");
-        }
-        const id = createDashboardControlNonce();
-        controlHandoff = {
-          id,
-          pid,
-          pids,
-          participants: new Set([pid]),
-          pending: false,
-          committed: false,
-        };
-        controlHandoffTimer = setTimeout(() => {
-          if (controlHandoff?.id === id && !controlHandoff.committed) controlHandoff = null;
-          controlHandoffTimer = null;
-        }, DASHBOARD_HANDOFF_PREPARE_TTL_MS);
-        controlHandoffTimer.unref?.();
-        sendJson(response, 200, {
-          schemaVersion: 1,
-          accepted: true,
-          id,
-          pids,
-          nonce,
-          proof: dashboardControlProof(
-            control.secret,
-            `handoff-prepared:${pid}:${id}:${JSON.stringify(pids)}`,
-            nonce,
-          ),
-        });
-      } catch {
-        if (controlHandoff?.pid === pid && controlHandoff.pending) controlHandoff = null;
-        sendJson(response, 409, {
-          message: "Dashboard handoff was refused.",
-          reason: "refused",
-        });
-      }
-      return;
-    }
-
-    if (url.pathname === DASHBOARD_CONTROL_HANDOFF_COMMIT_PATH && method === "POST") {
-      if (!control || typeof control.onHandoff !== "function") {
-        sendJson(response, 404, { message: "Not found." });
-        return;
-      }
-      const body = await readBoundedJsonBody(request);
-      const nonce = body?.nonce;
-      const id = body?.id;
-      if (!validDashboardControlNonce(id)
-          || !verifyDashboardControlProof(
-            control.secret, `handoff-commit:${id}`, nonce, body?.proof,
-          )) {
-        sendJson(response, 403, { message: "Dashboard control authentication failed." });
-        return;
-      }
-      if (!controlReplayCache.accept(nonce)) {
-        sendJson(response, 409, { message: "Dashboard control credential was already used." });
-        return;
-      }
-      if (!controlHandoff || controlHandoff.id !== id) {
-        sendJson(response, 409, {
-          message: "Dashboard handoff preparation expired or did not match.",
-          reason: "refused",
-        });
-        return;
-      }
-      if (!controlHandoff.commitPromise) {
-        controlHandoff.committed = true;
-        if (controlHandoffTimer) clearTimeout(controlHandoffTimer);
-        controlHandoffTimer = null;
-        controlHandoff.commitPromise = new Promise((resolve, reject) => {
-          const finalizationTimer = setTimeout(async () => {
-            try {
-              controlHandoff.finalizing = true;
-              const pids = await control.onHandoff(controlHandoff.pid);
-              if (!Array.isArray(pids)
-                  || pids.length > MAX_TRANSFERRED_DASHBOARD_SESSION_PIDS
-                  || pids.some((value) => !validSessionPid(value))
-                  || new Set(pids).size !== pids.length
-                  || !pids.includes(controlHandoff.pid)) {
-                throw new Error("dashboard handoff returned invalid final session leases");
-              }
-              controlHandoff.pids = pids;
-              await control.onHandoffFinalized?.({ id, pids });
-              controlHandoff.finalized = true;
-              resolve(pids);
-            } catch (error) {
-              reject(error);
-            }
-          }, DASHBOARD_HANDOFF_COMMIT_GRACE_MS);
-          finalizationTimer.unref?.();
-        });
-      }
-      let pids;
-      try {
-        pids = await controlHandoff.commitPromise;
-      } catch {
-        if (controlHandoff?.id === id) controlHandoff = null;
-        sendJson(response, 409, {
-          message: "Dashboard handoff finalization was refused.",
-          reason: "refused",
-        });
-        return;
-      }
-      sendJson(response, 202, {
-        schemaVersion: 1,
-        accepted: true,
-        id,
-        pids,
-        nonce,
-        proof: dashboardControlProof(
-          control.secret,
-          `handoff-committed:${id}:${JSON.stringify(pids)}`,
-          nonce,
-        ),
-      });
-      if (!controlHandoff.shutdownScheduled) {
-        controlHandoff.shutdownScheduled = true;
-        const shutdownTimer = setTimeout(() => {
-          void control.onShutdown().catch(() => {});
-        }, DASHBOARD_HANDOFF_COMMIT_RETRY_MS);
-        shutdownTimer.unref?.();
-      }
-      return;
-    }
-
     if (url.pathname === "/api/settings" && method === "GET") {
       const profiles = [{ id: "personal", project: "Personal", ...await resolveRoles({ includeCatalog: true }) }];
       usageProviderPromise ??= Promise.resolve(resolveUsageProvider()).catch(() => ({

package/src/mcp.js

@@ -109,7 +109,7 @@ const preparationSchema = z.object({
 
 const dashboardSchema = z.object({
   action: z.enum(["started", "reused"]),
-  launcher: z.literal("session"),
+  launcher: z.enum(["session", "standalone", "mcp"]),
   url: z.string().url(),
   workspace: z.string(),
   taskchefVersion: z.string(),
@@ -126,7 +126,7 @@ function toolResult(key, value, message) {
 function dashboardAutostartDiagnostic(error) {
   const message = typeof error?.message === "string" ? error.message : "";
   if (typeof error?.staleTaskchefVersion === "string") {
-    return `TaskChef dashboard autostart skipped: verified older TaskChef ${error.staleTaskchefVersion} listener could not complete authenticated handoff; it was left untouched.`;
+    return `TaskChef dashboard autostart skipped: recognized older TaskChef ${error.staleTaskchefVersion} listener refused graceful shutdown; it was left running.`;
   }
   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.";
@@ -204,7 +204,7 @@ export function createTaskChefMcpServer({
     {
       title: "Ensure TaskChef dashboard",
       description:
-        "Best-effort ensure the canonical TaskChef dashboard is available on 127.0.0.1:3210. Starts or reuses the authenticated TaskChef dashboard for this Codex session and canonical workspace; verified older TaskChef session listeners are handed off to the installed version, while standalone and unknown listeners are never terminated or replaced.",
+        "Best-effort ensure the canonical TaskChef dashboard is available on 127.0.0.1:3210. Starts or reuses the exact recognized TaskChef dashboard for this Codex session and canonical workspace; recognized older same-workspace listeners are gracefully restarted to the installed version, while newer and unknown listeners remain running.",
       inputSchema: {},
       outputSchema: { dashboard: dashboardSchema },
       annotations: {