codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/plan-service.js

@@ -0,0 +1,682 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plan_service_exports = {};
+__export(plan_service_exports, {
+  addPlanScope: () => addPlanScope,
+  appendTaskCodeReference: () => appendTaskCodeReference,
+  appendTaskToPlan: () => appendTaskToPlan,
+  claimTask: () => claimTask,
+  createPlan: () => createPlan,
+  deletePlan: () => deletePlan,
+  getNextTask: () => getNextTask,
+  getPlan: () => getPlan,
+  getPlanVersions: () => getPlanVersions,
+  getSubtasks: () => getSubtasks,
+  getTaskByUid: () => getTaskByUid,
+  getTasksByPlan: () => getTasksByPlan,
+  listPlans: () => listPlans,
+  listPlansByRepoUrl: () => listPlansByRepoUrl,
+  removePlanScope: () => removePlanScope,
+  setPlanHomeRepo: () => setPlanHomeRepo,
+  updatePlan: () => updatePlan,
+  updateTask: () => updateTask
+});
+module.exports = __toCommonJS(plan_service_exports);
+var _lazy___plan_file_service = __toESM(require("./plan-file-service"));
+var _lazy___git_identity = __toESM(require("./git-identity"));
+var import_node_crypto = require("node:crypto");
+var import_database = require("./database");
+var import_persistence = require("./persistence");
+var planItemService = __toESM(require("./plan-item-service"));
+function deriveAffectedFiles(fileSpecs, existing) {
+  if (!fileSpecs || fileSpecs.length === 0) return existing ?? [];
+  const set = /* @__PURE__ */ new Set();
+  for (const fs of fileSpecs) {
+    if (fs.path) set.add(fs.path);
+    if (fs.moveTo) set.add(fs.moveTo);
+  }
+  const ordered = Array.from(set);
+  if (existing) {
+    for (const p of existing) {
+      if (!set.has(p)) {
+        ordered.push(p);
+        set.add(p);
+      }
+    }
+  }
+  return ordered;
+}
+function notifyMutation(planUid) {
+  try {
+    const { scheduleWriteThrough } = _lazy___plan_file_service;
+    scheduleWriteThrough(planUid);
+  } catch {
+  }
+}
+function normalizePath(p) {
+  return p.replace(/\/+$/, "") || p;
+}
+function createPlan(input, author, authorType, projectPath) {
+  const db = (0, import_database.getDb)();
+  const uid = input.uid ?? (0, import_node_crypto.randomUUID)();
+  const now = Date.now();
+  const normalizedPath = normalizePath(projectPath);
+  const { getNormalisedOriginUrl } = _lazy___git_identity;
+  const homeRepo = normalizedPath ? getNormalisedOriginUrl(normalizedPath) ?? null : null;
+  db.run(
+    `INSERT INTO plans (uid, title, description, status, author, author_type, project_path, created_at, updated_at, home_repo, scope)
+     VALUES (?, ?, ?, 'draft', ?, ?, ?, ?, ?, ?, '[]')`,
+    [uid, input.title, input.description || "", author, authorType, normalizedPath, now, now, homeRepo]
+  );
+  const tasks = [];
+  for (let i = 0; i < input.tasks.length; i++) {
+    const t = input.tasks[i];
+    const taskUid = (0, import_node_crypto.randomUUID)();
+    const fileSpecs = t.fileSpecs ?? [];
+    const affectedFiles = deriveAffectedFiles(fileSpecs, t.affectedFiles);
+    db.run(
+      `INSERT INTO tasks (uid, plan_uid, sort_order, description, status, affected_files, affected_symbols, new_connections, removed_connections, dependencies, file_spec, symbol_specs, parent_task_uid, body, prompt, scope_path, file_specs, created_at, updated_at)
+       VALUES (?, ?, ?, ?, 'pending', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        taskUid,
+        uid,
+        i,
+        t.description,
+        JSON.stringify(affectedFiles),
+        JSON.stringify(t.affectedSymbols || []),
+        JSON.stringify(t.newConnections || []),
+        JSON.stringify(t.removedConnections || []),
+        JSON.stringify(t.dependencies || []),
+        t.fileSpec ?? null,
+        JSON.stringify(t.symbolSpecs || []),
+        t.parentTaskUid ?? null,
+        t.body ?? null,
+        t.prompt ?? null,
+        t.scopePath ?? null,
+        JSON.stringify(fileSpecs),
+        now,
+        now
+      ]
+    );
+    tasks.push({
+      uid: taskUid,
+      planUid: uid,
+      sortOrder: i,
+      description: t.description,
+      status: "pending",
+      assignee: null,
+      assigneeType: null,
+      assigneeModel: null,
+      affectedFiles,
+      affectedSymbols: t.affectedSymbols || [],
+      newConnections: t.newConnections || [],
+      removedConnections: t.removedConnections || [],
+      dependencies: t.dependencies || [],
+      fileSpec: t.fileSpec,
+      symbolSpecs: t.symbolSpecs || [],
+      phaseUid: null,
+      parentTaskUid: t.parentTaskUid ?? null,
+      body: t.body,
+      prompt: t.prompt,
+      scopePath: t.scopePath ?? null,
+      fileSpecs,
+      progressPercent: null,
+      blockedReason: null,
+      createdAt: now,
+      updatedAt: now
+    });
+  }
+  const plan = {
+    uid,
+    title: input.title,
+    description: input.description || "",
+    status: "draft",
+    author,
+    authorType,
+    projectPath,
+    createdAt: now,
+    updatedAt: now,
+    taskCount: tasks.length,
+    completedTaskCount: 0,
+    homeRepo,
+    scope: []
+  };
+  db.run(
+    `INSERT INTO plan_versions (plan_uid, version, snapshot, change_summary, author, author_type, created_at)
+     VALUES (?, 1, ?, 'Plan created', ?, ?, ?)`,
+    [uid, JSON.stringify(plan), author, authorType, now]
+  );
+  (0, import_persistence.markDirty)();
+  notifyMutation(plan.uid);
+  return plan;
+}
+const PLAN_COLUMNS = `uid, title, description, status, author, author_type, project_path, created_at, updated_at,
+        base_ref, target_branch, target_worktree, auto_create_branch,
+        home_repo, scope`;
+function rowToPlanCore(r) {
+  let scope = [];
+  try {
+    const parsed = JSON.parse(r[14] ?? "[]");
+    if (Array.isArray(parsed)) scope = parsed.filter((s) => typeof s === "string");
+  } catch {
+  }
+  return {
+    uid: r[0],
+    title: r[1],
+    description: r[2],
+    status: r[3],
+    author: r[4],
+    authorType: r[5],
+    projectPath: r[6],
+    createdAt: r[7],
+    updatedAt: r[8],
+    baseRef: r[9] ?? null,
+    targetBranch: r[10] ?? null,
+    targetWorktree: r[11] ?? null,
+    autoCreateBranch: !!r[12],
+    // Phase 3.3 — cross-repo scope
+    homeRepo: r[13] ?? null,
+    scope
+  };
+}
+function getPlan(planUid) {
+  const db = (0, import_database.getDb)();
+  const result = db.exec(
+    `SELECT ${PLAN_COLUMNS} FROM plans WHERE uid = ?`,
+    [planUid]
+  );
+  if (!result[0]?.values[0]) return null;
+  const r = result[0].values[0];
+  const tasks = getTasksByPlan(planUid);
+  const core = rowToPlanCore(r);
+  return {
+    ...core,
+    // Same source as the list — see `countPlanActions`. Counting the
+    // legacy `tasks` array here meant the plan DETAIL disagreed with
+    // itself too: 0 actions beside an item tree that plainly had some.
+    ...countPlanActions(db, planUid),
+    tasks
+  };
+}
+function countPlanActions(db, planUid) {
+  const items = db.exec(
+    `SELECT COUNT(*), SUM(CASE WHEN status = 'done' THEN 1 ELSE 0 END)
+     FROM plan_items WHERE plan_uid = ? AND kind = 'action'`,
+    [planUid]
+  );
+  const itemTotal = items[0]?.values[0]?.[0] || 0;
+  if (itemTotal > 0) {
+    return { taskCount: itemTotal, completedTaskCount: items[0]?.values[0]?.[1] || 0 };
+  }
+  const legacy = db.exec(
+    `SELECT COUNT(*), SUM(CASE WHEN status = 'done' THEN 1 ELSE 0 END) FROM tasks WHERE plan_uid = ?`,
+    [planUid]
+  );
+  return {
+    taskCount: legacy[0]?.values[0]?.[0] || 0,
+    completedTaskCount: legacy[0]?.values[0]?.[1] || 0
+  };
+}
+function listPlans(projectPath, statusFilter) {
+  const db = (0, import_database.getDb)();
+  let query = `SELECT ${PLAN_COLUMNS} FROM plans WHERE status != 'archived'`;
+  const params = [];
+  if (projectPath) {
+    query += ` AND project_path = ?`;
+    params.push(normalizePath(projectPath));
+  }
+  if (statusFilter) {
+    query += ` AND status = ?`;
+    params.push(statusFilter);
+  }
+  query += ` ORDER BY updated_at DESC`;
+  const result = db.exec(query, params);
+  if (!result[0]) return [];
+  return result[0].values.map((r) => {
+    const core = rowToPlanCore(r);
+    return { ...core, ...countPlanActions(db, r[0]) };
+  });
+}
+function updatePlan(planUid, changes, author, authorType) {
+  const db = (0, import_database.getDb)();
+  const now = Date.now();
+  const sets = ["updated_at = ?"];
+  const params = [now];
+  if (changes.title !== void 0) {
+    sets.push("title = ?");
+    params.push(changes.title);
+  }
+  if (changes.description !== void 0) {
+    sets.push("description = ?");
+    params.push(changes.description);
+  }
+  if (changes.status !== void 0) {
+    sets.push("status = ?");
+    params.push(changes.status);
+  }
+  if (changes.baseRef !== void 0) {
+    sets.push("base_ref = ?");
+    params.push(changes.baseRef);
+  }
+  if (changes.targetBranch !== void 0) {
+    sets.push("target_branch = ?");
+    params.push(changes.targetBranch);
+  }
+  if (changes.targetWorktree !== void 0) {
+    sets.push("target_worktree = ?");
+    params.push(changes.targetWorktree);
+  }
+  if (changes.autoCreateBranch !== void 0) {
+    sets.push("auto_create_branch = ?");
+    params.push(changes.autoCreateBranch ? 1 : 0);
+  }
+  params.push(planUid);
+  db.run(`UPDATE plans SET ${sets.join(", ")} WHERE uid = ?`, params);
+  const plan = getPlan(planUid);
+  if (plan) {
+    const vr = db.exec(`SELECT MAX(version) FROM plan_versions WHERE plan_uid = ?`, [planUid]);
+    const nextVersion = (vr[0]?.values[0]?.[0] || 0) + 1;
+    db.run(
+      `INSERT INTO plan_versions (plan_uid, version, snapshot, change_summary, author, author_type, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`,
+      [planUid, nextVersion, JSON.stringify(plan), Object.keys(changes).join(", ") + " updated", author, authorType, now]
+    );
+  }
+  (0, import_persistence.markDirty)();
+  notifyMutation(planUid);
+}
+function deletePlan(planUid) {
+  (0, import_database.getDb)().run(`UPDATE plans SET status = 'archived', updated_at = ? WHERE uid = ?`, [Date.now(), planUid]);
+  (0, import_persistence.markDirty)();
+  notifyMutation(planUid);
+}
+function setPlanHomeRepo(planUid, homeRepoUrl) {
+  const { normaliseRepoUrl } = _lazy___git_identity;
+  const normalised = homeRepoUrl ? normaliseRepoUrl(homeRepoUrl) : null;
+  const now = Date.now();
+  (0, import_database.getDb)().run(
+    `UPDATE plans SET home_repo = ?, updated_at = ? WHERE uid = ?`,
+    [normalised, now, planUid]
+  );
+  (0, import_persistence.markDirty)();
+  notifyMutation(planUid);
+}
+function addPlanScope(planUid, repoUrl) {
+  const { normaliseRepoUrl } = _lazy___git_identity;
+  const normalised = normaliseRepoUrl(repoUrl);
+  if (!normalised) throw new Error("addPlanScope: repoUrl must be a non-empty URL");
+  const plan = getPlan(planUid);
+  if (!plan) throw new Error(`Plan ${planUid} not found`);
+  if (plan.homeRepo && normalised === plan.homeRepo) {
+    return plan.scope ?? [];
+  }
+  const current = plan.scope ?? [];
+  if (current.includes(normalised)) return current;
+  const next = [...current, normalised];
+  const now = Date.now();
+  (0, import_database.getDb)().run(
+    `UPDATE plans SET scope = ?, updated_at = ? WHERE uid = ?`,
+    [JSON.stringify(next), now, planUid]
+  );
+  (0, import_persistence.markDirty)();
+  notifyMutation(planUid);
+  return next;
+}
+function removePlanScope(planUid, repoUrl) {
+  const { normaliseRepoUrl } = _lazy___git_identity;
+  const normalised = normaliseRepoUrl(repoUrl);
+  if (!normalised) throw new Error("removePlanScope: repoUrl must be a non-empty URL");
+  const plan = getPlan(planUid);
+  if (!plan) throw new Error(`Plan ${planUid} not found`);
+  const current = plan.scope ?? [];
+  if (!current.includes(normalised)) return current;
+  const next = current.filter((r) => r !== normalised);
+  const now = Date.now();
+  (0, import_database.getDb)().run(
+    `UPDATE plans SET scope = ?, updated_at = ? WHERE uid = ?`,
+    [JSON.stringify(next), now, planUid]
+  );
+  (0, import_persistence.markDirty)();
+  notifyMutation(planUid);
+  return next;
+}
+function listPlansByRepoUrl(repoUrl) {
+  const { normaliseRepoUrl } = _lazy___git_identity;
+  const normalised = normaliseRepoUrl(repoUrl);
+  if (!normalised) return [];
+  const db = (0, import_database.getDb)();
+  const result = db.exec(
+    `SELECT ${PLAN_COLUMNS} FROM plans
+     WHERE status != 'archived'
+       AND (home_repo = ? OR scope LIKE ?)
+     ORDER BY updated_at DESC`,
+    [normalised, `%"${normalised}"%`]
+  );
+  if (!result[0]) return [];
+  return result[0].values.map((r) => {
+    const core = rowToPlanCore(r);
+    return { ...core, ...countPlanActions(db, r[0]) };
+  });
+}
+const TASK_COLUMNS = `uid, plan_uid, sort_order, description, status, assignee, assignee_type, assignee_model,
+            affected_files, affected_symbols, new_connections, removed_connections, dependencies,
+            file_spec, symbol_specs, phase_uid,
+            parent_task_uid, body, prompt, scope_path, file_specs,
+            progress_percent, blocked_reason,
+            created_at, updated_at`;
+function rowToTask(r) {
+  return {
+    uid: r[0],
+    planUid: r[1],
+    sortOrder: r[2],
+    description: r[3],
+    status: r[4],
+    assignee: r[5],
+    assigneeType: r[6],
+    assigneeModel: r[7],
+    affectedFiles: JSON.parse(r[8] || "[]"),
+    affectedSymbols: JSON.parse(r[9] || "[]"),
+    newConnections: JSON.parse(r[10] || "[]"),
+    removedConnections: JSON.parse(r[11] || "[]"),
+    dependencies: JSON.parse(r[12] || "[]"),
+    fileSpec: r[13] ?? void 0,
+    symbolSpecs: JSON.parse(r[14] || "[]"),
+    phaseUid: r[15] ?? null,
+    parentTaskUid: r[16] ?? null,
+    body: r[17] ?? void 0,
+    prompt: r[18] ?? void 0,
+    scopePath: r[19] ?? null,
+    fileSpecs: JSON.parse(r[20] || "[]"),
+    progressPercent: r[21] ?? null,
+    blockedReason: r[22] ?? null,
+    createdAt: r[23],
+    updatedAt: r[24]
+  };
+}
+function getTasksByPlan(planUid) {
+  const result = (0, import_database.getDb)().exec(
+    `SELECT ${TASK_COLUMNS} FROM tasks WHERE plan_uid = ? ORDER BY sort_order`,
+    [planUid]
+  );
+  if (!result[0]) return [];
+  return result[0].values.map(rowToTask);
+}
+function getSubtasks(parentTaskUid) {
+  const result = (0, import_database.getDb)().exec(
+    `SELECT ${TASK_COLUMNS} FROM tasks WHERE parent_task_uid = ? ORDER BY sort_order`,
+    [parentTaskUid]
+  );
+  if (!result[0]) return [];
+  return result[0].values.map(rowToTask);
+}
+function updateTask(taskUid, updates) {
+  const now = Date.now();
+  const sets = ["updated_at = ?"];
+  const params = [now];
+  if (updates.status !== void 0) {
+    sets.push("status = ?");
+    params.push(updates.status);
+  }
+  if (updates.assignee !== void 0) {
+    sets.push("assignee = ?");
+    params.push(updates.assignee);
+  }
+  if (updates.assigneeType !== void 0) {
+    sets.push("assignee_type = ?");
+    params.push(updates.assigneeType);
+  }
+  if (updates.assigneeModel !== void 0) {
+    sets.push("assignee_model = ?");
+    params.push(updates.assigneeModel);
+  }
+  if (updates.description !== void 0) {
+    sets.push("description = ?");
+    params.push(updates.description);
+  }
+  if (updates.affectedSymbols !== void 0) {
+    sets.push("affected_symbols = ?");
+    params.push(JSON.stringify(updates.affectedSymbols));
+  }
+  if (updates.newConnections !== void 0) {
+    sets.push("new_connections = ?");
+    params.push(JSON.stringify(updates.newConnections));
+  }
+  if (updates.removedConnections !== void 0) {
+    sets.push("removed_connections = ?");
+    params.push(JSON.stringify(updates.removedConnections));
+  }
+  if (updates.dependencies !== void 0) {
+    sets.push("dependencies = ?");
+    params.push(JSON.stringify(updates.dependencies));
+  }
+  if (updates.fileSpec !== void 0) {
+    sets.push("file_spec = ?");
+    params.push(updates.fileSpec);
+  }
+  if (updates.symbolSpecs !== void 0) {
+    sets.push("symbol_specs = ?");
+    params.push(JSON.stringify(updates.symbolSpecs));
+  }
+  if (updates.phaseUid !== void 0) {
+    sets.push("phase_uid = ?");
+    params.push(updates.phaseUid);
+  }
+  if (updates.parentTaskUid !== void 0) {
+    sets.push("parent_task_uid = ?");
+    params.push(updates.parentTaskUid);
+  }
+  if (updates.body !== void 0) {
+    sets.push("body = ?");
+    params.push(updates.body);
+  }
+  if (updates.prompt !== void 0) {
+    sets.push("prompt = ?");
+    params.push(updates.prompt);
+  }
+  if (updates.scopePath !== void 0) {
+    sets.push("scope_path = ?");
+    params.push(updates.scopePath);
+  }
+  if (updates.progressPercent !== void 0) {
+    sets.push("progress_percent = ?");
+    params.push(updates.progressPercent);
+  }
+  if (updates.blockedReason !== void 0) {
+    sets.push("blocked_reason = ?");
+    params.push(updates.blockedReason);
+  }
+  if (updates.fileSpecs !== void 0) {
+    const merged = deriveAffectedFiles(updates.fileSpecs, updates.affectedFiles);
+    sets.push("file_specs = ?");
+    params.push(JSON.stringify(updates.fileSpecs));
+    sets.push("affected_files = ?");
+    params.push(JSON.stringify(merged));
+  } else if (updates.affectedFiles !== void 0) {
+    sets.push("affected_files = ?");
+    params.push(JSON.stringify(updates.affectedFiles));
+  }
+  params.push(taskUid);
+  (0, import_database.getDb)().run(`UPDATE tasks SET ${sets.join(", ")} WHERE uid = ?`, params);
+  (0, import_persistence.markDirty)();
+  const parent = (0, import_database.getDb)().exec(`SELECT plan_uid FROM tasks WHERE uid = ?`, [taskUid]);
+  const planUid = parent[0]?.values[0]?.[0];
+  if (planUid) notifyMutation(planUid);
+}
+function appendTaskCodeReference(taskUid, ref) {
+  const db = (0, import_database.getDb)();
+  const result = db.exec(
+    `SELECT affected_files, file_spec FROM tasks WHERE uid = ?`,
+    [taskUid]
+  );
+  if (!result[0]?.values[0]) return null;
+  const [filesJson, currentSpec] = result[0].values[0];
+  const existingFiles = JSON.parse(filesJson || "[]");
+  const nextFiles = existingFiles.includes(ref.filePath) ? existingFiles : [...existingFiles, ref.filePath];
+  const range = ref.startLine != null && ref.endLine != null ? `${ref.filePath}:${ref.startLine}-${ref.endLine}` : ref.filePath;
+  const lines = [];
+  lines.push("");
+  lines.push(`### Reference: \`${range}\``);
+  if (ref.note?.trim()) {
+    lines.push("");
+    lines.push(ref.note.trim());
+  }
+  if (ref.codeSnippet?.trim()) {
+    lines.push("");
+    lines.push("```");
+    lines.push(ref.codeSnippet.replace(/```/g, "`\u200B``"));
+    lines.push("```");
+  }
+  const appended = (currentSpec || "") + lines.join("\n");
+  updateTask(taskUid, { affectedFiles: nextFiles, fileSpec: appended });
+  return getTaskByUid(taskUid);
+}
+function getTaskByUid(taskUid) {
+  const result = (0, import_database.getDb)().exec(
+    `SELECT ${TASK_COLUMNS} FROM tasks WHERE uid = ?`,
+    [taskUid]
+  );
+  if (!result[0]?.values[0]) return null;
+  return rowToTask(result[0].values[0]);
+}
+function appendTaskToPlan(planUid, input) {
+  const db = (0, import_database.getDb)();
+  const planExists = db.exec(`SELECT uid FROM plans WHERE uid = ?`, [planUid]);
+  if (!planExists[0]?.values[0]) return null;
+  const orderResult = db.exec(`SELECT COALESCE(MAX(sort_order), -1) FROM tasks WHERE plan_uid = ?`, [planUid]);
+  const nextOrder = (orderResult[0]?.values[0]?.[0] ?? -1) + 1;
+  const taskUid = (0, import_node_crypto.randomUUID)();
+  const now = Date.now();
+  const fileSpecs = input.fileSpecs ?? [];
+  const affectedFiles = deriveAffectedFiles(fileSpecs, input.affectedFiles);
+  db.run(
+    `INSERT INTO tasks (uid, plan_uid, sort_order, description, status, affected_files, affected_symbols, new_connections, removed_connections, dependencies, file_spec, symbol_specs, parent_task_uid, body, prompt, scope_path, file_specs, created_at, updated_at)
+     VALUES (?, ?, ?, ?, 'pending', ?, ?, '[]', '[]', '[]', ?, '[]', ?, ?, ?, ?, ?, ?, ?)`,
+    [
+      taskUid,
+      planUid,
+      nextOrder,
+      input.description,
+      JSON.stringify(affectedFiles),
+      JSON.stringify(input.affectedSymbols || []),
+      input.fileSpec ?? null,
+      input.parentTaskUid ?? null,
+      input.body ?? null,
+      input.prompt ?? null,
+      input.scopePath ?? null,
+      JSON.stringify(fileSpecs),
+      now,
+      now
+    ]
+  );
+  (0, import_persistence.markDirty)();
+  notifyMutation(planUid);
+  return getTaskByUid(taskUid);
+}
+function claimTask(taskUid, agentId, agentType, model) {
+  const result = (0, import_database.getDb)().exec(`SELECT status, assignee, plan_uid, affected_files FROM tasks WHERE uid = ?`, [taskUid]);
+  if (!result[0]?.values[0]) return { ok: false };
+  const [status, assignee, planUid, affectedFilesJson] = result[0].values[0];
+  if (assignee || status !== "pending") return { ok: false };
+  const affectedFiles = JSON.parse(affectedFilesJson || "[]");
+  const conflicts = [];
+  if (affectedFiles.length > 0) {
+    const otherTasks = getTasksByPlan(planUid);
+    for (const other of otherTasks) {
+      if (other.uid === taskUid) continue;
+      if (other.status !== "in_progress" && other.status !== "assigned") continue;
+      if (other.assignee === agentId) continue;
+      const overlap = other.affectedFiles.filter((f) => affectedFiles.includes(f));
+      if (overlap.length > 0) {
+        conflicts.push(`Task "${other.description}" (${other.assignee}) also affects: ${overlap.join(", ")}`);
+      }
+    }
+  }
+  updateTask(taskUid, { status: "assigned", assignee: agentId, assigneeType: agentType, assigneeModel: model || null });
+  return { ok: true, conflicts: conflicts.length > 0 ? conflicts : void 0 };
+}
+function getNextTask(planUid, phaseUid) {
+  const items = planItemService.listAllItems(planUid);
+  if (items.length > 0) return nextPlanItem(items, phaseUid);
+  const tasks = getTasksByPlan(planUid);
+  const done = new Set(tasks.filter((t) => t.status === "done").map((t) => t.uid));
+  for (const task of tasks) {
+    if (task.status !== "pending") continue;
+    if (phaseUid !== void 0 && task.phaseUid !== phaseUid) continue;
+    if (task.dependencies.every((d) => done.has(d))) return task;
+  }
+  return null;
+}
+function nextPlanItem(items, parentUid) {
+  const local = new Map(items.map((i) => [i.uid, i]));
+  for (const item of items) {
+    if (item.kind !== "action") continue;
+    if (item.status !== "pending") continue;
+    if (parentUid !== void 0 && item.parentUid !== parentUid) continue;
+    if (planItemService.dependencyStateOf(item, local).met) return item;
+  }
+  return null;
+}
+function getPlanVersions(planUid) {
+  const result = (0, import_database.getDb)().exec(
+    `SELECT id, plan_uid, version, snapshot, change_summary, author, created_at, author_type
+     FROM plan_versions WHERE plan_uid = ? ORDER BY version DESC`,
+    [planUid]
+  );
+  if (!result[0]) return [];
+  return result[0].values.map((r) => ({
+    id: r[0],
+    planUid: r[1],
+    version: r[2],
+    snapshot: r[3],
+    changeSummary: r[4],
+    author: r[5],
+    createdAt: r[6],
+    authorType: r[7] ?? null
+  }));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addPlanScope,
+  appendTaskCodeReference,
+  appendTaskToPlan,
+  claimTask,
+  createPlan,
+  deletePlan,
+  getNextTask,
+  getPlan,
+  getPlanVersions,
+  getSubtasks,
+  getTaskByUid,
+  getTasksByPlan,
+  listPlans,
+  listPlansByRepoUrl,
+  removePlanScope,
+  setPlanHomeRepo,
+  updatePlan,
+  updateTask
+});