@ordewell/core 0.10.4 → 0.10.6

package/dist/chunk-H7QX32BH.mjs

@@ -0,0 +1,647 @@
+import {
+  DEFAULT_RUNNERS,
+  createTask,
+  dependencyTargetErrors,
+  findDependencyCycle,
+  flattenTasks,
+  flattenTasksWithParents,
+  inheritedSkills,
+  skillNames
+} from "./chunk-EEE2GBLG.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/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;
+}
+
+// src/services/TaskAssignment.ts
+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 assignableRunners(writer, enabled, planRunners) {
+  if (writer === "plan") return [...enabled];
+  if (writer === "edit") return [.../* @__PURE__ */ new Set([...planRunners, ...enabled])];
+  return void 0;
+}
+function sameAssignment(a, b) {
+  return a?.modelId === b?.modelId && a?.thinkingEffort === b?.thinkingEffort;
+}
+function readOnlyOn(mode, runner, catalog) {
+  return mode !== void 0 && mode === taggedReadOnlyMode(catalog.runnerModes?.[runner]);
+}
+function modeFor(write, task, moved) {
+  const { writer, before, catalog } = write;
+  const prior = before ?? write.from;
+  const runner = task.assignedRunner;
+  const modes = catalog.runnerModes?.[runner];
+  const picked = (writer === "user" || writer === "userAdd") && task.taskMode !== void 0 && task.taskMode !== prior?.taskMode;
+  if (picked) {
+    if (modes && modes.length > 0 && !modes.some((m) => m.id === task.taskMode)) {
+      return { ok: false, error: `Runner "${runner}" has no task mode "${task.taskMode}": valid modes: ${modes.map((m) => m.id).join(", ")}` };
+    }
+    const unavailable = unavailableModeReason(modes, task.taskMode);
+    if (unavailable) return { ok: false, error: `Mode "${task.taskMode}" of runner "${runner}" is unavailable on this host: ${unavailable}` };
+    return { ok: true, mode: task.taskMode };
+  }
+  const becameAi = before?.type === "user";
+  if (writer === "runner" || !catalog.runnerModes || before && !moved && !becameAi && write.readOnly === void 0) return { ok: true, mode: task.taskMode };
+  const carried = prior !== void 0 && task.taskMode === prior.taskMode && readOnlyOn(prior.taskMode, prior.assignedRunner, catalog);
+  const readOnly = write.readOnly ?? (carried || readOnlyOn(task.taskMode, runner, catalog));
+  if (readOnly && !readOnlyMode(modes) && writer !== "plan" && writer !== "edit") {
+    const reason = unavailableModeReason(modes, taggedReadOnlyMode(modes));
+    const able = readOnlyRunners(catalog.runnerModes).filter((r) => r !== runner);
+    return {
+      ok: false,
+      error: `"${task.title}" is read-only, and runner "${runner}" has no read-only mode${reason ? " available on this host" : ""}: give it another mode first${able.length > 0 ? `, or move it to one of: ${able.join(", ")}` : ""}${reason ? `. ${reason}` : ""}`
+    };
+  }
+  const mode = plannedMode(runner, catalog.runnerModes, { readOnly, current: task.taskMode }, catalog.autonomousDefault ?? true);
+  return mode.ok ? { ok: true, mode: mode.mode ?? task.taskMode } : mode;
+}
+function resolveAssignment(write) {
+  const { writer, before, catalog } = write;
+  const written = write.task;
+  const prior = before ?? write.from;
+  const moved = prior !== void 0 && prior.assignedRunner !== written.assignedRunner;
+  const title = (before ?? written).title;
+  const live = writer !== "runner" && !!before && !!catalog.liveRunner?.(before.id);
+  if (live && moved) return { ok: false, field: "assignedRunner", error: liveRunnerRefusal({ title }) };
+  if (live && !sameAssignment(before?.assignedModel, written.assignedModel)) return { ok: false, field: "assignedModel", error: liveModelRefusal({ title }) };
+  if (written.type === "user") return { ok: true, task: written, adjustments: [] };
+  const mode = modeFor(write, written, moved);
+  if (!mode.ok) return { ok: false, field: "taskMode", error: mode.error };
+  const model = live ? { ok: true, assignment: written.assignedModel } : modelFor(write, moved);
+  if (!model.ok) return { ok: false, field: "assignedModel", error: model.error };
+  const task = model.assignment === written.assignedModel && mode.mode === written.taskMode ? written : { ...written, assignedModel: model.assignment, taskMode: mode.mode };
+  const adjustments = [];
+  const note = (field, from, to) => {
+    if ((from ?? null) !== (to ?? null)) adjustments.push({ taskId: written.id, title: written.title, field, from: from ?? null, to: to ?? null });
+  };
+  note("assignedModel", written.assignedModel?.modelId, task.assignedModel?.modelId);
+  note("thinkingEffort", written.assignedModel?.thinkingEffort, task.assignedModel?.thinkingEffort);
+  return { ok: true, task, adjustments };
+}
+function modelFor(write, moved) {
+  const { writer, before, catalog } = write;
+  const prior = before ?? write.from;
+  const written = write.task.assignedModel;
+  const runner = write.task.assignedRunner;
+  const models = catalog.modelsByRunner;
+  const own = models[runner] ?? [];
+  const listing = (id2) => own.find((m) => m.modelId === id2);
+  const carriedFrom = moved && written && prior?.assignedModel?.modelId === written.modelId ? prior.assignedRunner : void 0;
+  const seen = carriedFrom && written && !models[carriedFrom]?.some((m) => m.modelId === written.modelId) ? { ...models, [carriedFrom]: [...models[carriedFrom] ?? [], { modelId: written.modelId, modelLabel: written.modelLabel, variants: [] }] } : models;
+  const allowed = effectiveAllowlist(catalog.perRunnerAllowlist?.[runner], runner, seen);
+  const allows = (id2) => !allowed || allowed.includes(id2);
+  const settled = (assignment) => {
+    const known = listing(assignment.modelId);
+    if (!known) return assignment;
+    const thinkingEffort = clampThinkingEffort(assignment.thinkingEffort, known.variants);
+    const availableVariants = known.variants.map((v) => v.id);
+    if (thinkingEffort === assignment.thinkingEffort && assignment.availableVariants?.join() === availableVariants.join()) return assignment;
+    const next = { ...assignment, availableVariants };
+    if (thinkingEffort === void 0) delete next.thinkingEffort;
+    else next.thinkingEffort = thinkingEffort;
+    return next;
+  };
+  const refill = (effort) => {
+    const id2 = allowed?.find((a) => listing(a)) ?? allowed?.[0] ?? own[0]?.modelId;
+    if (id2 === void 0) return void 0;
+    const known = listing(id2);
+    const thinkingEffort = clampThinkingEffort(effort, known?.variants ?? []);
+    return {
+      modelId: id2,
+      modelLabel: known?.modelLabel ?? id2,
+      ...thinkingEffort !== void 0 ? { thinkingEffort } : {},
+      ...known ? { availableVariants: known.variants.map((v) => v.id) } : {}
+    };
+  };
+  if (!written) return { ok: true, assignment: writer === "runner" ? void 0 : refill(void 0) };
+  if (writer === "runner") return { ok: true, assignment: settled(written) };
+  const id = written.modelId;
+  const same = prior?.assignedModel?.modelId === id;
+  if (before && same && !moved) return { ok: true, assignment: settled(written) };
+  const listedElsewhere = Object.entries(models).some(([other, list]) => other !== runner && list?.some((m) => m.modelId === id));
+  if (same) {
+    const fits = !moved || !!listing(id) || own.length === 0 && !listedElsewhere;
+    return { ok: true, assignment: fits && allows(id) ? settled(written) : refill(written.thinkingEffort) };
+  }
+  if (writer === "edit" || writer === "user") {
+    const offered = own.length === 0 || !!listing(id) || !!allowed?.includes(id);
+    if (!offered) return { ok: false, error: `Runner "${runner}" does not offer model "${id}"` };
+    if (!allows(id)) return { ok: false, error: `Model "${id}" is excluded by the allowlist for runner "${runner}"` };
+    return { ok: true, assignment: settled(written) };
+  }
+  const disowned = !listing(id) && listedElsewhere;
+  return { ok: true, assignment: disowned || !allows(id) ? refill(written.thinkingEffort) : settled(written) };
+}
+function resolveAssignments(tasks, planned, catalog) {
+  const prior = /* @__PURE__ */ new Map();
+  const index = (list) => list.forEach((t) => {
+    prior.set(t.id, t);
+    index(t.subtasks ?? []);
+  });
+  index(planned);
+  const models = { ...catalog, runnerModes: void 0 };
+  const adjustments = [];
+  const walk = (list) => list.map((task) => {
+    const outcome = resolveAssignment({ writer: "plan", task, before: prior.get(task.id), catalog: models });
+    const resolved = outcome.ok ? outcome.task : task;
+    if (outcome.ok) adjustments.push(...outcome.adjustments);
+    return { ...resolved, subtasks: walk(task.subtasks ?? []) };
+  });
+  return { tasks: walk(tasks), adjustments };
+}
+
+// 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 adjustments = [];
+  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);
+  const assignedModel = ai ? modelOf(raw, base.assignedModel) : void 0;
+  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);
+      adjustments.push(...child.adjustments);
+      for (const [was, now] of child.renamed) renamed.set(was, now);
+    }
+  }
+  const fields = {
+    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,
+    autonomy,
+    sliceType,
+    userStoriesCovered: Array.isArray(raw.userStoriesCovered) ? raw.userStoriesCovered.map(String) : base.userStoriesCovered,
+    ops,
+    skills: from ? inheritedSkills(raw.skills, base.skills) : skillNames(raw.skills)
+  };
+  let taskMode = base.taskMode;
+  let landedModel = assignedModel;
+  if (ai && catalog.runners.includes(assignedRunner)) {
+    const resolved = resolveAssignment({
+      writer: catalog.models ? "edit" : "plan",
+      task: { ...createTask(fields), taskMode },
+      from: from ? { assignedRunner: base.assignedRunner ?? assignedRunner, assignedModel: base.assignedModel, taskMode: base.taskMode } : void 0,
+      readOnly,
+      catalog: { modelsByRunner: {}, ...catalog.models, runnerModes: catalog.runnerModes, autonomousDefault: catalog.autonomousDefault }
+    });
+    if (!resolved.ok) {
+      errors.push({ taskId: id, field: resolved.field === "taskMode" ? "readOnly" : resolved.field, message: `${where}: ${resolved.error}` });
+    } else {
+      taskMode = resolved.task.taskMode;
+      landedModel = resolved.task.assignedModel;
+      adjustments.push(...resolved.adjustments);
+    }
+  }
+  if (taskMode === void 0 && readOnly && !catalog.runnerModes) taskMode = "plan";
+  const task = createTask({ ...fields, assignedModel: landedModel, taskMode });
+  if (Array.isArray(raw.skills)) skillsAsked.set(task, raw.skills);
+  return { task, errors, ignored, renamed, adjustments };
+}
+function checkPlanInvariants(tasks, runners, runnerModes) {
+  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.ops && t.taskMode !== void 0 && t.taskMode === taggedReadOnlyMode(runnerModes?.[t.assignedRunner])) {
+      fail("taskMode", `${where} is an ops task, which runs commands, so it cannot run in its runner's read-only mode`);
+    }
+    if (runners && t.type !== "user" && !runners.includes(t.assignedRunner)) {
+      fail("assignedRunner", `${where} has invalid assignedRunner "${t.assignedRunner}". Expected one of: ${runners.join(", ")}`);
+    }
+  }
+  for (const { task: t, parent } of rows) {
+    for (const error of dependencyTargetErrors(tasks, t.id, t.dependencies.filter((id) => id !== t.id))) {
+      errors.push({ taskId: t.id, field: "dependencies", message: `${taskWhere(t.title, parent?.title)}: ${error}` });
+    }
+  }
+  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) {
+  return findDependencyCycle(tasks);
+}
+function detectCycle(tasks) {
+  return findCycle(tasks)?.[0].title ?? null;
+}
+
+export {
+  PLAN_ENVELOPE_KEY,
+  TASK_OPS_ENVELOPE_KEY,
+  TASK_QUERY_ENVELOPE_KEY,
+  PlanParseError,
+  stripModelNoise,
+  opensWithJsonObject,
+  extractObjectsWithKey,
+  extractJsonObject,
+  stripTrailingCommas,
+  escapeControlCharsInStrings,
+  runnerModesFrom,
+  autonomyLevelLabel,
+  parseAutonomyLevel,
+  taggedReadOnlyMode,
+  readOnlyMode,
+  unavailableTaskModeMessage,
+  carryPlannedModes,
+  readOnlyRunners,
+  effectiveAllowlist,
+  filterModelsForPrompt,
+  clampThinkingEffort,
+  liveRunnerRefusal,
+  assignableRunners,
+  resolveAssignment,
+  resolveAssignments,
+  MODE_NOT_THE_PLANNERS,
+  MANUAL_NOT_READ_ONLY,
+  OPS_NOT_READ_ONLY,
+  opsPlacementRefusal,
+  taskWhere,
+  requestedSkills,
+  plannedTask,
+  checkPlanInvariants,
+  detectCycle
+};
+//# sourceMappingURL=chunk-H7QX32BH.mjs.map