@ordewell/core 0.10.5 → 0.10.6

package/dist/chunk-4QLFM73A.mjs

@@ -1,1407 +0,0 @@
-import {
-  DEFAULT_RUNNERS,
-  addTaskToPlan,
-  createTask,
-  flattenTasks,
-  flattenTasksWithParents,
-  inheritedOps,
-  inheritedSkills,
-  opsFlag,
-  removeTaskFromPlan,
-  renumberTasks,
-  resolveTaskRef,
-  skillNames,
-  updateTaskInPlan
-} from "./chunk-RT4NQ2BZ.mjs";
-
-// src/services/JsonExtractor.ts
-var PLAN_ENVELOPE_KEY = "tasks";
-var TASK_OPS_ENVELOPE_KEY = "taskOps";
-var TASK_QUERY_ENVELOPE_KEY = "taskQuery";
-var PlanParseError = class extends Error {
-  raw;
-  /**
-   * True when the reply was cut off mid-object (output-token limit) rather
-   * than malformed — the two need different repairs: a truncated emission will
-   * be cut at the same point again unless the retry frees context or asks for
-   * terser output.
-   */
-  truncated;
-  /**
-   * True when the JSON parsed fine and a *shape* rule rejected it. The generic
-   * "could not be parsed as JSON" corrective is a lie for these, so the model
-   * re-sends the same object; a semantic rejection must be repaired by naming
-   * the rule it broke.
-   */
-  semantic;
-  constructor(message, raw, opts) {
-    super(message);
-    this.name = "PlanParseError";
-    this.raw = raw;
-    this.truncated = opts?.truncated ?? false;
-    this.semantic = opts?.semantic ?? false;
-  }
-};
-function stripModelNoise(raw) {
-  return raw.replace(/<think>[\s\S]*?<\/think>/gi, "").replace(/```json\s*/gi, "").replace(/```\s*/g, "").trim();
-}
-var THINK_OPEN = "<think>";
-var THINK_CLOSE = "</think>";
-var FENCE = "```";
-var FENCE_JSON_TAG = "json";
-function opensWithJsonObject(prefix) {
-  let rest = prefix;
-  for (; ; ) {
-    rest = rest.trimStart();
-    if (!rest) return void 0;
-    const head = rest.slice(0, THINK_OPEN.length).toLowerCase();
-    if (head === THINK_OPEN) {
-      const close = rest.toLowerCase().indexOf(THINK_CLOSE);
-      if (close < 0) return void 0;
-      rest = rest.slice(close + THINK_CLOSE.length);
-      continue;
-    }
-    if (rest.startsWith(FENCE)) {
-      rest = rest.slice(FENCE.length);
-      const tag = rest.slice(0, FENCE_JSON_TAG.length).toLowerCase();
-      if (tag === FENCE_JSON_TAG) rest = rest.slice(FENCE_JSON_TAG.length);
-      else if (tag === rest.toLowerCase() && FENCE_JSON_TAG.startsWith(tag)) return void 0;
-      continue;
-    }
-    if (THINK_OPEN.startsWith(head) || FENCE.startsWith(rest)) return void 0;
-    return rest.startsWith("{");
-  }
-}
-function balancedObjectAt(text2, start) {
-  let depth = 0;
-  let inString = false;
-  let escaped = false;
-  for (let i = start; i < text2.length; i++) {
-    const ch = text2[i];
-    if (inString) {
-      if (escaped) escaped = false;
-      else if (ch === "\\") escaped = true;
-      else if (ch === '"') inString = false;
-      continue;
-    }
-    if (ch === '"') inString = true;
-    else if (ch === "{") depth++;
-    else if (ch === "}") {
-      depth--;
-      if (depth === 0) return { json: text2.slice(start, i + 1), balanced: true };
-    }
-  }
-  return { json: text2.slice(start), balanced: false };
-}
-function extractObjectsWithKey(raw, key) {
-  const stripped = stripModelNoise(raw);
-  const keyRe = new RegExp(`"${key}"\\s*:`);
-  const matches = [];
-  let firstObject = null;
-  let sawBrace = false;
-  let sawUnbalanced = false;
-  let inString = false;
-  let escaped = false;
-  for (let i = 0; i < stripped.length; i++) {
-    const ch = stripped[i];
-    if (inString) {
-      if (escaped) escaped = false;
-      else if (ch === "\\") escaped = true;
-      else if (ch === '"') inString = false;
-      continue;
-    }
-    if (ch === '"') {
-      inString = true;
-      continue;
-    }
-    if (ch !== "{") continue;
-    sawBrace = true;
-    const obj = balancedObjectAt(stripped, i);
-    if (obj.balanced && keyRe.test(obj.json)) {
-      matches.push(obj.json);
-      i += obj.json.length - 1;
-      continue;
-    }
-    if (!obj.balanced) sawUnbalanced = true;
-    if (!firstObject && obj.balanced) firstObject = obj.json;
-  }
-  return {
-    matches,
-    fallback: firstObject !== null ? { json: firstObject, balanced: true } : { json: stripped, balanced: false },
-    sawBrace,
-    sawUnbalanced
-  };
-}
-function extractObjectWithBalance(raw) {
-  const { matches, fallback, sawBrace } = extractObjectsWithKey(raw, PLAN_ENVELOPE_KEY);
-  if (matches.length > 0) return { json: matches[0], balanced: true, sawBrace };
-  return { ...fallback, sawBrace };
-}
-function extractJsonObject(raw) {
-  return extractObjectWithBalance(raw).json;
-}
-function stripTrailingCommas(json) {
-  return json.replace(/,(\s*[}\]])/g, "$1");
-}
-function escapeControlCharsInStrings(json) {
-  let out = "";
-  let inString = false;
-  let escaped = false;
-  for (const ch of json) {
-    if (inString) {
-      if (escaped) {
-        out += ch;
-        escaped = false;
-        continue;
-      }
-      if (ch === "\\") {
-        out += ch;
-        escaped = true;
-        continue;
-      }
-      if (ch === '"') {
-        out += ch;
-        inString = false;
-        continue;
-      }
-      if (ch === "\n") {
-        out += "\\n";
-        continue;
-      }
-      if (ch === "\r") {
-        out += "\\r";
-        continue;
-      }
-      if (ch === "	") {
-        out += "\\t";
-        continue;
-      }
-      out += ch;
-      continue;
-    }
-    if (ch === '"') inString = true;
-    out += ch;
-  }
-  return out;
-}
-
-// src/services/ModeResolver.ts
-function runnerModesFrom(registry, runners) {
-  return Object.fromEntries(runners.map((r) => [r, registry.getManifest(r)?.modes ?? []]));
-}
-function resolveDefaultMode(modes, autonomousDefault = true) {
-  if (!modes || modes.length === 0) return void 0;
-  const tag = autonomousDefault ? "autonomous" : "safe";
-  const tagged = modes.find((m) => m[tag]);
-  if (tagged) return tagged.id;
-  for (let i = modes.length - 1; i >= 0; i--) {
-    if (!modes[i].readOnly && modes[i].id !== "plan") return modes[i].id;
-  }
-  return void 0;
-}
-function autonomyLevelLabel(autonomous) {
-  return autonomous ? "Full" : "Guarded";
-}
-function parseAutonomyLevel(arg) {
-  switch (arg?.trim().toLowerCase()) {
-    case "full":
-    case "on":
-      return true;
-    case "guarded":
-    case "auto":
-    case "off":
-      return false;
-    default:
-      return null;
-  }
-}
-function taggedReadOnlyMode(modes) {
-  return modes?.find((m) => m.readOnly)?.id;
-}
-function readOnlyMode(modes) {
-  const mode = modes?.find((m) => m.readOnly);
-  return mode && !mode.unavailable ? mode.id : void 0;
-}
-function unavailableModeReason(modes, id) {
-  return id === void 0 ? void 0 : modes?.find((m) => m.id === id)?.unavailable;
-}
-function unavailableModeError(runner, id, reason) {
-  return `Mode "${id}" of runner "${runner}" is unavailable on this host: ${reason}`;
-}
-function unavailableTaskModeMessage(manifest, mode) {
-  const reason = unavailableModeReason(manifest.modes, mode);
-  return reason ? `Mode "${mode}" of ${manifest.displayName} is unavailable on this host: ${reason}` : void 0;
-}
-function plannedMode(runner, runnerModes, { readOnly, current }, autonomousDefault = true) {
-  if (!runnerModes) return { ok: true, mode: void 0 };
-  const modes = runnerModes[runner] ?? [];
-  const readOnlyId = readOnlyMode(modes);
-  if (readOnly === true) {
-    if (readOnlyId) return { ok: true, mode: readOnlyId };
-    const able = readOnlyRunners(runnerModes);
-    const reason2 = unavailableModeReason(modes, taggedReadOnlyMode(modes));
-    return {
-      ok: false,
-      error: `Runner "${runner}" has no read-only mode${reason2 ? " available on this host" : ""}: assign a read-only task to ${able.length > 0 ? `one of: ${able.join(", ")}` : "no runner: none of the enabled runners has one"}, or drop "readOnly"${reason2 ? `. ${reason2}` : ""}`
-    };
-  }
-  const keep = current !== void 0 && modes.some((m) => m.id === current) && !(readOnly === false && current === taggedReadOnlyMode(modes));
-  const mode = keep ? current : resolveDefaultMode(modes, autonomousDefault);
-  const reason = unavailableModeReason(modes, mode);
-  if (mode !== void 0 && reason) return { ok: false, error: unavailableModeError(runner, mode, reason) };
-  return { ok: true, mode };
-}
-function carryPlannedModes(before, rewrite, catalog) {
-  const prior = new Map(flattenTasks(before).map((t) => [t.id, t]));
-  const carry = (t) => {
-    const subtasks = (t.subtasks ?? []).map(carry);
-    const was = prior.get(t.id);
-    if (t.type === "user" || !was || was.type === "user" || t.taskMode === taggedReadOnlyMode(catalog.runnerModes[t.assignedRunner])) return { ...t, subtasks };
-    const mode = plannedMode(t.assignedRunner, catalog.runnerModes, { readOnly: false, current: was.taskMode }, catalog.autonomousDefault ?? true);
-    return { ...t, subtasks, ...mode.ok && mode.mode !== void 0 ? { taskMode: mode.mode } : {} };
-  };
-  return rewrite.map(carry);
-}
-function readOnlyRunners(runnerModes) {
-  return Object.entries(runnerModes).filter(([, ms]) => readOnlyMode(ms)).map(([id]) => id);
-}
-
-// src/taskRow/status.ts
-var isTaskRunning = (task) => task.status === "in_progress" || task.status === "running";
-var NOT_STARTED = /* @__PURE__ */ new Set(["pending", "approved", "blocked"]);
-function taskStatusKind(task) {
-  switch (task.status) {
-    case "completed":
-      return "done";
-    case "failed":
-      return "failed";
-    case "skipped":
-      return "skipped";
-    case "blocked":
-      return "blocked";
-    case "awaiting_user":
-      return "awaiting";
-  }
-  if (!isTaskRunning(task)) return "todo";
-  return task.status === "in_progress" && task.idleSince ? "quiet" : "running";
-}
-var AWAITING_LABELS = {
-  input: "Waiting for your input",
-  checkpoint: "Checkpoint",
-  conflict: "Merge conflict",
-  "files-changed": "Changed tracked files",
-  "usage-limit": "Paused on a usage limit"
-};
-function awaitingLabel(task) {
-  return task.status === "awaiting_user" && task.awaitingReason ? AWAITING_LABELS[task.awaitingReason] : null;
-}
-function blockedByLabel(refs) {
-  return `Blocked by ${refs.join(", ")}`;
-}
-function skippedLabel(reason) {
-  return reason ? `Skipped: ${reason}` : "Skipped";
-}
-var WAITS_FOR_APPROVAL_LABEL = "Waits for your approval";
-function approvalLabel(count) {
-  if (!count) return null;
-  return count > 1 ? `Waiting for approval (${count})` : "Waiting for approval";
-}
-function resumeTime(at, now = /* @__PURE__ */ new Date()) {
-  const clock = at.toLocaleTimeString("en-US", { hour: "numeric", minute: at.getMinutes() === 0 ? void 0 : "2-digit", hour12: true }).replace(/[ \u202f]([AP]M)$/i, (_m, meridiem) => meridiem.toLowerCase());
-  if (at.toDateString() === now.toDateString()) return clock;
-  return `${at.toLocaleDateString("en-US", { month: "short", day: "numeric" })}, ${clock}`;
-}
-function resumeLabel(task, now = /* @__PURE__ */ new Date()) {
-  if (task.status !== "awaiting_user" || task.awaitingReason !== "usage-limit" || !task.resumeAt) return null;
-  const at = new Date(task.resumeAt);
-  return Number.isNaN(at.getTime()) ? null : `Resumes at ${resumeTime(at, now)}`;
-}
-
-// src/services/TaskOps.ts
-import { v4 as uuidv42 } from "uuid";
-
-// 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, modelsByRunner, planned = []) {
-  const prior = new Map(flattenTasks(planned).map((t) => [t.id, t]));
-  const unwritten = (task) => {
-    const was = prior.get(task.id);
-    if (!was?.assignedModel || !task.assignedModel || was.assignedRunner !== task.assignedRunner) return void 0;
-    if (was.assignedModel.modelId !== task.assignedModel.modelId || was.assignedModel.thinkingEffort !== task.assignedModel.thinkingEffort) return void 0;
-    return was;
-  };
-  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) } : {}
-    };
-  };
-  const coerceOne = (task) => {
-    if (task.type === "user") return task;
-    const kept = unwritten(task);
-    if (kept) {
-      const left = { ...task, assignedModel: kept.assignedModel };
-      return kept.status === "in_progress" || kept.status === "awaiting_user" ? left : clampVariant(left);
-    }
-    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]) };
-  };
-  const coerced = [];
-  const walk = (list) => list.map((task) => {
-    const after = coerceOne(task);
-    const [fromModel, toModel] = [task.assignedModel?.modelId ?? null, after.assignedModel?.modelId ?? null];
-    if (fromModel !== toModel) coerced.push({ taskId: task.id, title: task.title, field: "assignedModel", from: fromModel, to: toModel });
-    const [fromEffort, toEffort] = [task.assignedModel?.thinkingEffort ?? null, after.assignedModel?.thinkingEffort ?? null];
-    if (fromEffort !== toEffort) coerced.push({ taskId: task.id, title: task.title, field: "thinkingEffort", from: fromEffort, to: toEffort });
-    return { ...after, subtasks: walk(task.subtasks ?? []) };
-  });
-  return { tasks: walk(tasks), coerced };
-}
-
-// src/services/PlannedTask.ts
-import { v4 as uuidv4 } from "uuid";
-var MODE_NOT_THE_PLANNERS = `"taskMode" is the user's to choose: set "readOnly": true on a task that must not change files, and leave it out otherwise`;
-var MANUAL_NOT_READ_ONLY = '"readOnly" is for AI tasks: a manual task runs in no mode';
-var OPS_NOT_READ_ONLY = `"readOnly" is not for an ops task: it runs commands, in the session's mode, and a read-only mode refuses them`;
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function text(value) {
-  return typeof value === "string" || typeof value === "number" ? String(value) : void 0;
-}
-function opsPlacementRefusal(type, isSubtask) {
-  if (type !== "ai") return "is a manual task: only an AI task can be an ops task";
-  if (isSubtask) return "is a subtask, which runs with its parent: only a top-level task can be an ops task";
-  return null;
-}
-function taskWhere(title, parentTitle) {
-  return parentTitle !== void 0 ? `subtask "${title}" of "${parentTitle}"` : `Task "${title}"`;
-}
-var skillsAsked = /* @__PURE__ */ new WeakMap();
-function requestedSkills(task) {
-  return skillsAsked.get(task);
-}
-function modelOf(raw, from) {
-  const effort = text(raw.thinkingEffort);
-  if (isRecord(raw.assignedModel)) {
-    const m = raw.assignedModel;
-    return {
-      modelId: text(m.modelId) ?? "",
-      modelLabel: text(m.modelLabel) ?? "",
-      thinkingEffort: text(m.thinkingEffort) ?? effort
-    };
-  }
-  return from && effort !== void 0 ? { ...from, thinkingEffort: effort } : from;
-}
-function plannedTask(spec, catalog, at = {}) {
-  const raw = isRecord(spec) ? spec : {};
-  const { parent, from, freshIds, newId = uuidv4 } = at;
-  const base = from?.fields ?? {};
-  const errors = [];
-  const ignored = [];
-  const renamed = /* @__PURE__ */ new Map();
-  const title = text(raw.title) ?? "";
-  const where = taskWhere(title, parent?.title);
-  const plannerId = text(raw.id);
-  const id = freshIds || !plannerId ? newId() : plannerId;
-  if (freshIds && plannerId) renamed.set(plannerId, id);
-  const type = raw.type === "user" || raw.type === "ai" ? raw.type : base.type ?? "ai";
-  const ai = type === "ai";
-  const assignedRunner = text(raw.assignedRunner) ?? base.assignedRunner ?? catalog.runners[0] ?? DEFAULT_RUNNERS[0];
-  const description = text(raw.description) ?? base.description ?? title;
-  if (raw.ops === true && !ai) errors.push({ taskId: id, field: "ops", message: `${where} ${opsPlacementRefusal(type, !!parent)}` });
-  if (raw.taskMode !== void 0) ignored.push({ taskId: id, field: "taskMode", message: `${where}: ${MODE_NOT_THE_PLANNERS}` });
-  if (!ai && raw.readOnly === true) ignored.push({ taskId: id, field: "readOnly", message: `${where}: ${MANUAL_NOT_READ_ONLY}` });
-  const ops = raw.ops !== void 0 ? raw.ops === true : base.ops;
-  if (ai && ops && raw.readOnly === true) ignored.push({ taskId: id, field: "readOnly", message: `${where}: ${OPS_NOT_READ_ONLY}` });
-  const asked = typeof raw.readOnly === "boolean" ? raw.readOnly : void 0;
-  const readOnly = ai && !ops && (asked ?? from?.readOnly ?? parent?.readOnly ?? false);
-  let taskMode = base.taskMode;
-  if (ai && catalog.runners.includes(assignedRunner)) {
-    const mode = plannedMode(assignedRunner, catalog.runnerModes, { readOnly, current: base.taskMode }, catalog.autonomousDefault ?? true);
-    if (!mode.ok) errors.push({ taskId: id, field: "readOnly", message: `${where}: ${mode.error}` });
-    else if (mode.mode !== void 0) taskMode = mode.mode;
-  }
-  if (taskMode === void 0 && readOnly && !catalog.runnerModes) taskMode = "plan";
-  const assignedModel = ai ? modelOf(raw, base.assignedModel) : void 0;
-  if (assignedModel && isRecord(raw.assignedModel) && catalog.models && catalog.runners.includes(assignedRunner)) {
-    const validity = checkModelAndModeValidity(assignedRunner, assignedModel, void 0, catalog.models);
-    if (!validity.ok) errors.push({ taskId: id, field: "assignedModel", message: `${where}: ${validity.error}` });
-  }
-  const slice = (value) => value === "AFK" || value === "HITL" ? value : void 0;
-  const autonomy = ai ? slice(raw.autonomy) ?? base.autonomy ?? parent?.autonomy : void 0;
-  const sliceType = slice(raw.sliceType) ?? base.sliceType ?? (ai ? parent?.sliceType : void 0);
-  const subtasks = [];
-  if (Array.isArray(raw.subtasks)) {
-    for (const s of raw.subtasks) {
-      const child = plannedTask(s, catalog, { parent: { title, sliceType, autonomy, readOnly }, freshIds, newId });
-      subtasks.push(child.task);
-      errors.push(...child.errors);
-      ignored.push(...child.ignored);
-      for (const [was, now] of child.renamed) renamed.set(was, now);
-    }
-  }
-  const task = createTask({
-    id,
-    order: Number(raw.order ?? 0),
-    title,
-    description,
-    type,
-    dependencies: Array.isArray(raw.dependencies) ? raw.dependencies.map(String) : base.dependencies ?? [],
-    prompt: text(raw.prompt) || base.prompt || (ai ? description || title || void 0 : void 0),
-    userSteps: Array.isArray(raw.userSteps) ? raw.userSteps.map((s) => isRecord(s) ? s : {}).map((s) => ({ order: Number(s.order ?? 0), instruction: String(s.instruction ?? ""), completed: false })) : base.userSteps,
-    subtasks,
-    assignedModel,
-    assignedRunner,
-    taskMode,
-    autonomy,
-    sliceType,
-    userStoriesCovered: Array.isArray(raw.userStoriesCovered) ? raw.userStoriesCovered.map(String) : base.userStoriesCovered,
-    ops,
-    skills: from ? inheritedSkills(raw.skills, base.skills) : skillNames(raw.skills)
-  });
-  if (Array.isArray(raw.skills)) skillsAsked.set(task, raw.skills);
-  return { task, errors, ignored, renamed };
-}
-function checkPlanInvariants(tasks, runners) {
-  const rows = flattenTasksWithParents(tasks);
-  const errors = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const { task: t, parent } of rows) {
-    const where = taskWhere(t.title, parent?.title);
-    const fail = (field, message) => errors.push({ taskId: t.id, field, message });
-    if (seen.has(t.id)) fail("id", `${where} has id "${t.id}", which another task in the plan has too: every task, subtasks included, needs an id of its own`);
-    seen.add(t.id);
-    if (t.autonomy === "AFK" && t.userSteps && t.userSteps.length > 0) {
-      fail("userSteps", `${where} has autonomy "AFK" but contains userSteps. AFK tasks must not have user touchpoints.`);
-    }
-    if (t.type === "user" && t.sliceType && t.sliceType !== "HITL") {
-      fail("sliceType", `User ${where} has sliceType "${t.sliceType}". User tasks must have sliceType "HITL".`);
-    }
-    const opsRefused = t.ops ? opsPlacementRefusal(t.type, parent !== null) : null;
-    if (opsRefused) fail("ops", `${where} ${opsRefused}`);
-    if (t.type !== "user" && !runners.includes(t.assignedRunner)) {
-      fail("assignedRunner", `${where} has invalid assignedRunner "${t.assignedRunner}". Expected one of: ${runners.join(", ")}`);
-    }
-  }
-  const ids = new Set(rows.map((r) => r.task.id));
-  for (const { task: t, parent } of rows) {
-    for (const dep of t.dependencies) {
-      if (!ids.has(dep)) errors.push({ taskId: t.id, field: "dependencies", message: `${taskWhere(t.title, parent?.title)} depends on "${dep}", which is not a task in the plan` });
-    }
-  }
-  const cycle = findCycle(rows.map((r) => r.task));
-  if (cycle) errors.push({ taskId: cycle[0].id, field: "dependencies", message: `Dependency cycle detected: ${[...cycle, cycle[0]].map((t) => `"${t.title}"`).join(" \u2192 ")}` });
-  return errors;
-}
-function findCycle(tasks) {
-  const byId = new Map(tasks.map((t) => [t.id, t]));
-  const path = [];
-  const done = /* @__PURE__ */ new Set();
-  const visit = (id) => {
-    if (done.has(id)) return null;
-    const at = path.indexOf(id);
-    if (at >= 0) return path.slice(at);
-    path.push(id);
-    for (const dep of byId.get(id)?.dependencies ?? []) {
-      const hit = visit(dep);
-      if (hit) return hit;
-    }
-    path.pop();
-    done.add(id);
-    return null;
-  };
-  for (const t of tasks) {
-    const hit = visit(t.id);
-    if (hit) return hit.map((id) => byId.get(id));
-  }
-  return null;
-}
-function detectCycle(tasks) {
-  return findCycle(tasks)?.[0].title ?? null;
-}
-
-// src/services/TaskEditValidator.ts
-function lockedTaskRefusal(task, action = "changed") {
-  if (task.status === "in_progress") return `"${task.title}" is running and cannot be ${action} now: the user can stop it first, or change it after it finishes`;
-  if (task.status === "completed") return `"${task.title}" is completed and cannot be ${action}: rearm it to run it again, or add a new task for further work`;
-  return null;
-}
-function liveModelRefusal(task) {
-  return `"${task.title}" has a live runner, so its model and effort cannot change now: stop the task first, or use the runner's own /model`;
-}
-function liveRunnerRefusal(task) {
-  return `"${task.title}" has a live runner, so its runner cannot change now: stop the task first`;
-}
-function sameAssignment(a, b) {
-  return a?.modelId === b?.modelId && a?.thinkingEffort === b?.thinkingEffort;
-}
-var AI_ONLY_FIELDS = ["assignedModel", "taskMode", "autonomy", "ops"];
-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}": valid modes: ${modes.map((m) => m.id).join(", ")}` };
-    }
-    const unavailable = unavailableModeReason(modes, taskMode);
-    if (unavailable) return { ok: false, error: `Mode "${taskMode}" of runner "${runner}" is unavailable on this host: ${unavailable}` };
-  }
-  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: include "userSteps" in this edit` };
-    }
-    return {
-      ok: true,
-      clear: AI_ONLY_FIELDS.filter((f) => target[f] !== void 0),
-      // User tasks are held to HITL, so a flip that kept the AI task's slice would be refused by the plan's own rules.
-      ...target.sliceType !== "HITL" ? { set: { sliceType: "HITL" } } : {}
-    };
-  }
-  if (!changes.prompt || !changes.prompt.trim()) {
-    return { ok: false, error: `"${target.title}" cannot become an AI task without a prompt: include "prompt" in this edit` };
-  }
-  return { ok: true, clear: target.userSteps && target.userSteps.length > 0 ? ["userSteps"] : [] };
-}
-function opsCheck(target, isSubtask, changes) {
-  if (!("ops" in changes) || !!changes.ops === !!target.ops) return null;
-  if (!NOT_STARTED.has(target.status)) {
-    return { ok: false, error: `"${target.title}" has started, so whether it is an ops task is fixed` };
-  }
-  if (!changes.ops) return null;
-  const refused = opsPlacementRefusal(changes.type ?? target.type, isSubtask);
-  return refused ? { ok: false, error: `"${target.title}" ${refused}` } : null;
-}
-function validateTaskEdit(actor, tasks, taskId, changes, catalog) {
-  const found = flattenTasksWithParents(tasks).find(({ task }) => task.id === taskId);
-  if (!found) return { ok: false, error: "Task not found" };
-  const { task: target, parent } = found;
-  const locked = actor === "planner" ? lockedTaskRefusal(target, "modified") : null;
-  if (locked) return { ok: false, error: locked };
-  const coherence = typeCoherenceCheck(target, changes);
-  const landing = coherence?.clear?.includes("assignedModel") ? { ...changes, assignedModel: void 0 } : changes;
-  if ("assignedModel" in landing && !sameAssignment(landing.assignedModel, target.assignedModel) && catalog?.liveRunner?.(taskId)) {
-    return { ok: false, error: liveModelRefusal(target) };
-  }
-  if ("assignedRunner" in changes && changes.assignedRunner !== target.assignedRunner && catalog?.liveRunner?.(taskId)) {
-    return { ok: false, error: liveRunnerRefusal(target) };
-  }
-  if (changes.dependencies) {
-    const depCheck = canSetDependencies(parent?.subtasks ?? tasks, taskId, changes.dependencies);
-    if (!depCheck.ok) return depCheck;
-  }
-  if (coherence && !coherence.ok) return coherence;
-  const ops = opsCheck(target, parent !== null, changes);
-  if (ops) return ops;
-  const validity = checkModelAndModeValidity(changes.assignedRunner ?? target.assignedRunner, 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",
-  "type",
-  "userSteps",
-  "autonomy",
-  "sliceType",
-  "ops",
-  "skills"
-];
-function taskOpsProtocol(executionNote = "", tools = false) {
-  const updateChanges = [...UPDATABLE_FIELDS.filter((f) => f !== "taskMode"), "thinkingEffort", "readOnly"].map((f) => f === "dependencies" ? '"dependencies"?:["<id or #order>"]' : `"${f}"?`).join(",");
-  return [
-    tools ? "- To modify specific tasks, call edit_plan, never a JSON reply. Its argument is:" : "- To modify specific tasks, reply with ONLY this JSON object:",
-    tools ? '  {"ops": [' : '  {"taskOps": [',
-    `    {"op":"update","taskId":"<id or #order>","changes":{${updateChanges}}},`,
-    '    {"op":"add","task":{"title","description","prompt","dependencies":["<id or #order>"],"assignedRunner"?,"assignedModel"?,"readOnly"?,"ops"?},"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}}}`,
-    "  ]}",
-    tools ? "- For sweeping changes, you may instead call submit_plan with the full plan." : '- 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. "#N" is top-level task N; a subtask is named by its dotted label ("#2.1"), as the plan lists it.',
-    '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 ${tools ? "list_runners and list_models return" : "listed in <available_models>"}.`,
-    'Set "readOnly": true on a task that must not change any file, never on one that must run commands (tests, scripts, builds) or an ops task, and "readOnly": false to lift it; you never set "taskMode". A task you move, split or edit keeps being read-only or not unless you say otherwise, and so do the subtasks of a read-only task you add.',
-    'Keep dependencies consistent: no cycles, no references to removed tasks, and never touch running or completed tasks \u2014 "rearm" is the one exception, below.',
-    ...tools ? ["edit_plan checks the batch when you call it and answers with what it will change, or with the error to fix \u2014 call it again in the same reply. The edit is applied when your reply ends; edits you make in one reply join one batch."] : [],
-    '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", which also makes the task HITL) or the userSteps (flipping to "ai") are cleared automatically.',
-    `"skills" in "changes" REPLACES the task's whole skill list. To add one, send the names the plan block shows in its skills:[...] plus the new one; to drop one, send the rest; [] removes them all.`,
-    '"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(text2) {
-  return text2.includes(`"${TASK_OPS_ENVELOPE_KEY}"`);
-}
-function parseTaskOpsJson(text2) {
-  const { matches, fallback } = extractObjectsWithKey(text2, 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, text2);
-    } catch (err) {
-      if (!(err instanceof PlanParseError)) throw err;
-      if (!lastError) lastError = err;
-    }
-  }
-  throw lastError ?? new PlanParseError("No JSON object found in task-ops reply", text2);
-}
-function parseTaskOpsObject(json, text2) {
-  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)}`, text2);
-  }
-  const ops = parsed.taskOps;
-  if (!Array.isArray(ops) || ops.length === 0) {
-    throw new PlanParseError('"taskOps" must be a non-empty array', text2);
-  }
-  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)', text2);
-    }
-  }
-  return ops;
-}
-function resolveRef(ref, originalTree, liveTree, 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 by a later op in this batch and cannot be referenced yet` };
-    }
-    const id = handleId.get(s);
-    if (!id) return { error: `handle "${s}" was never resolved` };
-    return { id };
-  }
-  if (findInTasks(liveTree, s)) return { id: s };
-  const task = resolveTaskRef(originalTree, s);
-  return task ? { id: task.id } : { error: `task "${s}" not found` };
-}
-function updatableChanges(raw) {
-  const changes = {};
-  for (const key of UPDATABLE_FIELDS) {
-    if (raw && key in raw) changes[key] = raw[key];
-  }
-  if ("ops" in changes) changes.ops = opsFlag(changes.ops);
-  if ("skills" in changes) changes.skills = skillNames(changes.skills);
-  return changes;
-}
-function findInTasks(tasks, id) {
-  return flattenTasks(tasks).find((t) => t.id === id);
-}
-function findTopLevel(tasks, id) {
-  return tasks.find((t) => t.id === id);
-}
-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 askedReadOnly(spec) {
-  return typeof spec?.readOnly === "boolean" ? spec.readOnly : void 0;
-}
-function isReadOnly(task, catalog) {
-  return task.taskMode !== void 0 && task.taskMode === taggedReadOnlyMode(catalog?.runnerModes[task.assignedRunner]);
-}
-function landingMode(runner, readOnly, current, catalog) {
-  return plannedMode(runner, catalog?.runnerModes, { readOnly, current }, catalog?.autonomousDefault ?? true);
-}
-function changedFields(target, changes, catalog) {
-  const fields = Object.keys(changes).filter((f) => f !== "taskMode");
-  if ("taskMode" in changes && isReadOnly({ ...target, ...changes }, catalog) !== isReadOnly(target, catalog)) fields.push("readOnly");
-  return fields;
-}
-var keptIds = /* @__PURE__ */ new WeakMap();
-function idsOf(op) {
-  if (typeof op !== "object" || op === null) return uuidv42;
-  const ids = keptIds.get(op) ?? [];
-  keptIds.set(op, ids);
-  let next = 0;
-  return () => {
-    if (next === ids.length) ids.push(uuidv42());
-    return ids[next++];
-  };
-}
-function applyTaskOps(currentTasks, newOps, runners, catalog, held = []) {
-  const ops = [...held, ...newOps];
-  const opLabel = (i) => i < held.length ? `earlier op ${i + 1} (${ops[i].op})` : `op ${i - held.length + 1} (${ops[i].op})`;
-  let tasks = JSON.parse(JSON.stringify(currentTasks));
-  const errors = [];
-  const summary = [];
-  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(`${opLabel(i)}: handle must be a non-empty string`);
-      continue;
-    }
-    if (handleOwner.has(handle)) {
-      errors.push(`${opLabel(i)}: handle "${handle}" is already used earlier in this batch`);
-      continue;
-    }
-    if (resolveTaskRef(currentTasks, handle)) {
-      errors.push(`${opLabel(i)}: 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, currentTasks, tasks, 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 };
-  };
-  const intake = { runners, runnerModes: catalog?.runnerModes, autonomousDefault: catalog?.autonomousDefault, models: catalog };
-  const resolveTree = (planned, opIndex) => {
-    const walk = (t, parentTitle) => {
-      const ids = [];
-      const bad = [];
-      for (const d of t.dependencies) {
-        const own = planned.renamed.get(d);
-        if (own) {
-          ids.push(own);
-          continue;
-        }
-        const r = resolveDeps([d], opIndex);
-        ids.push(...r.ids);
-        bad.push(...r.bad);
-      }
-      if (bad.length) return `unknown dependencies${parentTitle !== void 0 ? ` of ${taskWhere(t.title, parentTitle)}` : ""}: ${bad.join(", ")}`;
-      const subtasks = [];
-      for (const sub of t.subtasks) {
-        const done2 = walk(sub, t.title);
-        if (typeof done2 === "string") return done2;
-        subtasks.push(done2);
-      }
-      return { ...t, dependencies: ids.filter((id) => id !== t.id), subtasks };
-    };
-    const done = walk(planned.task);
-    return typeof done === "string" ? { error: done } : { task: done };
-  };
-  const refusalOf = (planned) => [...planned.ignored, ...planned.errors][0]?.message;
-  const prepareEdit = (op, opIndex, label, audience, refuseRunning = false) => {
-    const ref = resolveRef(op.taskId, currentTasks, tasks, handleOwner, handleId, opIndex);
-    if ("error" in ref) return { error: `${label}: ${ref.error}` };
-    const target = findInTasks(tasks, ref.id);
-    if (!target) return { error: `${label}: task "${op.taskId}" no longer exists in this batch (removed, merged, or split by an earlier op)` };
-    if (refuseRunning && target.status === "in_progress") return { error: `${label}: ${lockedTaskRefusal(target, "re-armed")}` };
-    if (op.changes && "taskMode" in op.changes) return { error: `${label}: ${MODE_NOT_THE_PLANNERS}` };
-    const changes = updatableChanges(op.changes);
-    if (op.changes && "thinkingEffort" in op.changes) {
-      const model = changes.assignedModel ?? target.assignedModel;
-      if (!model) return { error: `${label}: "thinkingEffort" is the assigned model's \u2014 set "assignedModel" with it` };
-      changes.assignedModel = { ...model, thinkingEffort: op.changes.thinkingEffort ?? void 0 };
-    }
-    const changesForCheck = { ...changes };
-    delete changesForCheck.dependencies;
-    const check = validateTaskEdit(audience, tasks, target.id, changesForCheck, catalog);
-    if (!check.ok) return { error: `${label}: ${check.error}` };
-    for (const field of check.clear ?? []) changes[field] = void 0;
-    Object.assign(changes, check.set);
-    const readOnly = askedReadOnly(op.changes);
-    if (readOnly === true && (changes.type ?? target.type) === "user") return { error: `${label}: ${MANUAL_NOT_READ_ONLY}` };
-    if ((changes.ops ?? target.ops) && (readOnly ?? isReadOnly(target, catalog))) return { error: `${label}: ${OPS_NOT_READ_ONLY}` };
-    const moved = changes.assignedRunner !== void 0 && changes.assignedRunner !== target.assignedRunner;
-    const becomesAi = changes.type === "ai" && target.type === "user";
-    const known = runners.includes(changes.assignedRunner ?? target.assignedRunner);
-    if (known && (readOnly !== void 0 || moved || becomesAi) && (changes.type ?? target.type) !== "user") {
-      const mode = landingMode(changes.assignedRunner ?? target.assignedRunner, readOnly ?? isReadOnly(target, catalog), target.taskMode, catalog);
-      if (!mode.ok) return { error: `${label}: ${mode.error}` };
-      if (mode.mode !== void 0 && mode.mode !== target.taskMode) changes.taskMode = mode.mode;
-    }
-    if ("dependencies" in changes) {
-      const { ids, bad } = resolveDeps(changes.dependencies, opIndex);
-      if (bad.length) return { error: `${label}: unknown dependencies: ${bad.join(", ")}` };
-      changes.dependencies = ids.filter((id) => id !== target.id);
-    }
-    return { target, changes, check };
-  };
-  const breachKey = (e) => `${e.taskId ?? ""}\0${e.field}`;
-  const standing = new Set(checkPlanInvariants(currentTasks, runners).map(breachKey));
-  const brokenBy = /* @__PURE__ */ new Map();
-  let lastLabel = opLabel(0);
-  for (const [i, op] of ops.entries()) {
-    const label = opLabel(i);
-    const newId = idsOf(op);
-    switch (op.op) {
-      case "update": {
-        const prep = prepareEdit(op, i, label, "planner");
-        if ("error" in prep) {
-          errors.push(prep.error);
-          break;
-        }
-        const { target, changes, check } = prep;
-        if (Object.keys(changes).length === 0) {
-          const readOnly = askedReadOnly(op.changes);
-          if (readOnly !== void 0 && isReadOnly(target, catalog) === readOnly) {
-            summary.push(`"${target.title}" is already ${readOnly ? "" : "not "}read-only`);
-            break;
-          }
-          errors.push(`${label}: no valid changes provided`);
-          break;
-        }
-        tasks = updateTaskInPlan(tasks, target.id, changes);
-        const clearedNote = check.clear?.length ? `; cleared ${check.clear.join(", ")}` : "";
-        const fields = changedFields(target, changes, catalog);
-        summary.push(`Updated "${target.title}"${fields.length ? ` (${fields.join(", ")})` : ""}${clearedNote}`);
-        break;
-      }
-      case "add": {
-        const spec = op.task ?? {};
-        if (!spec.title) {
-          errors.push(`${label}: new task needs a title`);
-          break;
-        }
-        const planned = plannedTask(spec, intake, { freshIds: true, newId });
-        const refused = refusalOf(planned);
-        if (refused) {
-          errors.push(`${label}: ${refused}`);
-          break;
-        }
-        const resolved = resolveTree(planned, i);
-        if ("error" in resolved) {
-          errors.push(`${label}: ${resolved.error}`);
-          break;
-        }
-        tasks = addTaskToPlan(tasks, resolved.task);
-        if (op.handle) handleId.set(op.handle, resolved.task.id);
-        summary.push(`Added "${spec.title}"`);
-        break;
-      }
-      case "remove": {
-        const ref = resolveRef(op.taskId, currentTasks, 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 locked = lockedTaskRefusal(target, "removed");
-        if (locked) {
-          errors.push(`${label}: ${locked}`);
-          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 = [...new Map(resolved.map((t) => [t.id, t])).values()].sort((a, b) => a.order - b.order);
-        if (toMerge.length < 2) {
-          errors.push(`${label}: merge needs at least two tasks`);
-          break;
-        }
-        const locked = toMerge.map((t) => lockedTaskRefusal(t, "merged")).find((refusal) => refusal !== null);
-        if (locked) {
-          errors.push(`${label}: ${locked}`);
-          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 writes = toMerge.find((t) => !isReadOnly(t, catalog));
-        const stories = [...new Set(toMerge.flatMap((t) => t.userStoriesCovered ?? []))];
-        const planned = plannedTask(spec, intake, {
-          freshIds: true,
-          newId,
-          from: {
-            readOnly: !writes,
-            fields: {
-              description: toMerge.map((t) => t.description).filter(Boolean).join("\n\n"),
-              prompt: toMerge.map((t) => t.prompt).filter(Boolean).join("\n\n---\n\n") || void 0,
-              type: toMerge.some((t) => t.type === "user") ? "user" : "ai",
-              assignedRunner: toMerge[0].assignedRunner,
-              assignedModel: toMerge.find((t) => t.assignedModel)?.assignedModel,
-              taskMode: (writes ?? toMerge[0]).taskMode,
-              autonomy: toMerge.find((t) => t.autonomy)?.autonomy,
-              sliceType: toMerge.find((t) => t.sliceType)?.sliceType,
-              ops: inheritedOps(toMerge),
-              skills: toMerge.flatMap((t) => t.skills ?? []),
-              userStoriesCovered: stories.length ? stories : void 0
-            }
-          }
-        });
-        const refused = refusalOf(planned);
-        if (refused) {
-          errors.push(`${label}: ${refused}`);
-          break;
-        }
-        const built = resolveTree({ ...planned, task: { ...planned.task, dependencies: [] } }, i);
-        if ("error" in built) {
-          errors.push(`${label}: ${built.error}`);
-          break;
-        }
-        const mergedTask = { ...built.task, dependencies: ids };
-        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;
-        }
-        const locked = lockedTaskRefusal(target, "split");
-        if (locked) {
-          errors.push(`${label}: ${locked}`);
-          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 planned = plannedTask(spec, intake, {
-            freshIds: true,
-            newId,
-            from: {
-              readOnly: isReadOnly(target, catalog),
-              fields: {
-                type: target.type,
-                assignedRunner: target.assignedRunner,
-                assignedModel: target.assignedModel,
-                taskMode: target.taskMode,
-                autonomy: target.autonomy,
-                sliceType: target.sliceType,
-                ops: inheritedOps([target]),
-                skills: target.skills,
-                userStoriesCovered: target.userStoriesCovered
-              }
-            }
-          });
-          const refused = refusalOf(planned);
-          if (refused) {
-            errors.push(`${label}: split part ${p + 1}: ${refused}`);
-            buildError = true;
-            break;
-          }
-          const resolved = resolveTree({ ...planned, task: { ...planned.task, dependencies: [] } }, i);
-          if ("error" in resolved) {
-            errors.push(`${label}: split part ${p + 1}: ${resolved.error}`);
-            buildError = true;
-            break;
-          }
-          const nt = { ...resolved.task, dependencies: deps };
-          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 prep = prepareEdit(op, i, label, "direct", true);
-        if ("error" in prep) {
-          errors.push(prep.error);
-          break;
-        }
-        const { target, changes, check } = prep;
-        tasks = updateTaskInPlan(tasks, target.id, { ...changes, status: "pending", verdict: void 0, outputSummary: void 0, awaitingReason: void 0, resumeAt: void 0, skipReason: 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 fields = changedFields(target, changes, catalog);
-        const changedNote = fields.length ? ` (${fields.join(", ")})` : "";
-        summary.push(`Re-armed "${target.title}"${changedNote}${clearedNote}`);
-        break;
-      }
-      default:
-        errors.push(`${label}: unknown op "${op.op}"`);
-    }
-    if (errors.length) break;
-    lastLabel = label;
-    const now = new Set(checkPlanInvariants(tasks, runners).map(breachKey));
-    for (const key of brokenBy.keys()) if (!now.has(key)) brokenBy.delete(key);
-    for (const key of now) if (!standing.has(key) && !brokenBy.has(key)) brokenBy.set(key, label);
-  }
-  if (!errors.length) {
-    for (const e of checkPlanInvariants(tasks, runners)) {
-      const key = breachKey(e);
-      if (!standing.has(key)) errors.push(`${brokenBy.get(key) ?? lastLabel}: ${e.message}`);
-    }
-  }
-  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, handles: handleId };
-}
-
-export {
-  PLAN_ENVELOPE_KEY,
-  TASK_OPS_ENVELOPE_KEY,
-  TASK_QUERY_ENVELOPE_KEY,
-  PlanParseError,
-  stripModelNoise,
-  opensWithJsonObject,
-  extractObjectsWithKey,
-  extractJsonObject,
-  stripTrailingCommas,
-  escapeControlCharsInStrings,
-  runnerModesFrom,
-  resolveDefaultMode,
-  autonomyLevelLabel,
-  parseAutonomyLevel,
-  taggedReadOnlyMode,
-  readOnlyMode,
-  unavailableModeReason,
-  unavailableTaskModeMessage,
-  carryPlannedModes,
-  readOnlyRunners,
-  effectiveAllowlist,
-  filterModelsForPrompt,
-  clampThinkingEffort,
-  coerceAssignments,
-  isTaskRunning,
-  NOT_STARTED,
-  taskStatusKind,
-  awaitingLabel,
-  blockedByLabel,
-  skippedLabel,
-  WAITS_FOR_APPROVAL_LABEL,
-  approvalLabel,
-  resumeTime,
-  resumeLabel,
-  taskWhere,
-  requestedSkills,
-  plannedTask,
-  checkPlanInvariants,
-  liveRunnerRefusal,
-  validateTaskEdit,
-  UPDATABLE_FIELDS,
-  taskOpsProtocol,
-  textHasTaskOps,
-  parseTaskOpsJson,
-  canMergeTasks,
-  dependentsOf,
-  dependencyCandidates,
-  canSetDependencies,
-  canSplitTask,
-  applyTaskOps
-};
-//# sourceMappingURL=chunk-4QLFM73A.mjs.map