taskchef 3.0.2 → 3.0.3

package/src/workspace.js

@@ -18,6 +18,7 @@ import { fileURLToPath } from "node:url";
 import path from "node:path";
 import { promisify } from "node:util";
 import lockfile from "proper-lockfile";
+import { normalizeDurableThreadId, parseTaskChefMarker } from "./delegation.js";
 
 const execFile = promisify(execFileCallback);
 const DISPATCHER_INSTRUCTIONS_URL = new URL(
@@ -164,6 +165,12 @@ async function appendDispatchesAtomic(workspaceRoot, dispatches) {
   await writeTextAtomic(dispatchPath, `${content}${appended}`);
 }
 
+async function writeDispatchesAtomic(workspaceRoot, dispatches) {
+  const dispatchPath = path.join(workspaceRoot, DISPATCH_FILE_NAME);
+  const content = dispatches.map((dispatch) => `${JSON.stringify(dispatch)}\n`).join("");
+  await writeTextAtomic(dispatchPath, content);
+}
+
 async function writeJsonAtomic(filePath, value, { exclusive = false } = {}) {
   await mkdir(path.dirname(filePath), { recursive: true });
   if (exclusive && (await pathExists(filePath))) {
@@ -558,14 +565,12 @@ export async function initializeWorkspace(workspaceRoot) {
     ? await readConfig(root, { checkPaths: false })
     : { schemaVersion: 1, projects: [] };
   const dispatchPath = path.join(root, DISPATCH_FILE_NAME);
-  const existingDispatches = configExists && (await managedRegularFileExists(dispatchPath))
-    ? await readDispatchesUnlocked(root)
-    : [];
-  const legacyTaskRecords = await inspectLegacyTaskRecords(root, config, existingDispatches);
+  if (configExists && (await managedRegularFileExists(dispatchPath))) {
+    await readDispatchesUnlocked(root);
+  }
   const { legacySkills } = await ensureWorkspaceSkills(root);
   if (!configExists) await writeJsonAtomic(configPath, config, { exclusive: true });
   const tasks = await ensureDispatchFile(root);
-  const legacyTasks = await migrateLegacyTaskRecords(root, legacyTaskRecords);
   const instructions = await ensureWorkspaceInstructions(root).catch(async (error) => {
     if (!configExists) await unlink(configPath).catch(() => {});
     throw error;
@@ -576,7 +581,6 @@ export async function initializeWorkspace(workspaceRoot) {
     tasks,
     instructions,
     legacySkills,
-    legacyTasks,
   };
 }
 
@@ -656,15 +660,24 @@ async function validateDispatchShape(dispatch, name = "task") {
   if (dispatch.schemaVersion !== 1) throw new Error(`unsupported ${name} schemaVersion`);
   const id = requireSafeId(dispatch.id, `${name}.id`);
   const project = await normalizeProject(dispatch.project, 0, { checkPath: false });
-  return {
+  const normalized = {
     schemaVersion: 1,
     id,
     project,
     title: requireString(dispatch.title, `${name}.title`).trim(),
     instruction: requireString(dispatch.instruction, `${name}.instruction`).trim(),
-    threadId: requireString(dispatch.threadId, `${name}.threadId`).trim(),
+    threadId: dispatch.threadId === null
+      ? null
+      : normalizeDurableThreadId(dispatch.threadId, `${name}.threadId`),
     createdAt: requireTimestamp(dispatch.createdAt, `${name}.createdAt`),
   };
+  if (
+    normalized.threadId === null &&
+    parseTaskChefMarker(normalized.instruction) !== normalized.id
+  ) {
+    throw new Error(`${name} with a null threadId must contain its exact TaskChef marker`);
+  }
+  return normalized;
 }
 
 async function readDispatchesUnlocked(root) {
@@ -695,11 +708,11 @@ async function readDispatchesUnlocked(root) {
   const threadIds = new Set();
   for (const dispatch of dispatches) {
     if (ids.has(dispatch.id)) throw new Error(`duplicate task ID: ${dispatch.id}`);
-    if (threadIds.has(dispatch.threadId)) {
+    if (dispatch.threadId !== null && threadIds.has(dispatch.threadId)) {
       throw new Error(`duplicate task threadId: ${dispatch.threadId}`);
     }
     ids.add(dispatch.id);
-    threadIds.add(dispatch.threadId);
+    if (dispatch.threadId !== null) threadIds.add(dispatch.threadId);
   }
   return dispatches;
 }
@@ -730,7 +743,10 @@ export async function recordTask(workspaceRoot, input, { now } = {}) {
     if (existing.some((item) => item.id === dispatch.id)) {
       throw new Error(`task already exists: ${dispatch.id}`);
     }
-    if (existing.some((item) => item.threadId === dispatch.threadId)) {
+    if (
+      dispatch.threadId !== null &&
+      existing.some((item) => item.threadId === dispatch.threadId)
+    ) {
       throw new Error(`threadId is already recorded: ${dispatch.threadId}`);
     }
     await appendDispatchesAtomic(root, [dispatch]);
@@ -738,6 +754,32 @@ export async function recordTask(workspaceRoot, input, { now } = {}) {
   return dispatch;
 }
 
+export async function resolveTask(workspaceRoot, taskId, threadId) {
+  const id = requireSafeId(taskId, "taskId");
+  const durableThreadId = normalizeDurableThreadId(threadId);
+  const root = await realpath(path.resolve(workspaceRoot));
+  return withDispatchLock(root, async () => {
+    const dispatches = await readDispatchesUnlocked(root);
+    const index = dispatches.findIndex((dispatch) => dispatch.id === id);
+    if (index === -1) throw new Error(`task not found: ${id}`);
+    const dispatch = dispatches[index];
+    if (parseTaskChefMarker(dispatch.instruction) !== dispatch.id) {
+      throw new Error(`task instruction does not contain its exact TaskChef marker: ${id}`);
+    }
+    if (dispatch.threadId === durableThreadId) return dispatch;
+    if (dispatch.threadId !== null) {
+      throw new Error(`task already has a different threadId: ${id}`);
+    }
+    if (dispatches.some((item) => item.threadId === durableThreadId)) {
+      throw new Error(`threadId is already recorded: ${durableThreadId}`);
+    }
+    const resolved = { ...dispatch, threadId: durableThreadId };
+    dispatches[index] = resolved;
+    await writeDispatchesAtomic(root, dispatches);
+    return resolved;
+  });
+}
+
 export async function readTask(workspaceRoot, taskId) {
   const id = requireSafeId(taskId, "taskId");
   const dispatch = (await listTasks(workspaceRoot)).find((item) => item.id === id);
@@ -775,161 +817,6 @@ export async function buildTaskSummary(workspaceRoot) {
   };
 }
 
-const LEGACY_TASK_FIELDS = new Set([
-  "schemaVersion",
-  "id",
-  "project",
-  "title",
-  "instruction",
-  "status",
-  "threadId",
-  "result",
-  "createdAt",
-  "updatedAt",
-]);
-
-function validateLegacyTask(task, taskId) {
-  requireExactFields(task, LEGACY_TASK_FIELDS, `legacy task ${taskId}`);
-  if (task.schemaVersion !== 1) throw new Error(`legacy task ${taskId} has unsupported schemaVersion`);
-  if (requireSafeId(task.id) !== taskId) throw new Error(`legacy task ID does not match directory: ${taskId}`);
-  requireString(task.project, `legacy task ${taskId}.project`);
-  requireString(task.title, `legacy task ${taskId}.title`);
-  requireString(task.instruction, `legacy task ${taskId}.instruction`);
-  requireTimestamp(task.createdAt, `legacy task ${taskId}.createdAt`);
-  if (task.threadId === null) {
-    throw new Error(`legacy pending task ${taskId} has no executor thread and cannot be migrated`);
-  }
-  requireString(task.threadId, `legacy task ${taskId}.threadId`);
-  return task;
-}
-
-async function inspectLegacyTaskRecords(workspaceRoot, config, existingDispatches = []) {
-  const tasksPath = path.join(workspaceRoot, "tasks");
-  const details = await lstat(tasksPath).catch((error) => {
-    if (error.code === "ENOENT") return null;
-    throw error;
-  });
-  if (details === null) return { tasksPath, entries: [], records: [], action: "not-found" };
-  if (details.isSymbolicLink() || !details.isDirectory()) {
-    throw new Error(`legacy tasks path is not a real directory: ${tasksPath}`);
-  }
-  const entries = await readdir(tasksPath, { withFileTypes: true });
-  const records = [];
-  const ids = new Set();
-  const threadIds = new Set();
-  for (const entry of entries) {
-    if (!entry.isDirectory() || !SAFE_ID.test(entry.name)) {
-      throw new Error(`unexpected legacy task entry: ${entry.name}`);
-    }
-    const taskDirectory = path.join(tasksPath, entry.name);
-    const taskEntries = await readdir(taskDirectory, { withFileTypes: true });
-    if (taskEntries.length === 0) {
-      records.push({ dispatch: null, taskPath: null, taskDirectory, taskId: entry.name });
-      continue;
-    }
-    if (
-      taskEntries.length !== 1 ||
-      taskEntries[0].name !== "task.json" ||
-      !taskEntries[0].isFile()
-    ) {
-      throw new Error(`legacy task directory must contain only task.json: ${entry.name}`);
-    }
-    const taskPath = path.join(taskDirectory, "task.json");
-    const task = validateLegacyTask(JSON.parse(await readFile(taskPath, "utf8")), entry.name);
-    const existing = existingDispatches.find((dispatch) => dispatch.id === task.id);
-    let dispatch;
-    if (existing) {
-      if (task.project.trim() !== existing.project.path) {
-        throw new Error(`legacy task conflicts with task history: ${task.id}`);
-      }
-      const comparable = {
-        title: task.title.trim(),
-        instruction: task.instruction.trim(),
-        threadId: task.threadId.trim(),
-        createdAt: task.createdAt,
-      };
-      for (const [field, value] of Object.entries(comparable)) {
-        if (existing[field] !== value) {
-          throw new Error(`legacy task conflicts with task history: ${task.id}`);
-        }
-      }
-      dispatch = existing;
-    } else {
-      const project = config.projects.find((candidate) => candidate.path === task.project) ??
-        await inspectProject({ path: task.project });
-      dispatch = await validateDispatchShape({
-        schemaVersion: 1,
-        id: task.id,
-        project,
-        title: task.title,
-        instruction: task.instruction,
-        threadId: task.threadId,
-        createdAt: task.createdAt,
-      });
-    }
-    if (ids.has(dispatch.id)) throw new Error(`duplicate legacy task ID: ${dispatch.id}`);
-    if (threadIds.has(dispatch.threadId)) {
-      throw new Error(`duplicate legacy task threadId: ${dispatch.threadId}`);
-    }
-    ids.add(dispatch.id);
-    threadIds.add(dispatch.threadId);
-    records.push({ dispatch, taskPath, taskDirectory, taskId: task.id });
-  }
-  return {
-    tasksPath,
-    entries,
-    records,
-    action: entries.length === 0 ? "removed-empty" : "migrated",
-  };
-}
-
-async function migrateLegacyTaskRecords(workspaceRoot, inspection) {
-  if (inspection.action === "not-found") return { action: "not-found", migratedCount: 0 };
-  const migrations = await withDispatchLock(workspaceRoot, async () => {
-    const existing = await readDispatchesUnlocked(workspaceRoot);
-    const existingById = new Map(existing.map((dispatch) => [dispatch.id, dispatch]));
-    const threadIds = new Set(existing.map((dispatch) => dispatch.threadId));
-    const pending = [];
-    for (const { dispatch, taskPath, taskDirectory, taskId } of inspection.records) {
-      if (dispatch === null) {
-        if (!existingById.has(taskId)) {
-          throw new Error(`empty legacy task directory has no matching dispatch: ${taskId}`);
-        }
-        pending.push({ dispatch: null, taskPath, taskDirectory });
-        continue;
-      }
-      const previous = existingById.get(dispatch.id);
-      if (previous && JSON.stringify(previous) !== JSON.stringify(dispatch)) {
-        throw new Error(`legacy task conflicts with dispatch: ${dispatch.id}`);
-      }
-      if (!previous && threadIds.has(dispatch.threadId)) {
-        throw new Error(`legacy task threadId is already recorded: ${dispatch.threadId}`);
-      }
-      if (!previous) {
-        pending.push({ dispatch, taskPath, taskDirectory });
-        existingById.set(dispatch.id, dispatch);
-        threadIds.add(dispatch.threadId);
-      } else {
-        pending.push({ dispatch: null, taskPath, taskDirectory });
-      }
-    }
-    await appendDispatchesAtomic(
-      workspaceRoot,
-      pending.filter((item) => item.dispatch).map((item) => item.dispatch),
-    );
-    return pending;
-  });
-  for (const migration of migrations) {
-    if (migration.taskPath !== null) await unlink(migration.taskPath);
-    await rmdir(migration.taskDirectory);
-  }
-  await rmdir(inspection.tasksPath);
-  return {
-    action: inspection.action,
-    migratedCount: migrations.filter((item) => item.dispatch).length,
-  };
-}
-
 export async function doctorWorkspace(workspaceRoot) {
   const root = path.resolve(workspaceRoot);
   const checks = [];
@@ -965,11 +852,5 @@ export async function doctorWorkspace(workspaceRoot) {
     }
     return "no legacy TaskChef skill links";
   });
-  await check("legacy-tasks", async () => {
-    if (await pathExists(path.join(root, "tasks"))) {
-      throw new Error("legacy tasks directory remains; run workspace init to migrate it");
-    }
-    return "no legacy task records";
-  });
   return { workspace: root, ok: checks.every((item) => item.status === "pass"), checks };
 }