taskchef 7.28.1 → 8.0.0

package/src/dashboard/react/App.tsx

@@ -109,6 +109,7 @@ export function DashboardApp({
     return () => window.removeEventListener('hashchange', update);
   }, []);
   const [tasks, setTasks] = useState<Task[]>(initialTasks);
+  const [projectIndex, setProjectIndex] = useState<DashboardSnapshot["projectIndex"]>();
   const [connected, setConnected] = useState(false);
   const [message, setMessage] = useState<string | null>(null);
   const [version, setVersion] = useState<string | null>(null);
@@ -138,6 +139,7 @@ export function DashboardApp({
 
   const applySnapshot = useCallback((snapshot: DashboardSnapshot) => {
     setTasks(snapshot.tasks);
+    setProjectIndex(snapshot.projectIndex);
     setNotificationState((current) => {
       const reconciled = reconcileNotifications(current, snapshot.tasks);
       return {
@@ -325,6 +327,20 @@ export function DashboardApp({
 
         <AppShell.Main>
           <Container className="taskchef-main" pb={80} size={1080}>
+            {projectIndex?.status === "unavailable" && (
+              <Alert color="yellow" icon={<IconAlertTriangle size={18} />} mb="md" title="Project index unavailable">
+                Task history is still visible. Verify the index and inspect backups before making project changes.
+              </Alert>
+            )}
+            {projectIndex?.status === "available" && projectIndex.missingProjects.length > 0 && (
+              <Alert color="yellow" icon={<IconAlertTriangle size={18} />} mb="md" title="Historical projects are missing from the current index">
+                {projectIndex.missingProjects.map((item) => (
+                  <Text key={item.path} size="sm">
+                    {item.snapshotNames.join(", ")}: {item.taskCount} task(s). Run <code>taskchef backup list --json</code> and preview any restore; the dashboard never restores automatically.
+                  </Text>
+                ))}
+              </Alert>
+            )}
             {settings ? <Stack gap="md"><Button component="a" href="#" variant="subtle" size="sm" leftSection={<IconArrowLeft size={16} />} style={{ alignSelf: 'flex-start' }}>Back to tasks</Button><ModelSettings /></Stack> : <>
             <Paper className="taskchef-toolbar" p="sm" radius="md" withBorder>
               <Stack gap="sm">

package/src/dashboard/react/components/ModelSettings.test.tsx

@@ -19,6 +19,20 @@ vi.mock('@mantine/core', async () => {
 
 afterEach(() => { cleanup(); vi.unstubAllGlobals(); vi.clearAllMocks(); });
 
+test('shows the version reported by the active usage provider', async () => {
+  vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+    ok: true,
+    json: async () => ({
+      profiles: [],
+      usageProvider: { provider: 'ccusage', status: 'available', version: '20.0.21' },
+    }),
+  }));
+  render(<MantineProvider><ModelSettings /></MantineProvider>);
+  expect(await screen.findByText('ccusage 20.0.21')).toBeInTheDocument();
+  expect(screen.getByText('Usage provider')).toBeInTheDocument();
+  expect(screen.getByText(/Version reported by the executable/)).toBeInTheDocument();
+});
+
 test('refresh shows configuration failures and does not label them honored', async () => {
   const role = { role: 'reviewer', source: '/fixture/reviewer.toml', effectiveSource: '/fixture/reviewer.toml', model: 'fixture', effort: 'low', status: 'configured', availability: 'not checked', fallback: 'inherit parent settings', problems: [] as string[] };
   const profile = { id: 'personal', project: 'Personal', roles: [role], problems: [], catalogSource: null };

package/src/dashboard/react/components/ModelSettings.tsx

@@ -6,9 +6,11 @@ import { updateModelRole } from '../api';
 type ModelOption = { value: string; label: string; efforts: string[] };
 type Role = { role: string; source: string | null; displaySource?: string | null; model: unknown; effort: unknown; status: string; problems: string[] };
 type Profile = { id: string; roles: Role[]; problems: string[]; modelOptions?: ModelOption[] };
+type UsageProvider = { provider: string; status: 'available' | 'unavailable'; version: string | null };
 
 export function ModelSettings() {
   const [profiles, setProfiles] = useState<Profile[]>([]);
+  const [usageProvider, setUsageProvider] = useState<UsageProvider | null>(null);
   const [error, setError] = useState<string | null>(null);
   const [loading, setLoading] = useState(true);
   const [saving, setSaving] = useState<string | null>(null);
@@ -20,8 +22,9 @@ export function ModelSettings() {
     setError(null);
     fetch('/api/settings', { signal: controller.signal }).then(async (response) => {
       if (!response.ok) throw new Error('Settings preview could not be loaded.');
-      const data = await response.json() as { profiles: Profile[] };
+      const data = await response.json() as { profiles: Profile[]; usageProvider?: UsageProvider };
       setProfiles(data.profiles);
+      setUsageProvider(data.usageProvider ?? null);
     }).catch((failure: Error) => {
       if (!controller.signal.aborted) setError(failure.message);
     }).finally(() => { if (!controller.signal.aborted) setLoading(false); });
@@ -87,5 +90,15 @@ export function ModelSettings() {
         </Stack>
       </Paper>)}
     </>}
+    {usageProvider && <Paper withBorder p="md">
+      <Stack gap="xs">
+        <Group justify="space-between">
+          <Title order={3} size="h4">Usage provider</Title>
+          <Badge color={usageProvider.status === 'available' ? 'teal' : 'red'}>{usageProvider.status}</Badge>
+        </Group>
+        <Text>{usageProvider.provider}{usageProvider.version ? ` ${usageProvider.version}` : ' version unavailable'}</Text>
+        <Text c="dimmed" size="sm">Version reported by the executable TaskChef uses for token and cost estimates.</Text>
+      </Stack>
+    </Paper>}
   </Stack>;
 }

package/src/dashboard/react/types.ts

@@ -106,6 +106,16 @@ export interface NotificationSnapshot {
 export interface DashboardSnapshot {
   healthy?: boolean;
   tasks: Task[];
+  projectIndex?: {
+    status: "available" | "unavailable";
+    projectCount: number | null;
+    missingProjects: Array<{
+      path: string;
+      snapshotNames: string[];
+      taskCount: number;
+    }>;
+    truncated?: boolean;
+  };
 }
 
 export interface ManualTransitionResponse {

package/src/dashboard-manager.js

@@ -246,6 +246,7 @@ export function readDashboardIdentity({
   port = DEFAULT_PORT,
   maximumBytes = DASHBOARD_HEALTH_MAX_BYTES,
   timeoutMs = HEALTH_TIMEOUT_MS,
+  deadlineAt = Date.now() + timeoutMs,
 } = {}) {
   return new Promise((resolve, reject) => {
     let settled = false;
@@ -278,6 +279,21 @@ export function readDashboardIdentity({
         chunks.push(chunk);
       });
       response.on("end", () => {
+        if (response.statusCode === 503 && deadlineAt - Date.now() > 10) {
+          settled = true;
+          clearTimeout(deadline);
+          const remaining = deadlineAt - Date.now();
+          setTimeout(() => {
+            readDashboardIdentity({
+              host,
+              port,
+              maximumBytes,
+              timeoutMs: Math.max(1, remaining),
+              deadlineAt,
+            }).then(resolve, reject);
+          }, 10);
+          return;
+        }
         if (response.statusCode !== 200) {
           finish(new Error(`dashboard health returned HTTP ${response.statusCode}`));
           return;

package/src/dashboard.js

@@ -20,6 +20,7 @@ import {
   canonicalGitRoot,
   manuallyTransitionTask,
   parseTaskLogContent,
+  createWorkspaceBackup,
   readConfig,
   readTask,
 } from "./workspace.js";
@@ -27,7 +28,7 @@ import { DASHBOARD_SERVER_VERSION, TASKCHEF_VERSION } from "./version.js";
 import { taskGitHubProjection } from "./dashboard/github-links.js";
 import { CODEX_CHAT_ARCHIVE_ENABLED } from "./dashboard/state.js";
 import { createUsageTracker } from "./usage-tracker.js";
-import { readUsageStore, usageStorePath } from "./usage.js";
+import { readCcusageRuntimeInfo, readUsageStore, usageStorePath } from "./usage.js";
 import { reportedWorkSummary } from "./reported-work.js";
 import {
   MAX_DASHBOARD_SESSION_PIDS,
@@ -463,7 +464,9 @@ export class DashboardMonitor extends EventEmitter {
       const snapshot = await readBoundedTaskLog(this.tasksFile, this.maxFileBytes);
       return {
         fingerprint: snapshot.fingerprint,
-        tasks: await parseTaskLogContent(this.workspace, snapshot.content),
+        tasks: await parseTaskLogContent(this.workspace, snapshot.content, {
+          validateWorkspace: false,
+        }),
       };
     });
     this.tasks = [];
@@ -472,6 +475,7 @@ export class DashboardMonitor extends EventEmitter {
     this.currentFingerprint = null;
     this.currentTaskFingerprint = null;
     this.unhealthy = false;
+    this.projectIndex = { status: "available", projectCount: 0, missingProjects: [] };
     this.observedUpdateTimes = new Map();
     this.refreshPromise = null;
     this.refreshQueued = false;
@@ -487,6 +491,7 @@ export class DashboardMonitor extends EventEmitter {
       revision: this.revision,
       generatedAt: new Date().toISOString(),
       healthy: !this.unhealthy,
+      projectIndex: this.projectIndex,
       tasks: this.tasks.map((task) => ({
         ...taskListProjection(task),
         meaningfulUpdatedAt: new Date(
@@ -513,7 +518,7 @@ export class DashboardMonitor extends EventEmitter {
     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;
+        if (fileName !== null && !new Set([TASKS_FILE_NAME, "taskchef.json", "config-audit.jsonl"]).has(String(fileName))) return;
         clearTimeout(this.debounceTimer);
         this.debounceTimer = setTimeout(() => this.refresh({ force: true }), this.debounceMs);
         this.debounceTimer.unref?.();
@@ -579,8 +584,34 @@ export class DashboardMonitor extends EventEmitter {
         }
       }
       const tasks = sortTasksByMeaningfulUpdate(snapshot.tasks, this.observedUpdateTimes);
-      const nextTaskFingerprint = taskFingerprint(tasks);
+      let projectIndex;
+      try {
+        const config = await readConfig(this.workspace, { checkPaths: false });
+        const configured = new Set(config.projects.map((project) => project.path));
+        const missing = new Map();
+        for (const task of tasks) {
+          if (configured.has(task.project.path)) continue;
+          const item = missing.get(task.project.path) ?? {
+            path: task.project.path, snapshotNames: new Set(), taskCount: 0,
+          };
+          item.snapshotNames.add(task.project.name);
+          item.taskCount += 1;
+          missing.set(task.project.path, item);
+        }
+        projectIndex = {
+          status: "available",
+          projectCount: config.projects.length,
+          missingProjects: [...missing.values()].slice(0, 50).map((item) => ({
+            ...item, snapshotNames: [...item.snapshotNames].sort(),
+          })),
+          truncated: missing.size > 50,
+        };
+      } catch {
+        projectIndex = { status: "unavailable", projectCount: null, missingProjects: [] };
+      }
+      const nextTaskFingerprint = taskFingerprint({ tasks, projectIndex });
       this.currentFingerprint = after;
+      this.projectIndex = projectIndex;
       if (nextTaskFingerprint === this.currentTaskFingerprint) {
         if (this.unhealthy) {
           this.unhealthy = false;
@@ -804,7 +835,9 @@ export async function createDashboardServer({
   serverVersion = DASHBOARD_SERVER_VERSION,
   usageTracker = null,
   usageSummaryMonitor = null,
+  usagePreloadIntervalMs = 30_000,
   resolveRoles = resolveModelRoles,
+  resolveUsageProvider = readCcusageRuntimeInfo,
   updateRole = updateModelRole,
   control = null,
   controlReplayCache = createDashboardControlReplayCache(),
@@ -818,6 +851,9 @@ export async function createDashboardServer({
   if (!Number.isInteger(maxEventClients) || maxEventClients < 0) {
     throw new Error("dashboard event-client limit must be a non-negative integer");
   }
+  if (!Number.isFinite(usagePreloadIntervalMs) || usagePreloadIntervalMs < 1_000) {
+    throw new Error("dashboard usage preload interval must be at least one second");
+  }
   if (!new Set(["mcp", "session", "standalone"]).has(launcher)) {
     throw new Error("dashboard launcher must be mcp, session, or standalone");
   }
@@ -828,11 +864,24 @@ export async function createDashboardServer({
         || typeof control?.onHandoff !== "function")))) {
     throw new Error("dashboard control requires a valid TaskChef ownership controller");
   }
+  let requestHandler = (_request, response) => {
+    sendJson(response, 503, { message: "TaskChef dashboard is initializing." });
+  };
+  const server = http.createServer((request, response) => requestHandler(request, response));
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, host, resolve);
+  });
+  const address = server.address();
+  const boundPort = typeof address === "object" && address ? address.port : port;
+  const allowedAuthority = dashboardAuthority(host, boundPort);
+  const allowedOrigin = `http://${allowedAuthority}`;
   const monitor = new DashboardMonitor(workspace, monitorOptions);
   let taskUsageTracker;
   let taskUsageSummaryMonitor;
   let identity;
   try {
+    await createWorkspaceBackup(workspace, { reason: `dashboard-${launcher}-startup` });
     await monitor.start();
     taskUsageTracker = usageTracker ?? createUsageTracker({ workspace: monitor.workspace });
     taskUsageSummaryMonitor = usageSummaryMonitor
@@ -851,15 +900,16 @@ export async function createDashboardServer({
     }
   } catch (error) {
     taskUsageSummaryMonitor?.close();
+    taskUsageTracker?.close?.();
     monitor.close();
+    await new Promise((resolve) => server.close(() => resolve()));
     throw error;
   }
   const clients = new Set();
   const archiveRequests = new Set();
+  let usageProviderPromise = null;
   let controlHandoff = null;
   let controlHandoffTimer = null;
-  let allowedAuthority;
-  let allowedOrigin;
 
   const broadcast = (event, value) => {
     const payload = ssePayload(event, value);
@@ -875,12 +925,21 @@ export async function createDashboardServer({
       })),
     };
   };
-  const snapshotListener = () => broadcast("snapshot", dashboardSnapshot());
+  const preloadUsage = () => {
+    void Promise.resolve(taskUsageTracker.preload?.(monitor.tasks)).catch(() => {});
+  };
+  const snapshotListener = () => {
+    preloadUsage();
+    broadcast("snapshot", dashboardSnapshot());
+  };
   const usageSummaryListener = () => broadcast("snapshot", dashboardSnapshot());
   const errorListener = () => broadcast("dashboard-error", publicMonitorError());
   monitor.on("snapshot", snapshotListener);
   monitor.on("monitorError", errorListener);
   taskUsageSummaryMonitor.on("change", usageSummaryListener);
+  preloadUsage();
+  const usagePreloadTimer = setInterval(preloadUsage, usagePreloadIntervalMs);
+  usagePreloadTimer.unref?.();
 
   const handleRequest = async (request, response) => {
     const method = request.method ?? "GET";
@@ -1183,7 +1242,12 @@ export async function createDashboardServer({
 
     if (url.pathname === "/api/settings" && method === "GET") {
       const profiles = [{ id: "personal", project: "Personal", ...await resolveRoles({ includeCatalog: true }) }];
-      sendJson(response, 200, { profiles });
+      usageProviderPromise ??= Promise.resolve(resolveUsageProvider()).catch(() => ({
+        provider: "ccusage",
+        status: "unavailable",
+        version: null,
+      }));
+      sendJson(response, 200, { profiles, usageProvider: await usageProviderPromise });
       return;
     }
 
@@ -1458,26 +1522,12 @@ export async function createDashboardServer({
     response.end(method === "HEAD" ? undefined : body);
   };
 
-  const server = http.createServer((request, response) => {
+  requestHandler = (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();
-    taskUsageSummaryMonitor.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,
@@ -1493,6 +1543,8 @@ export async function createDashboardServer({
       taskUsageSummaryMonitor.off("change", usageSummaryListener);
       monitor.close();
       taskUsageSummaryMonitor.close();
+      taskUsageTracker.close?.();
+      clearInterval(usagePreloadTimer);
       for (const client of clients) client.close();
       const closed = new Promise((resolve, reject) => server.close((error) =>
         error ? reject(error) : resolve()));

package/src/state-store.js

@@ -0,0 +1,81 @@
+import { createHash, randomUUID } from "node:crypto";
+import { link, mkdir, open, rename, unlink } from "node:fs/promises";
+import path from "node:path";
+
+function canonicalize(value) {
+  if (Array.isArray(value)) return value.map(canonicalize);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonicalize(value[key])]));
+  }
+  return value;
+}
+
+export function canonicalJson(value) {
+  return JSON.stringify(canonicalize(value));
+}
+
+export function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+
+export function semanticHash(value, domain = "taskchef") {
+  return sha256(`${domain}\n${canonicalJson(value)}\n`);
+}
+
+export function taskChefError(code, message, details = {}) {
+  return Object.assign(new Error(message), { code, details });
+}
+
+export async function writeDurableAtomic(filePath, content, {
+  mode = 0o600,
+  exclusive = false,
+} = {}) {
+  await mkdir(path.dirname(filePath), { recursive: true, mode: 0o700 });
+  const temporaryPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+  const handle = await open(temporaryPath, "wx", mode);
+  try {
+    await handle.writeFile(content, "utf8");
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+  let replacementCommitted = false;
+  try {
+    if (exclusive) {
+      await link(temporaryPath, filePath);
+      replacementCommitted = true;
+      await unlink(temporaryPath);
+    } else {
+      await rename(temporaryPath, filePath);
+      replacementCommitted = true;
+    }
+    const directory = await open(path.dirname(filePath), "r");
+    try {
+      await directory.sync();
+    } finally {
+      await directory.close();
+    }
+  } catch (error) {
+    await unlink(temporaryPath).catch(() => {});
+    if (replacementCommitted) error.replacementCommitted = true;
+    throw error;
+  }
+}
+
+export async function removeDurable(filePath) {
+  let removed = false;
+  try {
+    await unlink(filePath);
+    removed = true;
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  if (!removed) return false;
+  const directory = await open(path.dirname(filePath), "r");
+  try {
+    await directory.sync();
+  } finally {
+    await directory.close();
+  }
+  return true;
+}