@ordewell/core 0.5.4 → 0.5.6

package/dist/chunk-GWPIYDQW.mjs

@@ -1,945 +0,0 @@
-import {
-  PlanParseError,
-  TASK_OPS_ENVELOPE_KEY,
-  addTaskToPlan,
-  createTask,
-  escapeControlCharsInStrings,
-  extractObjectsWithKey,
-  flattenTasks,
-  removeTaskFromPlan,
-  renumberTasks,
-  stripTrailingCommas,
-  updateTaskInPlan
-} from "./chunk-JVMDEHRQ.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;
-      const allowed = effectiveAllowlist(catalog.perRunnerAllowlist?.[runner], runner, catalog.modelsByRunner);
-      if (!models.some((m) => m.modelId === modelId) && !allowed?.includes(modelId)) {
-        return { ok: false, error: `Runner "${runner}" does not offer model "${modelId}"` };
-      }
-      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 taskOpsProtocol(executionNote = "") {
-  const updateChanges = UPDATABLE_FIELDS.map((f) => f === "dependencies" ? '"dependencies"?:["<id or #order>"]' : `"${f}"?`).join(",");
-  return [
-    "- To modify specific tasks, reply with ONLY this JSON object:",
-    '  {"taskOps": [',
-    `    {"op":"update","taskId":"<id or #order>","changes":{${updateChanges}}},`,
-    '    {"op":"add","task":{"title","description","prompt","dependencies":["<id or #order>"],"assignedRunner"?,"assignedModel"?},"handle"?:"<name>"},',
-    '    {"op":"remove","taskId":"<id or #order>"},',
-    '    {"op":"reorder","taskIds":["<id or #order>", "... every task exactly once"]},   // only to re-prioritise INDEPENDENT tasks',
-    '    {"op":"merge","taskIds":["<id or #order>", "..."],"merged":{"title","description","prompt"?,"assignedRunner"?,"assignedModel"?,...},"handle"?:"<name>"},',
-    '    {"op":"split","taskId":"<id or #order>","parts":[{"title","description","prompt"?,"assignedRunner"?,"assignedModel"?,...}, ...],"handle"?:"<name>"},',
-    `    {"op":"rearm","taskId":"<id or #order>","changes"?:{${updateChanges}}}`,
-    "  ]}",
-    '- For sweeping changes, you may instead emit a full {"tasks":[...]} plan JSON.',
-    'Every "<id or #order>" ref in a batch resolves against the plan shown above, before any op in the batch runs \u2014 an earlier remove/merge/split never shifts what a later "#N" means.',
-    'Give "add", "merge", or "split" a "handle" (any name you choose, unused elsewhere in this batch) to let a LATER op in the same batch reference the task it produces \u2014 for "split", the handle names its last part. A handle used before its defining op is rejected.',
-    'When creating or changing tasks, set "assignedRunner" and "assignedModel" ({"modelId","modelLabel","thinkingEffort"?}) using only the runners and models listed in <available_models>.',
-    'Keep dependencies consistent: no cycles, no references to removed tasks, and never touch running or completed tasks \u2014 "rearm" is the one exception, below.',
-    'Just declare the dependencies you want \u2014 display order is repaired for you afterwards, so a rewire or a newly added prerequisite never needs a "reorder" op. Only a task that is running or completed cannot be shifted, so an edit that would need one to move is rejected.' + executionNote,
-    'Flipping "type" between "ai" and "user" is a content change, not just a label: an update to "user" needs "userSteps" in the SAME op, and an update to "ai" needs "prompt" in the SAME op \u2014 the model/mode/effort/autonomy fields (flipping to "user") or the userSteps (flipping to "ai") are cleared automatically.',
-    '"rearm" puts a failed OR completed task back to pending \u2014 verdict and output summary are cleared, any dependents it had blocked are released, and it may carry field changes (e.g. a corrected "prompt") applied in the same op. A running task cannot be re-armed. Never rearm a task just to relabel it \u2014 only when it should actually run again.'
-  ];
-}
-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";
-}
-
-// src/services/SessionMessage.ts
-function serializeTask(t) {
-  return {
-    id: t.id,
-    order: t.order,
-    title: t.title,
-    type: t.type,
-    description: t.description,
-    dependencies: t.dependencies || [],
-    assignedRunner: t.assignedRunner,
-    assignedModel: t.assignedModel || null,
-    taskMode: t.taskMode || "build",
-    prompt: t.prompt || null,
-    subtasks: (t.subtasks || []).map(serializeTask),
-    userSteps: t.userSteps || void 0,
-    thinkingEffort: t.thinkingEffort || void 0,
-    autonomy: t.autonomy || void 0,
-    sliceType: t.sliceType || void 0,
-    userStoriesCovered: t.userStoriesCovered || void 0
-  };
-}
-function serializeTaskStatus(t, idleSince = null, isolation = null) {
-  return {
-    id: t.id,
-    status: t.status,
-    verdict: t.verdict ? { outcome: t.verdict.outcome, reason: t.verdict.reason, checks: t.verdict.checks || [] } : null,
-    idleSince,
-    ...isolation ? { isolation } : {}
-  };
-}
-function serializePlan(plan) {
-  return {
-    tasks: plan.tasks.map(serializeTask),
-    runners: plan.runners,
-    generatedAt: plan.generatedAt,
-    conversationHistory: plan.conversationHistory,
-    prdMarkdown: plan.prdMarkdown,
-    queuedMessages: plan.queuedMessages
-  };
-}
-function executionSummary(tasks) {
-  return {
-    total: tasks.length,
-    completed: tasks.filter((t) => t.status === "completed").length,
-    failed: tasks.filter((t) => t.status === "failed").length
-  };
-}
-var CHECKPOINT_TRUNCATE_LENGTH = 120;
-function truncateCheckpointSummary(summary) {
-  const firstLine = summary.split("\n")[0].trim();
-  if (firstLine.length <= CHECKPOINT_TRUNCATE_LENGTH) return firstLine;
-  return firstLine.slice(0, CHECKPOINT_TRUNCATE_LENGTH - 1) + "\u2026";
-}
-
-export {
-  effectiveAllowlist,
-  filterModelsForPrompt,
-  clampThinkingEffort,
-  coerceAssignments,
-  validateTaskEdit,
-  taskOpsProtocol,
-  textHasTaskOps,
-  parseTaskOpsJson,
-  canMergeTasks,
-  dependentsOf,
-  dependencyCandidates,
-  canSetDependencies,
-  canSplitTask,
-  applyTaskOps,
-  summarizeToolCall,
-  classifyOutcome,
-  serializeTask,
-  serializeTaskStatus,
-  serializePlan,
-  executionSummary,
-  CHECKPOINT_TRUNCATE_LENGTH,
-  truncateCheckpointSummary
-};
-//# sourceMappingURL=chunk-GWPIYDQW.mjs.map