taskchef 3.0.2 → 4.0.0

package/src/workspace.js

@@ -18,6 +18,11 @@ 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";
+import {
+  canonicalGithubRepository,
+  normalizeGithubRepositories,
+} from "./github.js";
 
 const execFile = promisify(execFileCallback);
 const DISPATCHER_INSTRUCTIONS_URL = new URL(
@@ -36,15 +41,18 @@ const SKILLS_SOURCE_ROOT = fileURLToPath(new URL("../skills/", import.meta.url))
 const DISPATCH_FILE_NAME = "tasks.jsonl";
 const DISPATCH_LOCK_NAME = ".taskchef-dispatch.lock";
 const SAFE_ID = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+const CURRENT_SCHEMA_VERSION = 2;
+const LEGACY_SCHEMA_VERSION = 1;
 const CONFIG_FIELDS = new Set(["schemaVersion", "projects"]);
 const PROJECT_FIELDS = new Set([
   "name",
   "path",
   "isGitRepository",
   "githubRepo",
+  "githubRepos",
   "description",
 ]);
-const PROJECT_INPUT_FIELDS = new Set(["name", "path", "githubRepo", "description"]);
+const PROJECT_INPUT_FIELDS = new Set(["name", "path", "githubRepos", "description"]);
 const DISPATCH_FIELDS = new Set([
   "schemaVersion",
   "id",
@@ -164,6 +172,12 @@ async function appendDispatchesAtomic(workspaceRoot, dispatches) {
   await writeTextAtomic(dispatchPath, `${content}${appended}`);
 }
 
+async function writeDispatchLinesAtomic(workspaceRoot, lines) {
+  const dispatchPath = path.join(workspaceRoot, DISPATCH_FILE_NAME);
+  const content = lines.length === 0 ? "" : `${lines.join("\n")}\n`;
+  await writeTextAtomic(dispatchPath, content);
+}
+
 async function writeJsonAtomic(filePath, value, { exclusive = false } = {}) {
   await mkdir(path.dirname(filePath), { recursive: true });
   if (exclusive && (await pathExists(filePath))) {
@@ -362,39 +376,23 @@ export async function canonicalDirectory(projectPath) {
   return requested;
 }
 
-function validateGithubRepository(value, name) {
-  if (value === null) return null;
-  requireString(value, name);
-  let url;
-  try {
-    url = new URL(value);
-  } catch {
-    throw new Error(`${name} must be a canonical GitHub repository URL or null`);
-  }
-  if (
-    url.protocol !== "https:" ||
-    url.hostname !== "github.com" ||
-    url.username ||
-    url.password ||
-    url.port ||
-    url.search ||
-    url.hash ||
-    !/^\/[^/]+\/[^/]+$/.test(url.pathname) ||
-    url.pathname.endsWith(".git")
-  ) {
-    throw new Error(`${name} must be a canonical GitHub repository URL or null`);
-  }
-  return value;
-}
-
-async function normalizeProject(project, index, { checkPath = true } = {}) {
+async function normalizeProject(
+  project,
+  index,
+  { checkPath = true, allowLegacyGithubRepo = false } = {},
+) {
   const field = `projects[${index}]`;
   if (!project || typeof project !== "object" || Array.isArray(project)) {
     throw new Error(`${field} must be an object`);
   }
   const unexpected = Object.keys(project).find((key) => !PROJECT_FIELDS.has(key));
   if (unexpected) throw new Error(`${field} has unsupported field: ${unexpected}`);
-  for (const required of ["name", "path", "isGitRepository", "githubRepo"]) {
+  const repositoryField = allowLegacyGithubRepo ? "githubRepo" : "githubRepos";
+  const unsupportedRepositoryField = allowLegacyGithubRepo ? "githubRepos" : "githubRepo";
+  if (unsupportedRepositoryField in project) {
+    throw new Error(`${field} has unsupported field: ${unsupportedRepositoryField}`);
+  }
+  for (const required of ["name", "path", "isGitRepository", repositoryField]) {
     if (!(required in project)) throw new Error(`${field} is missing field: ${required}`);
   }
   const name = requireString(project.name, `${field}.name`).trim();
@@ -412,15 +410,14 @@ async function normalizeProject(project, index, { checkPath = true } = {}) {
       throw new Error(`${field}.path must be a normalized absolute path`);
     }
   }
-  const githubRepo = validateGithubRepository(project.githubRepo, `${field}.githubRepo`);
-  if (!project.isGitRepository && githubRepo !== null) {
-    throw new Error(`${field}.githubRepo must be null for a non-Git project`);
-  }
+  const githubRepos = normalizeGithubRepositories(project[repositoryField], `${field}.${repositoryField}`, {
+    allowLegacyScalar: allowLegacyGithubRepo,
+  });
   const normalized = {
     name,
     path: projectPath,
     isGitRepository: project.isGitRepository,
-    githubRepo,
+    githubRepos,
   };
   if ("description" in project) {
     normalized.description = requireString(
@@ -431,11 +428,17 @@ async function normalizeProject(project, index, { checkPath = true } = {}) {
   return normalized;
 }
 
-async function normalizeProjects(projects, { checkPaths = true } = {}) {
+async function normalizeProjects(
+  projects,
+  { checkPaths = true, allowLegacyGithubRepo = false } = {},
+) {
   if (!Array.isArray(projects)) throw new Error("projects must be an array");
   const normalized = [];
   for (const [index, project] of projects.entries()) {
-    normalized.push(await normalizeProject(project, index, { checkPath: checkPaths }));
+    normalized.push(await normalizeProject(project, index, {
+      checkPath: checkPaths,
+      allowLegacyGithubRepo,
+    }));
   }
   if (new Set(normalized.map((project) => project.path)).size !== normalized.length) {
     throw new Error("project paths must not contain duplicates");
@@ -451,16 +454,8 @@ async function normalizeProjects(projects, { checkPaths = true } = {}) {
 
 function normalizeGithubRemote(remote) {
   if (typeof remote !== "string" || remote.trim().length === 0) return null;
-  const value = remote.trim();
-  const scpMatch = value.match(/^git@github\.com:([^/]+)\/(.+?)(?:\.git)?$/);
-  if (scpMatch) return `https://github.com/${scpMatch[1]}/${scpMatch[2]}`;
-  const sshMatch = value.match(/^ssh:\/\/git@github\.com\/([^/]+)\/(.+?)(?:\.git)?$/);
-  if (sshMatch) return `https://github.com/${sshMatch[1]}/${sshMatch[2]}`;
   try {
-    const url = new URL(value);
-    if (url.hostname !== "github.com") return null;
-    const match = url.pathname.match(/^\/([^/]+)\/([^/]+?)(?:\.git)?$/);
-    return match ? `https://github.com/${match[1]}/${match[2]}` : null;
+    return canonicalGithubRepository(remote, "GitHub origin");
   } catch {
     return null;
   }
@@ -500,10 +495,10 @@ async function inspectProject(input, index = 0) {
   if (isGitRepository && gitRoot !== projectPath) {
     throw new Error(`project must be the Git repository root: ${projectPath}`);
   }
-  let githubRepo = null;
+  let githubRepos = [];
   if (isGitRepository) {
-    if ("githubRepo" in input) {
-      githubRepo = validateGithubRepository(input.githubRepo, `${field}.githubRepo`);
+    if ("githubRepos" in input) {
+      githubRepos = normalizeGithubRepositories(input.githubRepos, `${field}.githubRepos`);
     } else {
       const remote = await execFile("git", ["remote", "get-url", "origin"], {
         cwd: projectPath,
@@ -511,10 +506,11 @@ async function inspectProject(input, index = 0) {
         if (error.code === 2 && /No such remote/i.test(error.stderr ?? "")) return null;
         throw gitInspectionError("failed to inspect GitHub origin", error);
       });
-      githubRepo = normalizeGithubRemote(remote);
+      const detected = normalizeGithubRemote(remote);
+      githubRepos = detected === null ? [] : [detected];
     }
-  } else if ("githubRepo" in input && input.githubRepo !== null) {
-    throw new Error(`${field}.githubRepo must be null for a non-Git project`);
+  } else if ("githubRepos" in input) {
+    githubRepos = normalizeGithubRepositories(input.githubRepos, `${field}.githubRepos`);
   }
   const project = {
     name: "name" in input
@@ -522,7 +518,7 @@ async function inspectProject(input, index = 0) {
       : path.basename(projectPath),
     path: projectPath,
     isGitRepository,
-    githubRepo,
+    githubRepos,
   };
   if ("description" in input) {
     project.description = requireString(input.description, `${field}.description`).trim();
@@ -532,10 +528,15 @@ async function inspectProject(input, index = 0) {
 
 export async function validateConfig(config, { checkPaths = true } = {}) {
   requireExactFields(config, CONFIG_FIELDS, "taskchef.json");
-  if (config.schemaVersion !== 1) throw new Error("unsupported configuration schemaVersion");
+  if (![LEGACY_SCHEMA_VERSION, CURRENT_SCHEMA_VERSION].includes(config.schemaVersion)) {
+    throw new Error("unsupported configuration schemaVersion");
+  }
   return {
-    schemaVersion: 1,
-    projects: await normalizeProjects(config.projects, { checkPaths }),
+    schemaVersion: CURRENT_SCHEMA_VERSION,
+    projects: await normalizeProjects(config.projects, {
+      checkPaths,
+      allowLegacyGithubRepo: config.schemaVersion === LEGACY_SCHEMA_VERSION,
+    }),
   };
 }
 
@@ -554,29 +555,38 @@ export async function initializeWorkspace(workspaceRoot) {
   const root = await realpath(requestedRoot);
   const configPath = path.join(root, "taskchef.json");
   const configExists = await managedRegularFileExists(configPath);
+  const storedConfigVersion = configExists
+    ? JSON.parse(await readFile(configPath, "utf8")).schemaVersion
+    : null;
   const config = configExists
     ? await readConfig(root, { checkPaths: false })
-    : { schemaVersion: 1, projects: [] };
+    : { schemaVersion: CURRENT_SCHEMA_VERSION, 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 });
+  else if (storedConfigVersion !== CURRENT_SCHEMA_VERSION) {
+    await writeJsonAtomic(configPath, config);
+  }
   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;
   });
   return {
     workspace: root,
-    config: { path: configPath, action: configExists ? "unchanged" : "created", value: config },
+    config: {
+      path: configPath,
+      action: !configExists
+        ? "created"
+        : storedConfigVersion === CURRENT_SCHEMA_VERSION ? "unchanged" : "migrated",
+      value: config,
+    },
     tasks,
     instructions,
     legacySkills,
-    legacyTasks,
   };
 }
 
@@ -600,7 +610,7 @@ export async function addProject(workspaceRoot, input) {
   const config = await readConfig(root);
   const project = await inspectProject(input);
   const updated = await validateConfig({
-    schemaVersion: 1,
+    schemaVersion: CURRENT_SCHEMA_VERSION,
     projects: [...config.projects, project],
   });
   await writeJsonAtomic(path.join(root, "taskchef.json"), updated);
@@ -620,6 +630,12 @@ export async function importProjects(workspaceRoot, inputs, { replace = false }
     if (!("description" in mergedInput) && existing?.description) {
       mergedInput.description = existing.description;
     }
+    if (existing && !replace) {
+      const importedRepositories = "githubRepos" in mergedInput
+        ? normalizeGithubRepositories(mergedInput.githubRepos, `projects[${index}].githubRepos`)
+        : [];
+      mergedInput.githubRepos = [...existing.githubRepos, ...importedRepositories];
+    }
     imported.push(await inspectProject(mergedInput, index));
   }
   const projects = replace ? [] : [...current.projects];
@@ -628,7 +644,7 @@ export async function importProjects(workspaceRoot, inputs, { replace = false }
     if (index === -1) projects.push(project);
     else projects[index] = project;
   }
-  const config = await validateConfig({ schemaVersion: 1, projects });
+  const config = await validateConfig({ schemaVersion: CURRENT_SCHEMA_VERSION, projects });
   await writeJsonAtomic(path.join(root, "taskchef.json"), config);
   return {
     mode: replace ? "replace" : "merge",
@@ -647,27 +663,44 @@ export async function removeProject(workspaceRoot, name) {
   if (index === -1) throw new Error(`configured project not found: ${name}`);
   const [project] = config.projects.slice(index, index + 1);
   const projects = config.projects.filter((_, projectIndex) => projectIndex !== index);
-  await writeJsonAtomic(path.join(root, "taskchef.json"), { schemaVersion: 1, projects });
+  await writeJsonAtomic(path.join(root, "taskchef.json"), {
+    schemaVersion: CURRENT_SCHEMA_VERSION,
+    projects,
+  });
   return { project };
 }
 
 async function validateDispatchShape(dispatch, name = "task") {
   requireExactFields(dispatch, DISPATCH_FIELDS, name);
-  if (dispatch.schemaVersion !== 1) throw new Error(`unsupported ${name} schemaVersion`);
+  if (![LEGACY_SCHEMA_VERSION, CURRENT_SCHEMA_VERSION].includes(dispatch.schemaVersion)) {
+    throw new Error(`unsupported ${name} schemaVersion`);
+  }
   const id = requireSafeId(dispatch.id, `${name}.id`);
-  const project = await normalizeProject(dispatch.project, 0, { checkPath: false });
-  return {
-    schemaVersion: 1,
+  const project = await normalizeProject(dispatch.project, 0, {
+    checkPath: false,
+    allowLegacyGithubRepo: dispatch.schemaVersion === LEGACY_SCHEMA_VERSION,
+  });
+  const normalized = {
+    schemaVersion: CURRENT_SCHEMA_VERSION,
     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) {
+async function readDispatchRecordsUnlocked(root) {
   await readConfig(root, { checkPaths: false });
   const filePath = path.join(root, DISPATCH_FILE_NAME);
   if (!(await managedRegularFileExists(filePath))) {
@@ -678,7 +711,7 @@ async function readDispatchesUnlocked(root) {
     throw new Error(`${DISPATCH_FILE_NAME} must end with a newline`);
   }
   const lines = content.length === 0 ? [] : content.slice(0, -1).split("\n");
-  const dispatches = [];
+  const records = [];
   for (const [index, line] of lines.entries()) {
     if (line.trim().length === 0) {
       throw new Error(`${DISPATCH_FILE_NAME} line ${index + 1} is empty`);
@@ -689,19 +722,27 @@ async function readDispatchesUnlocked(root) {
     } catch (error) {
       throw new Error(`${DISPATCH_FILE_NAME} line ${index + 1} is invalid JSON: ${error.message}`);
     }
-    dispatches.push(await validateDispatchShape(value, `task line ${index + 1}`));
+    records.push({
+      line,
+      raw: value,
+      normalized: await validateDispatchShape(value, `task line ${index + 1}`),
+    });
   }
   const ids = new Set();
   const threadIds = new Set();
-  for (const dispatch of dispatches) {
+  for (const { normalized: dispatch } of records) {
     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;
+  return records;
+}
+
+async function readDispatchesUnlocked(root) {
+  return (await readDispatchRecordsUnlocked(root)).map((record) => record.normalized);
 }
 
 export async function listTasks(workspaceRoot) {
@@ -717,7 +758,7 @@ export async function recordTask(workspaceRoot, input, { now } = {}) {
   const project = config.projects.find((candidate) => candidate.path === projectPath);
   if (!project) throw new Error(`project is not configured in taskchef.json: ${projectPath}`);
   const dispatch = await validateDispatchShape({
-    schemaVersion: 1,
+    schemaVersion: CURRENT_SCHEMA_VERSION,
     id: input.id,
     project,
     title: input.title,
@@ -730,7 +771,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 +782,35 @@ 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 records = await readDispatchRecordsUnlocked(root);
+    const dispatches = records.map((record) => record.normalized);
+    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 };
+    const lines = records.map((record, recordIndex) => recordIndex === index
+      ? JSON.stringify({ ...record.raw, threadId: durableThreadId })
+      : record.line);
+    await writeDispatchLinesAtomic(root, lines);
+    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 +848,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 +883,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 };
 }