taskchef 7.3.0 → 7.5.0

package/src/cli.js

@@ -14,6 +14,7 @@ import {
   initializeWorkspace,
   listProjects,
   listTasks,
+  migrateTaskLog,
   prepareDispatch,
   recordTask,
   removeProject,
@@ -182,11 +183,28 @@ function taskDetails(task) {
     `Updated by: ${singleLineDetail(task.updatedBy ?? "-")}`,
     `Task ID: ${singleLineDetail(task.id)}`,
     `Thread ID: ${singleLineDetail(task.threadId ?? "-")}`,
+    `Result count: ${task.results.length}`,
+    "Result history (newest first):",
+    ...[...task.results].reverse().map((result) => (
+      `- ${singleLineDetail(result.updatedAt)} | ${singleLineDetail(result.status)} | turn ${singleLineDetail(result.turnId ?? "-")} | ${singleLineDetail(result.summary)}`
+    )),
     "Instruction:",
     task.instruction,
   ].join("\n");
 }
 
+async function migrate(args) {
+  validateCommandArgs(args, 2, { values: ["--workspace"], switches: ["--json"] });
+  const result = await migrateTaskLog(workspaceRoot(args));
+  print(result, args, (value) => [
+    `Task log: ${value.action}`,
+    `Tasks: ${value.taskCount}`,
+    `Migrated: ${value.migratedCount}`,
+    `Backup: ${value.backupPath ?? "not needed"}`,
+  ].join("\n"));
+  return 0;
+}
+
 async function readTaskForShow(workspace, taskId) {
   const id = requireSafeId(taskId, "taskId");
   const tasks = await listTasks(workspace);
@@ -409,10 +427,22 @@ async function dashboard(args) {
     values: ["--port", "--workspace"],
     switches: ["--json"],
   });
