@ordewell/core 0.4.9 → 0.4.10

package/dist/chunk-YI4ZDZEE.mjs

@@ -0,0 +1,862 @@
+import {
+  PlanParseError,
+  TASK_OPS_ENVELOPE_KEY,
+  addTaskToPlan,
+  createTask,
+  escapeControlCharsInStrings,
+  extractObjectsWithKey,
+  flattenTasks,
+  removeTaskFromPlan,
+  renumberTasks,
+  stripTrailingCommas,
+  updateTaskInPlan
+} from "./chunk-IO6PEEN6.mjs";
+
+// src/services/ModelAllowlistResolver.ts
+function effectiveAllowlist(allowlist, runner, modelsByRunner) {
+  if (!allowlist || allowlist.length === 0) return void 0;
+  if (!modelsByRunner) return allowlist;
+  const own = new Set((modelsByRunner[runner] ?? []).map((m) => m.modelId));
+  const elsewhere = /* @__PURE__ */ new Set();
+  for (const [other, models] of Object.entries(modelsByRunner)) {
+    if (other === runner) continue;
+    for (const m of models ?? []) elsewhere.add(m.modelId);
+  }
+  const kept = allowlist.filter((id) => own.has(id) || !elsewhere.has(id));
+  return kept.length > 0 ? kept : void 0;
+}
+function filterModelsForPrompt(modelsByRunner, perRunnerAllowlist) {
+  const result = {};
+  for (const [runner, models] of Object.entries(modelsByRunner)) {
+    if (!models) continue;
+    const allowed = effectiveAllowlist(perRunnerAllowlist[runner], runner, modelsByRunner);
+    if (!allowed) {
+      result[runner] = models;
+      continue;
+    }
+    const allowedSet = new Set(allowed);
+    const intersection = models.filter((m) => allowedSet.has(m.modelId));
+    const covered = new Set(intersection.map((m) => m.modelId));
+    const missing = allowed.filter((id) => !covered.has(id)).map((id) => ({ modelId: id, modelLabel: id.split("/").pop() || id, variants: [] }));
+    result[runner] = [...intersection, ...missing];
+  }
+  return result;
+}
+var EFFORT_LADDER = ["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"];
+var EFFORT_ALIASES = { disabled: "none", adaptive: "medium" };
+function clampThinkingEffort(effort, variants) {
+  if (!effort) return void 0;
+  if (variants.length === 0) return void 0;
+  const ids = new Set(variants.map((v) => v.id));
+  if (ids.has(effort)) return effort;
+  const canon = EFFORT_ALIASES[effort] ?? effort;
+  if (ids.has(canon)) return canon;
+  const idx = EFFORT_LADDER.indexOf(canon);
+  if (idx < 0) return void 0;
+  for (let d = 1; d < EFFORT_LADDER.length; d++) {
+    const lower = EFFORT_LADDER[idx - d];
+    if (lower && ids.has(lower)) return lower;
+    const higher = EFFORT_LADDER[idx + d];
+    if (higher && ids.has(higher)) return higher;
+  }
+  return void 0;
+}
+function coerceAssignments(tasks, perRunnerAllowlist, allowedRunners, modelsByRunner) {
+  const clampVariant = (task) => {
+    if (!task.assignedModel || !modelsByRunner) return task;
+    const model = modelsByRunner[task.assignedRunner]?.find(
+      (m) => m.modelId === task.assignedModel.modelId
+    );
+    if (!model) return task;
+    const clamped = clampThinkingEffort(task.assignedModel.thinkingEffort, model.variants);
+    return {
+      ...task,
+      assignedModel: {
+        ...task.assignedModel,
+        thinkingEffort: clamped,
+        availableVariants: model.variants.map((v) => v.id)
+      }
+    };
+  };
+  const allowedFor = (runner) => effectiveAllowlist(perRunnerAllowlist[runner], runner, modelsByRunner);
+  const assignmentFor = (runner, modelId) => {
+    const known = modelsByRunner?.[runner]?.find((m) => m.modelId === modelId);
+    return {
+      modelId,
+      modelLabel: known?.modelLabel ?? modelId,
+      thinkingEffort: void 0,
+      ...known ? { availableVariants: known.variants.map((v) => v.id) } : {}
+    };
+  };
+  return tasks.map((task) => {
+    if (task.type === "user") return task;
+    if (allowedRunners && !allowedRunners.includes(task.assignedRunner)) {
+      const fallbackRunner = allowedRunners[0];
+      const fallbackModels = allowedFor(fallbackRunner);
+      const fallbackModel = fallbackModels?.length ? assignmentFor(fallbackRunner, fallbackModels[0]) : modelsByRunner?.[fallbackRunner]?.[0] ? assignmentFor(fallbackRunner, modelsByRunner[fallbackRunner][0].modelId) : task.assignedModel;
+      return clampVariant({
+        ...task,
+        assignedRunner: fallbackRunner,
+        assignedModel: fallbackModel
+      });
+    }
+    const allowlist = allowedFor(task.assignedRunner);
+    if (!task.assignedModel) {
+      if (allowlist && allowlist.length > 0) {
+        return clampVariant({ ...task, assignedModel: assignmentFor(task.assignedRunner, allowlist[0]) });
+      }
+      const discovered = modelsByRunner?.[task.assignedRunner]?.[0];
+      if (discovered) {
+        return clampVariant({ ...task, assignedModel: assignmentFor(task.assignedRunner, discovered.modelId) });
+      }
+      return task;
+    }
+    if (!allowlist || allowlist.length === 0) return clampVariant(task);
+    if (allowlist.includes(task.assignedModel.modelId)) return clampVariant(task);
+    return { ...task, assignedModel: assignmentFor(task.assignedRunner, allowlist[0]) };
+  });
+}
+
+// src/services/TaskOps.ts
+import { v4 as uuidv4 } from "uuid";
+
+// src/services/TaskEditValidator.ts
+var AI_ONLY_FIELDS = ["assignedModel", "thinkingEffort", "taskMode", "autonomy"];
+function checkModelAndModeValidity(runner, assignedModel, taskMode, catalog) {
+  if (!catalog) return { ok: true };
+  if (assignedModel) {
+    const models = catalog.modelsByRunner[runner];
+    if (models) {
+      const modelId = assignedModel.modelId;
+      if (!models.some((m) => m.modelId === modelId)) {
+        return { ok: false, error: `Runner "${runner}" does not offer model "${modelId}"` };
+      }
+      const allowed = effectiveAllowlist(catalog.perRunnerAllowlist?.[runner], runner, catalog.modelsByRunner);
+      if (allowed && !allowed.includes(modelId)) {
+        return { ok: false, error: `Model "${modelId}" is excluded by the allowlist for runner "${runner}"` };
+      }
+    }
+  }
+  if (taskMode !== void 0) {
+    const modes = catalog.runnerModes[runner];
+    if (modes && modes.length > 0 && !modes.some((m) => m.id === taskMode)) {
+      return { ok: false, error: `Runner "${runner}" has no task mode "${taskMode}" \u2014 valid modes: ${modes.map((m) => m.id).join(", ")}` };
+    }
+  }
+  return { ok: true };
+}
+function typeCoherenceCheck(target, changes) {
+  if (!changes.type || changes.type === target.type) return null;
+  if (changes.type === "user") {
+    if (!Array.isArray(changes.userSteps) || changes.userSteps.length === 0) {
+      return { ok: false, error: `"${target.title}" cannot become a manual task without user steps \u2014 include "userSteps" in this edit` };
+    }
+    return { ok: true, clear: AI_ONLY_FIELDS.filter((f) => target[f] !== void 0) };
+  }
+  if (!changes.prompt || !changes.prompt.trim()) {
+    return { ok: false, error: `"${target.title}" cannot become an AI task without a prompt \u2014 include "prompt" in this edit` };
+  }
+  return { ok: true, clear: target.userSteps && target.userSteps.length > 0 ? ["userSteps"] : [] };
+}
+function validateTaskEdit(actor, tasks, taskId, changes, catalog) {
+  const target = tasks.find((t) => t.id === taskId);
+  if (!target) return { ok: false, error: "Task not found" };
+  if (actor === "planner") {
+    if (target.status === "in_progress") return { ok: false, error: `"${target.title}" is running and cannot be modified` };
+    if (target.status === "completed") return { ok: false, error: `"${target.title}" is completed and cannot be modified` };
+  }
+  if (changes.dependencies) {
+    const depCheck = canSetDependencies(tasks, taskId, changes.dependencies);
+    if (!depCheck.ok) return depCheck;
+  }
+  const coherence = typeCoherenceCheck(target, changes);
+  if (coherence && !coherence.ok) return coherence;
+  const runner = changes.assignedRunner ?? target.assignedRunner;
+  const validity = checkModelAndModeValidity(runner, changes.assignedModel, changes.taskMode, catalog);
+  if (!validity.ok) return validity;
+  return coherence ?? { ok: true };
+}
+
+// src/services/TaskOps.ts
+var UPDATABLE_FIELDS = [
+  "title",
+  "description",
+  "prompt",
+  "dependencies",
+  "assignedRunner",
+  "assignedModel",
+  "taskMode",
+  "thinkingEffort",
+  "type",
+  "userSteps",
+  "autonomy",
+  "sliceType"
+];
+function textHasTaskOps(text) {
+  return text.includes(`"${TASK_OPS_ENVELOPE_KEY}"`);
+}
+function parseTaskOpsJson(text) {
+  const { matches, fallback } = extractObjectsWithKey(text, TASK_OPS_ENVELOPE_KEY);
+  const candidates = matches.length > 0 ? [...matches].reverse() : [fallback.json];
+  let lastError = null;
+  for (const json of candidates) {
+    try {
+      return parseTaskOpsObject(json, text);
+    } catch (err) {
+      if (!(err instanceof PlanParseError)) throw err;
+      if (!lastError) lastError = err;
+    }
+  }
+  throw lastError ?? new PlanParseError("No JSON object found in task-ops reply", text);
+}
+function parseTaskOpsObject(json, text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(escapeControlCharsInStrings(stripTrailingCommas(json)));
+  } catch (err) {
+    throw new PlanParseError(`Task-ops JSON is invalid: ${err instanceof Error ? err.message : String(err)}`, text);
+  }
+  const ops = parsed.taskOps;
+  if (!Array.isArray(ops) || ops.length === 0) {
+    throw new PlanParseError('"taskOps" must be a non-empty array', text);
+  }
+  for (const op of ops) {
+    if (typeof op !== "object" || op === null || typeof op.op !== "string") {
+      throw new PlanParseError('Every task op needs an "op" field (update | add | remove | reorder | merge | split)', text);
+    }
+  }
+  return ops;
+}
+function resolveRef(ref, originalScope, liveScope, handleOwner, handleId, opIndex) {
+  if (typeof ref !== "string" && typeof ref !== "number") return { error: `invalid reference "${String(ref)}"` };
+  const s = String(ref).trim();
+  const ownerIdx = handleOwner.get(s);
+  if (ownerIdx !== void 0) {
+    if (ownerIdx >= opIndex) {
+      return { error: `handle "${s}" is defined later in this batch (op ${ownerIdx + 1}) and cannot be referenced yet` };
+    }
+    const id = handleId.get(s);
+    if (!id) return { error: `handle "${s}" was never resolved` };
+    return { id };
+  }
+  const byLiveId = liveScope.find((t) => t.id === s);
+  if (byLiveId) return { id: byLiveId.id };
+  const orderStr = s.startsWith("#") ? s.slice(1) : s;
+  if (/^\d+$/.test(orderStr)) {
+    const order = Number(orderStr);
+    const byOrder = originalScope.filter((t) => t.order === order);
+    if (byOrder.length === 1) return { id: byOrder[0].id };
+  }
+  const byTitle = originalScope.find((t) => t.title === s);
+  if (byTitle) return { id: byTitle.id };
+  return { error: `task "${s}" not found` };
+}
+function refCollidesWithExisting(name, originalFlatAll) {
+  if (originalFlatAll.some((t) => t.id === name)) return true;
+  const orderStr = name.startsWith("#") ? name.slice(1) : name;
+  if (/^\d+$/.test(orderStr) && originalFlatAll.some((t) => t.order === Number(orderStr))) return true;
+  return originalFlatAll.some((t) => t.title === name);
+}
+function findInTasks(tasks, id) {
+  return flattenTasks(tasks).find((t) => t.id === id);
+}
+function findTopLevel(tasks, id) {
+  return tasks.find((t) => t.id === id);
+}
+function detectCycle(tasks) {
+  const byId = new Map(tasks.map((t) => [t.id, t]));
+  const visiting = /* @__PURE__ */ new Set();
+  const done = /* @__PURE__ */ new Set();
+  const visit = (id) => {
+    if (done.has(id)) return null;
+    if (visiting.has(id)) return id;
+    visiting.add(id);
+    for (const dep of byId.get(id)?.dependencies ?? []) {
+      const hit = visit(dep);
+      if (hit) return hit;
+    }
+    visiting.delete(id);
+    done.add(id);
+    return null;
+  };
+  for (const t of tasks) {
+    const hit = visit(t.id);
+    if (hit) return byId.get(hit)?.title ?? hit;
+  }
+  return null;
+}
+function isPinned(t) {
+  return t.status === "in_progress" || t.status === "completed";
+}
+function repairOrder(tasks) {
+  const byId = new Map(tasks.map((t) => [t.id, t]));
+  const placed = /* @__PURE__ */ new Set();
+  const movable = tasks.filter((t) => !isPinned(t));
+  const result = [];
+  const blockerOf = (t) => {
+    const id = t.dependencies.find((d) => byId.has(d) && !placed.has(d));
+    return id ? byId.get(id) : void 0;
+  };
+  const place = (t) => {
+    result.push(t);
+    placed.add(t.id);
+  };
+  for (const occupant of tasks) {
+    if (isPinned(occupant)) {
+      const blocker = blockerOf(occupant);
+      if (blocker) return { error: pinnedRefusal(blocker, occupant, "before") };
+      place(occupant);
+      continue;
+    }
+    const next = movable.findIndex((t) => !blockerOf(t));
+    if (next < 0) {
+      const [stuck, pin] = trailToPin(movable[0], blockerOf);
+      return { error: pinnedRefusal(stuck, pin, "after") };
+    }
+    place(movable.splice(next, 1)[0]);
+  }
+  return { tasks: result };
+}
+function trailToPin(task, blockerOf) {
+  let at = task;
+  for (; ; ) {
+    const blocker = blockerOf(at);
+    if (!blocker || isPinned(blocker)) return [at, blocker ?? at];
+    at = blocker;
+  }
+}
+function describeMoves(before, after) {
+  const wasAt = new Map(before.map((t, i) => [t.id, i + 1]));
+  const moved = after.map((t, i) => ({ t, from: wasAt.get(t.id), to: i + 1 })).filter((m) => m.from !== m.to);
+  return moved.length ? moved.map((m) => `"${m.t.title}" #${m.from}\u2192#${m.to}`).join(", ") : null;
+}
+function pinnedRefusal(other, pin, side) {
+  const word = pin.status === "in_progress" ? "running" : "completed";
+  return `"${other.title}" would have to run ${side} "${pin.title}", which is ${word} and cannot be moved`;
+}
+function canMergeTasks(tasks, selectedIds) {
+  if (selectedIds.length < 2) return { ok: false, error: "Select at least two tasks to merge" };
+  const idSet = new Set(selectedIds);
+  const toMerge = tasks.filter((t) => idSet.has(t.id));
+  if (toMerge.length < 2) return { ok: false, error: "At least two valid tasks are required to merge" };
+  for (const t of toMerge) {
+    if (t.status === "in_progress") return { ok: false, error: `"${t.title}" is running and cannot be merged` };
+    if (t.status === "completed") return { ok: false, error: `"${t.title}" is completed and cannot be merged` };
+  }
+  const ordered = [...toMerge].sort((a, b) => a.order - b.order);
+  const survivorId = "__merge_sim__";
+  const sim = tasks.filter((t) => !idSet.has(t.id)).map((t) => ({ ...t, dependencies: t.dependencies.map((d) => idSet.has(d) ? survivorId : d).filter((d) => d !== t.id) }));
+  const unionDeps = [...new Set(toMerge.flatMap((t) => t.dependencies))].filter((d) => !idSet.has(d));
+  sim.push({ ...ordered[0], id: survivorId, title: "__merge_sim__", order: ordered[0].order, dependencies: unionDeps });
+  const cycle = detectCycle(sim);
+  if (cycle) return { ok: false, error: `Merging would create a dependency cycle involving "${cycle}"` };
+  return { ok: true };
+}
+function dependentsOf(tasks, taskId) {
+  return tasks.filter((t) => t.id !== taskId && t.dependencies.includes(taskId));
+}
+function dependencyCandidates(tasks, taskId) {
+  if (!taskId) return [...tasks];
+  const target = tasks.find((t) => t.id === taskId);
+  return target ? tasks.filter((t) => t.order < target.order) : [];
+}
+function canSetDependencies(tasks, taskId, dependencies) {
+  const target = tasks.find((t) => t.id === taskId);
+  if (!target) return { ok: false, error: "Task not found" };
+  const allowed = new Set(dependencyCandidates(tasks, taskId).map((t) => t.id));
+  for (const dep of dependencies) {
+    if (dep === taskId) return { ok: false, error: `"${target.title}" cannot depend on itself` };
+    const found = tasks.find((t) => t.id === dep);
+    if (!found) return { ok: false, error: `Unknown dependency "${dep}"` };
+    if (!allowed.has(dep)) {
+      return { ok: false, error: `"${target.title}" cannot depend on "${found.title}", which comes after it in the plan` };
+    }
+  }
+  return { ok: true };
+}
+function canSplitTask(tasks, taskId) {
+  const target = tasks.find((t) => t.id === taskId);
+  if (!target) return { ok: false, error: "Task not found" };
+  if (target.status === "in_progress") return { ok: false, error: `"${target.title}" is running and cannot be split` };
+  if (target.status === "completed") return { ok: false, error: `"${target.title}" is completed and cannot be split` };
+  return { ok: true };
+}
+function applyTaskOps(currentTasks, ops, runners, catalog) {
+  let tasks = JSON.parse(JSON.stringify(currentTasks));
+  const errors = [];
+  const summary = [];
+  const originalFlatAll = flattenTasks(currentTasks);
+  const handleOwner = /* @__PURE__ */ new Map();
+  const handleId = /* @__PURE__ */ new Map();
+  for (const [i, op] of ops.entries()) {
+    const handle = op.handle;
+    if (handle === void 0) continue;
+    if (typeof handle !== "string" || !handle.trim()) {
+      errors.push(`op ${i + 1} (${op.op}): handle must be a non-empty string`);
+      continue;
+    }
+    if (handleOwner.has(handle)) {
+      errors.push(`op ${i + 1} (${op.op}): handle "${handle}" is already used earlier in this batch`);
+      continue;
+    }
+    if (refCollidesWithExisting(handle, originalFlatAll)) {
+      errors.push(`op ${i + 1} (${op.op}): handle "${handle}" collides with an existing task reference`);
+      continue;
+    }
+    handleOwner.set(handle, i);
+  }
+  if (errors.length) return { ok: false, tasks: currentTasks, errors, summary: [] };
+  const resolveDeps = (deps, opIndex) => {
+    const ids = [];
+    const bad = [];
+    const liveFlat = flattenTasks(tasks);
+    for (const d of Array.isArray(deps) ? deps : []) {
+      const r = resolveRef(d, originalFlatAll, liveFlat, handleOwner, handleId, opIndex);
+      if ("error" in r) {
+        bad.push(`${String(d)} (${r.error})`);
+        continue;
+      }
+      if (!liveFlat.some((t) => t.id === r.id)) {
+        bad.push(`${String(d)} (no longer exists in this batch)`);
+        continue;
+      }
+      ids.push(r.id);
+    }
+    return { ids, bad };
+  };
+  for (const [i, op] of ops.entries()) {
+    const label = `op ${i + 1} (${op.op})`;
+    switch (op.op) {
+      case "update": {
+        const ref = resolveRef(op.taskId, originalFlatAll, flattenTasks(tasks), handleOwner, handleId, i);
+        if ("error" in ref) {
+          errors.push(`${label}: ${ref.error}`);
+          break;
+        }
+        const target = findInTasks(tasks, ref.id);
+        if (!target) {
+          errors.push(`${label}: task "${op.taskId}" no longer exists in this batch (removed, merged, or split by an earlier op)`);
+          break;
+        }
+        const changes = {};
+        for (const key of UPDATABLE_FIELDS) {
+          if (op.changes && key in op.changes) changes[key] = op.changes[key];
+        }
+        if (changes.assignedRunner && !runners.includes(changes.assignedRunner)) {
+          errors.push(`${label}: runner "${changes.assignedRunner}" is not in this plan's runner set [${runners.join(", ")}]`);
+          break;
+        }
+        const changesForCheck = { ...changes };
+        delete changesForCheck.dependencies;
+        const check = validateTaskEdit("planner", flattenTasks(tasks), target.id, changesForCheck, catalog);
+        if (!check.ok) {
+          errors.push(`${label}: ${check.error}`);
+          break;
+        }
+        for (const field of check.clear ?? []) changes[field] = void 0;
+        if ("dependencies" in changes) {
+          const { ids, bad } = resolveDeps(changes.dependencies, i);
+          if (bad.length) {
+            errors.push(`${label}: unknown dependencies: ${bad.join(", ")}`);
+            break;
+          }
+          changes.dependencies = ids.filter((id) => id !== target.id);
+        }
+        if (Object.keys(changes).length === 0) {
+          errors.push(`${label}: no valid changes provided`);
+          break;
+        }
+        tasks = updateTaskInPlan(tasks, target.id, changes);
+        const clearedNote = check.clear?.length ? `; cleared ${check.clear.join(", ")}` : "";
+        summary.push(`Updated "${target.title}" (${Object.keys(changes).join(", ")})${clearedNote}`);
+        break;
+      }
+      case "add": {
+        const spec = op.task ?? {};
+        if (!spec.title) {
+          errors.push(`${label}: new task needs a title`);
+          break;
+        }
+        const { ids, bad } = resolveDeps(spec.dependencies, i);
+        if (bad.length) {
+          errors.push(`${label}: unknown dependencies: ${bad.join(", ")}`);
+          break;
+        }
+        const runner = spec.assignedRunner && runners.includes(spec.assignedRunner) ? spec.assignedRunner : runners[0];
+        const validity = checkModelAndModeValidity(runner, spec.assignedModel, spec.taskMode, catalog);
+        if (!validity.ok) {
+          errors.push(`${label}: ${validity.error}`);
+          break;
+        }
+        const newId = uuidv4();
+        tasks = addTaskToPlan(tasks, {
+          ...spec,
+          id: newId,
+          dependencies: ids,
+          assignedRunner: runner,
+          description: spec.description ?? spec.title,
+          prompt: spec.prompt ?? spec.description ?? spec.title
+        });
+        if (op.handle) handleId.set(op.handle, newId);
+        summary.push(`Added "${spec.title}"`);
+        break;
+      }
+      case "remove": {
+        const ref = resolveRef(op.taskId, originalFlatAll, flattenTasks(tasks), handleOwner, handleId, i);
+        if ("error" in ref) {
+          errors.push(`${label}: ${ref.error}`);
+          break;
+        }
+        const target = findInTasks(tasks, ref.id);
+        if (!target) {
+          errors.push(`${label}: task "${op.taskId}" no longer exists in this batch (removed, merged, or split by an earlier op)`);
+          break;
+        }
+        if (target.status === "in_progress") {
+          errors.push(`${label}: "${target.title}" is running and cannot be removed`);
+          break;
+        }
+        if (target.status === "completed") {
+          errors.push(`${label}: "${target.title}" is completed and cannot be removed`);
+          break;
+        }
+        tasks = removeTaskFromPlan(tasks, target.id);
+        summary.push(`Removed "${target.title}"`);
+        break;
+      }
+      case "reorder": {
+        const refs = (op.taskIds ?? []).map((r) => resolveRef(r, currentTasks, tasks, handleOwner, handleId, i));
+        const badRef = refs.find((r) => "error" in r);
+        if (badRef) {
+          errors.push(`${label}: ${badRef.error}`);
+          break;
+        }
+        const resolved = refs.map((r) => findTopLevel(tasks, r.id));
+        if (resolved.some((t) => !t)) {
+          errors.push(`${label}: unknown task in reorder list`);
+          break;
+        }
+        const orderIds = resolved.map((t) => t.id);
+        if (new Set(orderIds).size !== tasks.length) {
+          errors.push(`${label}: reorder must list every top-level task exactly once (${tasks.length} tasks)`);
+          break;
+        }
+        const byId = new Map(tasks.map((t) => [t.id, t]));
+        tasks = renumberTasks(orderIds.map((id) => byId.get(id)));
+        summary.push("Reordered tasks");
+        break;
+      }
+      case "merge": {
+        const refs = (op.taskIds ?? []).map((r) => resolveRef(r, currentTasks, tasks, handleOwner, handleId, i));
+        const badRef = refs.find((r) => "error" in r);
+        if (badRef) {
+          errors.push(`${label}: ${badRef.error}`);
+          break;
+        }
+        const resolved = refs.map((r) => findTopLevel(tasks, r.id));
+        if (resolved.some((t) => !t)) {
+          errors.push(`${label}: unknown task in merge list (already removed, merged, or split by an earlier op)`);
+          break;
+        }
+        const toMerge = resolved.map((t) => t).sort((a, b) => a.order - b.order);
+        if (toMerge.length < 2) {
+          errors.push(`${label}: merge needs at least two tasks`);
+          break;
+        }
+        const locked = toMerge.find((t) => t.status === "in_progress" || t.status === "completed");
+        if (locked) {
+          errors.push(`${label}: "${locked.title}" is ${locked.status === "in_progress" ? "running" : "completed"} and cannot be merged`);
+          break;
+        }
+        const idSet = new Set(toMerge.map((t) => t.id));
+        const unionDepsRaw = [...new Set(toMerge.flatMap((t) => t.dependencies))].filter((d) => !idSet.has(d));
+        const { ids, bad } = resolveDeps(unionDepsRaw, i);
+        if (bad.length) {
+          errors.push(`${label}: unknown dependencies: ${bad.join(", ")}`);
+          break;
+        }
+        const spec = op.merged ?? {};
+        if (!spec.title) {
+          errors.push(`${label}: merged task needs a title`);
+          break;
+        }
+        const runner = spec.assignedRunner && runners.includes(spec.assignedRunner) ? spec.assignedRunner : toMerge[0].assignedRunner;
+        const mergedTask = createTask({
+          title: spec.title,
+          description: spec.description ?? toMerge.map((t) => t.description).filter(Boolean).join("\n\n"),
+          prompt: spec.prompt ?? (toMerge.map((t) => t.prompt).filter(Boolean).join("\n\n---\n\n") || void 0),
+          type: spec.type ?? (toMerge.some((t) => t.type === "user") ? "user" : "ai"),
+          dependencies: ids,
+          assignedRunner: runner,
+          assignedModel: spec.assignedModel ?? toMerge.find((t) => t.assignedModel)?.assignedModel,
+          thinkingEffort: spec.thinkingEffort ?? toMerge.find((t) => t.thinkingEffort)?.thinkingEffort,
+          taskMode: spec.taskMode ?? toMerge[0].taskMode,
+          autonomy: spec.autonomy ?? toMerge.find((t) => t.autonomy)?.autonomy,
+          sliceType: spec.sliceType ?? toMerge.find((t) => t.sliceType)?.sliceType,
+          userStoriesCovered: spec.userStoriesCovered ?? (toMerge.flatMap((t) => t.userStoriesCovered ?? []).length ? [...new Set(toMerge.flatMap((t) => t.userStoriesCovered ?? []))] : void 0)
+        });
+        const mergedId = mergedTask.id;
+        const firstId = toMerge[0].id;
+        const result = [];
+        let inserted = false;
+        for (const t of tasks) {
+          if (idSet.has(t.id)) {
+            if (!inserted && t.id === firstId) {
+              result.push(mergedTask);
+              inserted = true;
+            }
+            continue;
+          }
+          result.push({ ...t, dependencies: t.dependencies.map((d) => idSet.has(d) ? mergedId : d) });
+        }
+        if (!inserted) result.push(mergedTask);
+        tasks = renumberTasks(result);
+        if (op.handle) handleId.set(op.handle, mergedId);
+        summary.push(`Merged ${toMerge.length} tasks into "${spec.title}"`);
+        break;
+      }
+      case "split": {
+        const ref = resolveRef(op.taskId, currentTasks, tasks, handleOwner, handleId, i);
+        if ("error" in ref) {
+          errors.push(`${label}: ${ref.error}`);
+          break;
+        }
+        const target = findTopLevel(tasks, ref.id);
+        if (!target) {
+          errors.push(`${label}: task "${op.taskId}" not found`);
+          break;
+        }
+        if (target.status === "in_progress") {
+          errors.push(`${label}: "${target.title}" is running and cannot be split`);
+          break;
+        }
+        if (target.status === "completed") {
+          errors.push(`${label}: "${target.title}" is completed and cannot be split`);
+          break;
+        }
+        const parts = op.parts ?? [];
+        if (parts.length < 2) {
+          errors.push(`${label}: split needs at least two parts`);
+          break;
+        }
+        const newTasks = [];
+        let prevId;
+        let buildError = false;
+        for (let p = 0; p < parts.length; p++) {
+          const spec = parts[p];
+          if (!spec || !spec.title) {
+            errors.push(`${label}: split part ${p + 1} needs a title`);
+            buildError = true;
+            break;
+          }
+          let deps;
+          if (p === 0) {
+            const { ids, bad } = resolveDeps(target.dependencies, i);
+            if (bad.length) {
+              errors.push(`${label}: split part 1 unknown dependencies: ${bad.join(", ")}`);
+              buildError = true;
+              break;
+            }
+            deps = ids;
+          } else {
+            deps = prevId ? [prevId] : [];
+          }
+          const runner = spec.assignedRunner && runners.includes(spec.assignedRunner) ? spec.assignedRunner : target.assignedRunner;
+          const nt = createTask({
+            title: spec.title,
+            description: spec.description ?? spec.title,
+            prompt: spec.prompt ?? spec.description ?? spec.title,
+            type: spec.type ?? target.type,
+            dependencies: deps,
+            assignedRunner: runner,
+            assignedModel: spec.assignedModel ?? target.assignedModel,
+            taskMode: spec.taskMode ?? target.taskMode,
+            autonomy: spec.autonomy ?? target.autonomy,
+            sliceType: spec.sliceType ?? target.sliceType,
+            userStoriesCovered: spec.userStoriesCovered ?? target.userStoriesCovered
+          });
+          newTasks.push(nt);
+          prevId = nt.id;
+        }
+        if (buildError) break;
+        const tailId = newTasks[newTasks.length - 1].id;
+        const result = [];
+        for (const t of tasks) {
+          if (t.id === target.id) {
+            result.push(...newTasks);
+            continue;
+          }
+          result.push({ ...t, dependencies: t.dependencies.map((d) => d === target.id ? tailId : d) });
+        }
+        tasks = renumberTasks(result);
+        if (op.handle) handleId.set(op.handle, tailId);
+        summary.push(`Split "${target.title}" into ${newTasks.length} tasks`);
+        break;
+      }
+      case "rearm": {
+        const ref = resolveRef(op.taskId, originalFlatAll, flattenTasks(tasks), handleOwner, handleId, i);
+        if ("error" in ref) {
+          errors.push(`${label}: ${ref.error}`);
+          break;
+        }
+        const target = findInTasks(tasks, ref.id);
+        if (!target) {
+          errors.push(`${label}: task "${op.taskId}" no longer exists in this batch (removed, merged, or split by an earlier op)`);
+          break;
+        }
+        if (target.status === "in_progress") {
+          errors.push(`${label}: "${target.title}" is running and cannot be re-armed`);
+          break;
+        }
+        const changes = {};
+        for (const key of UPDATABLE_FIELDS) {
+          if (op.changes && key in op.changes) changes[key] = op.changes[key];
+        }
+        if (changes.assignedRunner && !runners.includes(changes.assignedRunner)) {
+          errors.push(`${label}: runner "${changes.assignedRunner}" is not in this plan's runner set [${runners.join(", ")}]`);
+          break;
+        }
+        const changesForCheck = { ...changes };
+        delete changesForCheck.dependencies;
+        const check = validateTaskEdit("direct", flattenTasks(tasks), target.id, changesForCheck, catalog);
+        if (!check.ok) {
+          errors.push(`${label}: ${check.error}`);
+          break;
+        }
+        for (const field of check.clear ?? []) changes[field] = void 0;
+        if ("dependencies" in changes) {
+          const { ids, bad } = resolveDeps(changes.dependencies, i);
+          if (bad.length) {
+            errors.push(`${label}: unknown dependencies: ${bad.join(", ")}`);
+            break;
+          }
+          changes.dependencies = ids.filter((id) => id !== target.id);
+        }
+        tasks = updateTaskInPlan(tasks, target.id, { ...changes, status: "pending", verdict: void 0, outputSummary: void 0 });
+        for (const dep of flattenTasks(tasks)) {
+          if (dep.status === "blocked" && dep.dependencies.includes(target.id)) {
+            tasks = updateTaskInPlan(tasks, dep.id, { status: "pending" });
+          }
+        }
+        const clearedNote = check.clear?.length ? `; cleared ${check.clear.join(", ")}` : "";
+        const changedNote = Object.keys(changes).length ? ` (${Object.keys(changes).join(", ")})` : "";
+        summary.push(`Re-armed "${target.title}"${changedNote}${clearedNote}`);
+        break;
+      }
+      default:
+        errors.push(`${label}: unknown op "${op.op}"`);
+    }
+    if (errors.length) break;
+  }
+  if (!errors.length) {
+    const flat = flattenTasks(tasks);
+    const idSet = new Set(flat.map((t) => t.id));
+    for (const t of flat) {
+      for (const dep of t.dependencies) {
+        if (!idSet.has(dep)) errors.push(`"${t.title}" depends on a task that no longer exists (${dep})`);
+      }
+    }
+    const cycleAt = detectCycle(flat);
+    if (cycleAt) errors.push(`Dependency cycle detected involving "${cycleAt}"`);
+    if (!errors.length) {
+      const repaired = repairOrder(tasks);
+      if ("error" in repaired) {
+        errors.push(repaired.error);
+      } else {
+        const moves = describeMoves(tasks, repaired.tasks);
+        if (moves) summary.push(`Reordered to keep dependencies first: ${moves}`);
+        tasks = renumberTasks(repaired.tasks);
+      }
+    }
+  }
+  return errors.length ? { ok: false, tasks: currentTasks, errors, summary: [] } : { ok: true, tasks, errors: [], summary };
+}
+
+// src/services/researchStepSummary.ts
+function ellipsize(text, max) {
+  const oneLine = text.replace(/\s+/g, " ").trim();
+  return oneLine.length > max ? `${oneLine.slice(0, max)}\u2026` : oneLine;
+}
+function summarizeToolCall(tool, argsJson, toolLabel) {
+  const display = toolLabel?.trim() || tool;
+  if (tool === "agent_tool") {
+    try {
+      const args = JSON.parse(argsJson);
+      const hint = args.path ?? args.file_path ?? args.filePath ?? args.pattern ?? args.query ?? args.url ?? args.command;
+      if (hint) return `${display} ${ellipsize(String(hint), 50)}`;
+    } catch {
+    }
+    return display;
+  }
+  if (tool === "spawn_research_agent") {
+    try {
+      const args = JSON.parse(argsJson);
+      const prompt = typeof args.prompt === "string" ? args.prompt : "";
+      const oneLine = prompt.replace(/\s+/g, " ").trim();
+      return `spawn: "${oneLine.slice(0, 60)}${oneLine.length > 60 ? "\u2026" : ""}"`;
+    } catch {
+      return "spawn_research_agent";
+    }
+  }
+  try {
+    const args = JSON.parse(argsJson);
+    if (tool === "find_symbol" && args.symbol) {
+      return `find_symbol ${args.symbol}${args.language ? ` [${args.language}]` : ""}`;
+    }
+    if (tool === "web_search" && args.query) {
+      return `web_search "${ellipsize(String(args.query), 50)}"`;
+    }
+    if (tool === "fetch" && args.url) {
+      return `fetch ${ellipsize(String(args.url), 60)}`;
+    }
+    if (tool === "glob" && args.pattern) {
+      return `glob ${ellipsize(String(args.pattern), 50)}`;
+    }
+    if (tool === "grep" && args.pattern) {
+      const mode = args.output_mode && args.output_mode !== "content" ? ` (${args.output_mode})` : "";
+      const scope = args.include ? ` in ${args.include}` : "";
+      return `grep ${ellipsize(String(args.pattern), 40)}${scope}${mode}`;
+    }
+    const path = args.filePath || args.file_path || args.path;
+    if (path) {
+      const basename = String(path).split("/").pop() || String(path);
+      return `${display} ${basename}`;
+    }
+    if (args.pattern) {
+      return `${display} ${args.pattern}`;
+    }
+    if (args.command) {
+      return `bash: ${String(args.command).slice(0, 40)}`;
+    }
+  } catch {
+  }
+  return display;
+}
+function classifyOutcome(success, output) {
+  if (!success) {
+    if (/^Command refused:/.test(output) || /is not available\. You are a read-only research subagent/.test(output)) return "refused";
+    if (/not approved/i.test(output) || /^Access denied:/.test(output) || /needs user approval/i.test(output)) return "denied";
+    return "failure";
+  }
+  return "success";
+}
+
+export {
+  effectiveAllowlist,
+  filterModelsForPrompt,
+  clampThinkingEffort,
+  coerceAssignments,
+  validateTaskEdit,
+  UPDATABLE_FIELDS,
+  textHasTaskOps,
+  parseTaskOpsJson,
+  canMergeTasks,
+  dependentsOf,
+  dependencyCandidates,
+  canSetDependencies,
+  canSplitTask,
+  applyTaskOps,
+  summarizeToolCall,
+  classifyOutcome
+};
+//# sourceMappingURL=chunk-YI4ZDZEE.mjs.map