-  const server = await createDashboardServer({
-    workspace: workspaceRoot(args),
-    port: dashboardPort(args),
-  });
+  const port = dashboardPort(args);
+  let server;
+  try {
+    server = await createDashboardServer({
+      workspace: workspaceRoot(args),
+      port,
+    });
+  } catch (error) {
+    if (error?.code === "EADDRINUSE") {
+      throw new Error(
+        `dashboard port 127.0.0.1:${port} is already in use; `
+        + "stop the existing listener or choose another --port (TaskChef will not terminate it)",
+      );
+    }
+    throw error;
+  }
   print({
     schemaVersion: 1,
     url: server.url,
@@ -444,6 +474,7 @@ Usage:
   taskchef doctor [--json] [--workspace <path>]
   taskchef workspace path [--json] [--workspace <path>]
   taskchef workspace init [--register-codex] [--codex-cli <path>] [--json] [--workspace <path>]
+  taskchef workspace migrate [--json] [--workspace <path>]
   taskchef project add <path> [--name <name>] [--description <text>] [--github-repo <url> ... | --no-github] [--json] [--workspace <path>]
   taskchef project import [<file> | -] [--replace] [--json] [--workspace <path>]
   taskchef project list [--json] [--workspace <path>]
@@ -461,8 +492,10 @@ 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.
+The foreground dashboard binds to 127.0.0.1 and reads the canonical task log
+without modifying dispatcher-workspace files. The dispatcher MCP may reuse a
+compatible foreground server on port 3210; neither mode terminates a listener
+that already occupies its requested port.
 `);
 }
 
@@ -475,6 +508,7 @@ export async function runCli(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);
+  if (args[0] === "workspace" && args[1] === "migrate") return migrate(args);
   if (args[0] === "project" && args[1] === "add") return projectAdd(args);
   if (args[0] === "project" && args[1] === "import") return projectImport(args);
   if (args[0] === "project" && args[1] === "list") return projectList(args);

package/src/dashboard/app.js

@@ -17,6 +17,7 @@ const state = {
   selectedTask: null,
 };
 let dateRefreshTimer = null;
+let detailRequestGeneration = 0;
 
 const elements = {
   clearNotifications: document.querySelector("#clear-notifications"),
@@ -31,7 +32,7 @@ const elements = {
   dialogInstruction: document.querySelector("#dialog-instruction"),
   dialogMetadata: document.querySelector("#dialog-metadata"),
   dialogProject: document.querySelector("#dialog-project"),
-  dialogSummary: document.querySelector("#dialog-summary"),
+  dialogResults: document.querySelector("#dialog-results"),
   dialogTitle: document.querySelector("#dialog-title"),
   dismissDashboardMessage: document.querySelector("#dismiss-dashboard-message"),
   emptyState: document.querySelector("#empty-state"),
@@ -119,12 +120,48 @@ function detailRow(term, value) {
   return [dt, dd];
 }
 
-function openDialog(task) {
-  state.selectedTask = task;
+function resultHistory(results) {
+  if (results.length === 0) {
+    const empty = document.createElement("p");
+    empty.className = "result-history-empty";
+    empty.textContent = "No semantic result has been reported yet.";
+    return [empty];
+  }
+  return [...results].reverse().map((result, index) => {
+    const item = document.createElement("article");
+    item.className = `result-history-item${index === 0 ? " result-history-latest" : ""}`;
+    const header = document.createElement("div");
+    header.className = "result-history-header";
+    const status = document.createElement("span");
+    status.className = `status status-${result.status}`;
+    status.textContent = result.status.replaceAll("_", " ");
+    const timestamp = document.createElement("time");
+    timestamp.dateTime = result.updatedAt;
+    timestamp.textContent = formatTime(result.updatedAt);
+    header.append(status, timestamp);
+    const summary = document.createElement("p");
+    summary.className = "preserve-lines";
+    summary.textContent = result.summary;
+    const turn = document.createElement("p");
+    turn.className = "result-history-turn";
+    turn.textContent = result.turnId ? `Turn ${result.turnId}` : "No turn ID (creation failure)";
+    item.append(header, summary, turn);
+    return item;
+  });
+}
+
+function renderDialog(task) {
+  const preservedResults = state.selectedTask?.id === task.id
+    ? state.selectedTask.results
+    : null;
+  const detailedTask = {
+    ...task,
+    results: task.results ?? preservedResults ?? [],
+  };
+  state.selectedTask = detailedTask;
   elements.dialogProject.textContent = task.project.name;
   elements.dialogTitle.textContent = task.title;
-  elements.dialogSummary.textContent = task.lastResult?.summary
-    ?? "No semantic result has been reported yet.";
+  elements.dialogResults.replaceChildren(...resultHistory(detailedTask.results));
   elements.dialogInstruction.textContent = task.instruction;
   elements.copyThreadId.disabled = !task.threadId;
   elements.dialogMetadata.replaceChildren(
@@ -142,7 +179,28 @@ function openDialog(task) {
     )),
     ...detailRow("Updated by", task.updatedBy),
   );
+}
+
+async function openDialog(task) {
+  const requestGeneration = ++detailRequestGeneration;
+  renderDialog(task);
   if (!elements.dialog.open) elements.dialog.showModal();
+  try {
+    const response = await fetch(`/api/tasks/${encodeURIComponent(task.id)}`);
+    if (!response.ok) throw new Error("Task details are unavailable.");
+    const detail = await response.json();
+    if (
+      requestGeneration === detailRequestGeneration
+      && state.selectedTask?.id === task.id
+      && elements.dialog.open
+    ) {
+      renderDialog(detail.task);
+    }
+  } catch {
+    if (state.selectedTask?.id === task.id) {
+      showMessage("Task result history is temporarily unavailable.");
+    }
+  }
 }
 
 function taskCard(task) {

package/src/dashboard/index.html

@@ -87,8 +87,8 @@
         <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>
+        <h3>Result history</h3>
+        <div id="dialog-results" class="result-history"></div>
       </section>
       <section>
         <h3>Original instruction</h3>

package/src/dashboard/styles.css

@@ -117,6 +117,14 @@ dialog::backdrop { background: rgb(18 23 21 / 50%); backdrop-filter: blur(2px);
 .primary-button:disabled, .secondary-button:disabled { opacity: 0.5; cursor: not-allowed; }
 dialog section + section { margin-top: 24px; }
 .preserve-lines { white-space: pre-wrap; }
+.result-history { display: grid; gap: 10px; }
+.result-history-item { padding: 13px 14px; border: 1px solid var(--border); border-radius: 8px; background: var(--surface-muted); }
+.result-history-latest { border-color: var(--accent); background: var(--accent-soft); box-shadow: inset 3px 0 var(--accent); }
+.result-history-header { display: flex; align-items: center; justify-content: space-between; gap: 12px; margin-bottom: 9px; }
+.result-history-item p { margin-bottom: 7px; }
+.result-history-item p:last-child { margin-bottom: 0; }
+.result-history-turn, .result-history-empty { color: var(--muted); font-size: 0.78rem; overflow-wrap: anywhere; }
+.result-history-empty { margin: 0; }
 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; }

package/src/dashboard-manager.js

@@ -0,0 +1,183 @@
+import http from "node:http";
+import { realpath } from "node:fs/promises";
+import path from "node:path";
+
+import {
+  DASHBOARD_HEALTH_MAX_BYTES,
+  DASHBOARD_HEALTH_PATH,
+  createDashboardServer,
+  dashboardAuthority,
+} from "./dashboard.js";
+import { DASHBOARD_SERVER_VERSION, TASKCHEF_VERSION } from "./version.js";
+
+const DEFAULT_HOST = "127.0.0.1";
+const DEFAULT_PORT = 3210;
+const HEALTH_TIMEOUT_MS = 750;
+
+function expectedIdentity(workspace, taskchefVersion, serverVersion) {
+  return {
+    schemaVersion: 1,
+    service: "taskchef-dashboard",
+    taskchefVersion,
+    serverVersion,
+    workspace,
+  };
+}
+
+function isExactIdentity(value, expected) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const keys = Object.keys(value).sort();
+  const expectedKeys = Object.keys(expected).sort();
+  return keys.length === expectedKeys.length
+    && keys.every((key, index) => key === expectedKeys[index])
+    && expectedKeys.every((key) => value[key] === expected[key]);
+}
+
+function listenerConflict(url, detail) {
+  return new Error(
+    `TaskChef dashboard port conflict at ${url} ${detail} `
+    + "Stop that listener or choose another port for the foreground dashboard CLI; TaskChef will not terminate it.",
+  );
+}
+
+export function readDashboardIdentity({
+  host = DEFAULT_HOST,
+  port = DEFAULT_PORT,
+  maximumBytes = DASHBOARD_HEALTH_MAX_BYTES,
+  timeoutMs = HEALTH_TIMEOUT_MS,
+} = {}) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (error, value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(deadline);
+      if (error) reject(error);
+      else resolve(value);
+    };
+    const request = http.get({
+      host,
+      port,
+      path: DASHBOARD_HEALTH_PATH,
+      headers: {
+        Accept: "application/json",
+        Host: dashboardAuthority(host, port),
+      },
+    }, (response) => {
+      const chunks = [];
+      let total = 0;
+      response.on("data", (chunk) => {
+        total += chunk.length;
+        if (total > maximumBytes) {
+          const error = new Error("dashboard health response exceeds the identity limit");
+          finish(error);
+          request.destroy(error);
+          return;
+        }
+        chunks.push(chunk);
+      });
+      response.on("end", () => {
+        if (response.statusCode !== 200) {
+          finish(new Error(`dashboard health returned HTTP ${response.statusCode}`));
+          return;
+        }
+        try {
+          finish(null, JSON.parse(Buffer.concat(chunks, total).toString("utf8")));
+        } catch {
+          finish(new Error("dashboard health returned invalid JSON"));
+        }
+      });
+    });
+    const deadline = setTimeout(() => {
+      const error = new Error("dashboard health request timed out");
+      finish(error);
+      request.destroy(error);
+    }, timeoutMs);
+    request.on("error", (error) => finish(error));
+  });
+}
+
+function listenerAbsent(error) {
+  return error?.code === "ECONNREFUSED" || error?.code === "EHOSTUNREACH";
+}
+
+export function createDashboardManager({
+  workspace,
+  host = DEFAULT_HOST,
+  port = DEFAULT_PORT,
+  taskchefVersion = TASKCHEF_VERSION,
+  serverVersion = DASHBOARD_SERVER_VERSION,
+  createServer = createDashboardServer,
+  readIdentity = readDashboardIdentity,
+} = {}) {
+  let canonicalWorkspace;
+  let ownedServer = null;
+  let ensurePromise = null;
+  let closePromise = null;
+
+  const publicResult = (action) => ({
+    action,
+    url: `http://${dashboardAuthority(host, ownedServer?.port ?? port)}/`,
+    workspace: canonicalWorkspace,
+    taskchefVersion,
+    serverVersion,
+  });
+
+  const probe = async () => {
+    const url = `http://${dashboardAuthority(host, port)}/`;
+    let identity;
+    try {
+      identity = await readIdentity({ host, port });
+    } catch (error) {
+      if (listenerAbsent(error)) return false;
+      throw listenerConflict(url, `is occupied but did not return a compatible identity (${error.message}).`);
+    }
+    const expected = expectedIdentity(canonicalWorkspace, taskchefVersion, serverVersion);
+    if (!isExactIdentity(identity, expected)) {
+      throw listenerConflict(url, "belongs to an unknown, stale, or different-workspace service.");
+    }
+    return true;
+  };
+
+  const ensureOnce = async () => {
+    canonicalWorkspace ??= await realpath(path.resolve(workspace));
+    if (ownedServer) return publicResult("reused");
+    if (await probe()) return publicResult("reused");
+    try {
+      ownedServer = await createServer({
+        workspace: canonicalWorkspace,
+        host,
+        port,
+        taskchefVersion,
+        serverVersion,
+      });
+      return publicResult("started");
+    } catch (error) {
+      if (error?.code !== "EADDRINUSE") throw error;
+      if (await probe()) return publicResult("reused");
+      throw error;
+    }
+  };
+
+  return {
+    async ensure() {
+      if (closePromise) throw new Error("TaskChef dashboard manager is shutting down");
+      if (ensurePromise) {
+        await ensurePromise;
+        return publicResult("reused");
+      }
+      ensurePromise = ensureOnce().finally(() => { ensurePromise = null; });
+      return ensurePromise;
+    },
+    async close() {
+      closePromise ??= (async () => {
+        await ensurePromise?.catch(() => {});
+        const server = ownedServer;
+        ownedServer = null;
+        await server?.close();
+      })();
+      return closePromise;
+    },
+    get owned() { return ownedServer !== null; },
+  };
+}

package/src/dashboard.js

@@ -16,6 +16,7 @@ import {
   parseTaskLogContent,
   readConfig,
 } from "./workspace.js";
+import { DASHBOARD_SERVER_VERSION, TASKCHEF_VERSION } from "./version.js";
 
 const TASKS_FILE_NAME = "tasks.jsonl";
 const STATIC_ROOT = fileURLToPath(new URL("./dashboard/", import.meta.url));
@@ -24,6 +25,8 @@ 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;
+export const DASHBOARD_HEALTH_PATH = "/api/health";
+export const DASHBOARD_HEALTH_MAX_BYTES = 8 * 1024;
 const CONTENT_SECURITY_POLICY = [
   "default-src 'self'",
   "base-uri 'none'",
@@ -133,6 +136,14 @@ function assertDashboardTaskBounds(tasks, maximumTasks) {
     boundedText(task.turnId, 512, `${name} turn ID`);
     boundedText(task.lastResult?.summary, 2_000, `${name} last result summary`);
     boundedText(task.lastResult?.turnId, 512, `${name} last result turn ID`);
+    const results = task.results ?? [];
+    if (results.length > 10_000) {
+      throw new Error(`${name} has too many results for the dashboard`);
+    }
+    for (const [resultIndex, result] of results.entries()) {
+      boundedText(result.summary, 2_000, `${name} result ${resultIndex + 1} summary`);
+      boundedText(result.turnId, 512, `${name} result ${resultIndex + 1} 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`);
@@ -145,6 +156,11 @@ function assertDashboardTaskBounds(tasks, maximumTasks) {
   }
 }
 
+function taskListProjection(task) {
+  const { results: _results, ...projection } = task;
+  return projection;
+}
+
 export class DashboardMonitor extends EventEmitter {
   constructor(workspace, {
     debounceMs = 75,
@@ -194,7 +210,7 @@ export class DashboardMonitor extends EventEmitter {
       generatedAt: new Date().toISOString(),
       healthy: !this.unhealthy,
       tasks: this.tasks.map((task) => ({
-        ...task,
+        ...taskListProjection(task),
         meaningfulUpdatedAt: new Date(
           meaningfulUpdateTime(task, this.observedUpdateTimes),
         ).toISOString(),
@@ -402,6 +418,8 @@ export async function createDashboardServer({
   monitorOptions = {},
   openProject = null,
   openThread = null,
+  taskchefVersion = TASKCHEF_VERSION,
+  serverVersion = DASHBOARD_SERVER_VERSION,
 } = {}) {
   if (!LOOPBACK_HOSTS.has(host)) {
     throw new Error("dashboard host must be a loopback address");
@@ -414,6 +432,17 @@ export async function createDashboardServer({
   }
   const monitor = new DashboardMonitor(workspace, monitorOptions);
   await monitor.start();
+  const identity = Object.freeze({
+    schemaVersion: 1,
+    service: "taskchef-dashboard",
+    taskchefVersion,
+    serverVersion,
+    workspace: monitor.workspace,
+  });
+  if (Buffer.byteLength(`${JSON.stringify(identity)}\n`) > DASHBOARD_HEALTH_MAX_BYTES) {
+    monitor.close();
+    throw new Error("dashboard identity exceeds the health response limit");
+  }
   const clients = new Set();
   let allowedAuthority;
   let allowedOrigin;
@@ -446,6 +475,16 @@ export async function createDashboardServer({
       return;
     }
 
+    if (url.pathname === DASHBOARD_HEALTH_PATH && (method === "GET" || method === "HEAD")) {
+      if (method === "HEAD") {
+        response.writeHead(200, securityHeaders("application/json; charset=utf-8"));
+        response.end();
+      } else {
+        sendJson(response, 200, identity);
+      }
+      return;
+    }
+
     if (url.pathname === "/api/snapshot" && (method === "GET" || method === "HEAD")) {
       if (method === "HEAD") {
         response.writeHead(200, securityHeaders("application/json; charset=utf-8"));
@@ -484,6 +523,22 @@ export async function createDashboardServer({
       return;
     }
 
+    const detailMatch = url.pathname.match(/^\/api\/tasks\/([a-zA-Z0-9._-]+)$/);
+    if (detailMatch && (method === "GET" || method === "HEAD")) {
+      const task = monitor.tasks.find((candidate) => candidate.id === detailMatch[1]);
+      if (!task) {
+        sendJson(response, 404, { message: "Task not found." });
+        return;
+      }
+      if (method === "HEAD") {
+        response.writeHead(200, securityHeaders("application/json; charset=utf-8"));
+        response.end();
+      } else {
+        sendJson(response, 200, { schemaVersion: 1, task });
+      }
+      return;
+    }
+
     const taskMatch = url.pathname.match(/^\/api\/tasks\/([a-zA-Z0-9._-]+)\/open-codex$/);
     if (taskMatch && method === "POST") {
       if (request.headers.origin !== allowedOrigin) {
@@ -574,6 +629,7 @@ export async function createDashboardServer({
     port: boundPort,
     origin: allowedOrigin,
     url: `${allowedOrigin}/`,
+    identity,
     monitor,
     get eventClientCount() { return clients.size; },
     async close() {

package/src/mcp.js

@@ -8,7 +8,9 @@ import {
   reportTaskResult,
 } from "./workspace.js";
 import { parseTaskChefMarker } from "./delegation.js";
+import { createDashboardManager } from "./dashboard-manager.js";
 import { resolveWorkspacePath } from "./workspace-path.js";
+import { DASHBOARD_SERVER_VERSION, TASKCHEF_VERSION } from "./version.js";
 
 const projectSchema = z.object({
   name: z.string(),
@@ -19,7 +21,7 @@ const projectSchema = z.object({
 });
 
 const taskSchema = z.object({
-  schemaVersion: z.union([z.literal(4), z.literal(5)]),
+  schemaVersion: z.union([z.literal(4), z.literal(5), z.literal(6)]),
   id: z.string(),
   project: projectSchema,
   title: z.string(),
@@ -31,6 +33,12 @@ const taskSchema = z.object({
   turnId: z.string().nullable(),
   updatedAt: z.string(),
   updatedBy: z.enum(["dispatcher", "mcp"]),
+  results: z.array(z.object({
+    status: z.enum(["needs_input", "completed", "failed"]),
+    summary: z.string(),
+    turnId: z.string().nullable(),
+    updatedAt: z.string(),
+  })),
   lastResult: z.object({
     status: z.enum(["needs_input", "completed", "failed"]),
     summary: z.string(),
@@ -49,6 +57,14 @@ const preparationSchema = z.object({
   projects: z.array(projectSchema),
 });
 
+const dashboardSchema = z.object({
+  action: z.enum(["started", "reused"]),
+  url: z.string().url(),
+  workspace: z.string(),
+  taskchefVersion: z.string(),
+  serverVersion: z.string(),
+});
+
 function toolResult(key, value, message) {
   return {
     structuredContent: { [key]: value },
@@ -63,15 +79,53 @@ export function createTaskChefMcpServer({
   reportResult = reportTaskResult,
   reportState = reportTaskState,
   link = linkTask,
+  dashboardManager = createDashboardManager({ workspace }),
 } = {}) {
   const server = new McpServer(
-    { name: "taskchef", version: "1.0.0" },
+    { name: "taskchef", version: TASKCHEF_VERSION },
     {
       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.",
     },
   );
 
+  const originalClose = server.close.bind(server);
+  let closePromise = null;
+  server.close = async () => {
+    closePromise ??= (async () => {
+      await dashboardManager.close();
+      await originalClose();
+    })();
+    return closePromise;
+  };
+  server.server.onclose = () => {
+    void dashboardManager.close();
+  };
+
+  server.registerTool(
+    "ensure_dashboard",
+    {
+      title: "Ensure TaskChef dashboard",
+      description:
+        "Best-effort ensure the canonical TaskChef dashboard is available on 127.0.0.1:3210. Starts one dashboard inside this MCP process or reuses only an exact compatible TaskChef dashboard for the same canonical workspace; unknown listeners are never terminated or replaced.",
+      inputSchema: {},
+      outputSchema: { dashboard: dashboardSchema },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        openWorldHint: false,
+      },
+    },
+    async () => {
+      const dashboard = await dashboardManager.ensure();
+      return toolResult(
+        "dashboard",
+        dashboard,
+        `${dashboard.action === "started" ? "Started" : "Reused"} TaskChef dashboard ${dashboard.url}`,
+      );
+    },
+  );
+
   server.registerTool(
     "prepare_dispatch",
     {

package/src/version.js

@@ -0,0 +1,7 @@
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+const packageMetadata = require("../package.json");
+
+export const TASKCHEF_VERSION = packageMetadata.version;
+export const DASHBOARD_SERVER_VERSION = "1";