@ordewell/core 0.9.0 → 0.10.0

package/dist/parsing.d.mts

@@ -1,3 +1,55 @@
-export { a as PartialPlanTask, b as PlanParseError, l as extractJsonObject, q as parsePartialPlan, r as parsePlanJson } from './parsing-GgUJoYKs.mjs';
-import './Task-1Q19y7sZ.mjs';
-import './ModeResolver-DE-o2lRF.mjs';
+import { $ as RunnerId, ac as Task } from './Task-CxwnCJLi.mjs';
+import { R as RunnerModeInfo } from './ModeResolver-m1d8Cb-j.mjs';
+
+declare function parsePlanJson(raw: string, runners: RunnerId[], runnerModes?: Record<RunnerId, RunnerModeInfo[]>, autonomousDefault?: boolean): Task[];
+
+/** Thrown when an LLM plan response cannot be parsed into a valid plan. Carries the raw text so callers can log it or retry. */
+declare class PlanParseError extends Error {
+    readonly raw: string;
+    /**
+     * 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.
+     */
+    readonly truncated: boolean;
+    /**
+     * 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.
+     */
+    readonly semantic: boolean;
+    constructor(message: string, raw: string, opts?: {
+        truncated?: boolean;
+        semantic?: boolean;
+    });
+}
+/**
+ * Pull the JSON object out of an LLM response. Strips markdown code fences and
+ * `<think>` blocks, prefers the object containing a `tasks` key, and tolerates a
+ * prose preamble and trailing prose. Returns the fence-stripped text unchanged
+ * if no `{` is present so the caller's JSON.parse produces a clear failure.
+ */
+declare function extractJsonObject(raw: string): string;
+
+/** A task as seen in a still-streaming plan: its title (possibly partial) and whether its object has closed. */
+interface PartialPlanTask {
+    title: string;
+    status: 'streaming' | 'complete';
+    /** Assigned model label, once it has streamed in — for the live row's chip. */
+    model?: string;
+    /** Set once `"readOnly": true` has streamed in — for the live row's chip. */
+    readOnly?: true;
+}
+/**
+ * Parse a partial (still-streaming) plan-JSON string into an ordered list of task
+ * rows for the live progress view. Pure and lenient: it walks the characters of the
+ * `tasks` array, emitting one row per task object once it has opened, with the title
+ * read incrementally and the status flipping to `complete` when the object's brace
+ * closes. The currently-streaming object stays `streaming` even with a partial title.
+ * The React view is a thin renderer over this — it never parses JSON itself.
+ */
+declare function parsePartialPlan(partial: string): PartialPlanTask[];
+
+export { type PartialPlanTask, PlanParseError, extractJsonObject, parsePartialPlan, parsePlanJson };

package/dist/parsing.d.ts

@@ -1,3 +1,55 @@
-export { a as PartialPlanTask, b as PlanParseError, l as extractJsonObject, q as parsePartialPlan, r as parsePlanJson } from './parsing-CZdp2p_n.js';
-import './Task-1Q19y7sZ.js';
-import './ModeResolver-EWlpmVAy.js';
+import { $ as RunnerId, ac as Task } from './Task-CxwnCJLi.js';
+import { R as RunnerModeInfo } from './ModeResolver-u5ZhRC8x.js';
+
+declare function parsePlanJson(raw: string, runners: RunnerId[], runnerModes?: Record<RunnerId, RunnerModeInfo[]>, autonomousDefault?: boolean): Task[];
+
+/** Thrown when an LLM plan response cannot be parsed into a valid plan. Carries the raw text so callers can log it or retry. */
+declare class PlanParseError extends Error {
+    readonly raw: string;
+    /**
+     * 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.
+     */
+    readonly truncated: boolean;
+    /**
+     * 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.
+     */
+    readonly semantic: boolean;
+    constructor(message: string, raw: string, opts?: {
+        truncated?: boolean;
+        semantic?: boolean;
+    });
+}
+/**
+ * Pull the JSON object out of an LLM response. Strips markdown code fences and
+ * `<think>` blocks, prefers the object containing a `tasks` key, and tolerates a
+ * prose preamble and trailing prose. Returns the fence-stripped text unchanged
+ * if no `{` is present so the caller's JSON.parse produces a clear failure.
+ */
+declare function extractJsonObject(raw: string): string;
+
+/** A task as seen in a still-streaming plan: its title (possibly partial) and whether its object has closed. */
+interface PartialPlanTask {
+    title: string;
+    status: 'streaming' | 'complete';
+    /** Assigned model label, once it has streamed in — for the live row's chip. */
+    model?: string;
+    /** Set once `"readOnly": true` has streamed in — for the live row's chip. */
+    readOnly?: true;
+}
+/**
+ * Parse a partial (still-streaming) plan-JSON string into an ordered list of task
+ * rows for the live progress view. Pure and lenient: it walks the characters of the
+ * `tasks` array, emitting one row per task object once it has opened, with the title
+ * read incrementally and the status flipping to `complete` when the object's brace
+ * closes. The currently-streaming object stays `streaming` even with a partial title.
+ * The React view is a thin renderer over this — it never parses JSON itself.
+ */
+declare function parsePartialPlan(partial: string): PartialPlanTask[];
+
+export { type PartialPlanTask, PlanParseError, extractJsonObject, parsePartialPlan, parsePlanJson };

package/dist/parsing.js

@@ -34,6 +34,11 @@ var import_uuid = require("uuid");
 var SKILL_NAME_PATTERN = "[a-z0-9][a-z0-9_-]*";
 var SKILL_TOKEN = new RegExp(`(^|\\s)\\/(${SKILL_NAME_PATTERN})([,.!?;:]*)(?=\\s|$)`, "gi");
 
+// src/services/TaskRefs.ts
+function taskOrderLabel(task, parent) {
+  return parent ? `${parent.label ?? parent.order}.${task.order}` : String(task.order);
+}
+
 // src/models/Task.ts
 function createTask(overrides = {}) {
   const skills = skillNames(overrides.skills);
@@ -50,15 +55,16 @@ function createTask(overrides = {}) {
     subtasks: overrides.subtasks ?? [],
     verdict: overrides.verdict,
     outputSummary: overrides.outputSummary,
+    ...overrides.attemptUsage ? { attemptUsage: structuredClone(overrides.attemptUsage) } : {},
     assignedModel: overrides.assignedModel,
     assignedRunner: overrides.assignedRunner ?? "claude-code",
-    thinkingEffort: overrides.thinkingEffort,
     taskMode: overrides.taskMode ?? "build",
     autonomy: overrides.autonomy,
     sliceType: overrides.sliceType,
     userStoriesCovered: overrides.userStoriesCovered,
     ...opsFlag(overrides.ops, overrides.type) ? { ops: true } : {},
-    ...skills ? { skills } : {}
+    ...skills ? { skills } : {},
+    ...overrides.addedBy === "supervisor" ? { addedBy: "supervisor" } : {}
   };
 }
 var SKILL_NAME = new RegExp(`^${SKILL_NAME_PATTERN}$`);
@@ -70,9 +76,23 @@ function skillNames(value) {
   const names = [...new Set(value.filter((v) => typeof v === "string").map((v) => v.trim().toLowerCase()).filter(isSkillName))];
   return names.length > 0 ? names : void 0;
 }
+function inheritedSkills(chosen, inherited) {
+  if (Array.isArray(chosen) && chosen.length === 0) return void 0;
+  return skillNames(chosen) ?? skillNames(inherited);
+}
 function opsFlag(value, type = "ai") {
   return value === true && type === "ai" ? true : void 0;
 }
+function flattenTasksWithParents(tasks) {
+  const rows = [];
+  const walk = (t, parent, parentLabel) => {
+    const label = taskOrderLabel(t, parent ? { order: parent.order, label: parentLabel } : void 0);
+    rows.push({ task: t, parent, label, ref: `#${label}` });
+    for (const sub of t.subtasks ?? []) walk(sub, t, label);
+  };
+  for (const t of tasks) walk(t, null);
+  return rows;
+}
 
 // src/services/JsonExtractor.ts
 var PLAN_ENVELOPE_KEY = "tasks";
@@ -103,12 +123,12 @@ var PlanParseError = class extends Error {
 function stripModelNoise(raw) {
   return raw.replace(/<think>[\s\S]*?<\/think>/gi, "").replace(/```json\s*/gi, "").replace(/```\s*/g, "").trim();
 }
-function balancedObjectAt(text, start) {
+function balancedObjectAt(text2, start) {
   let depth = 0;
   let inString = false;
   let escaped = false;
-  for (let i = start; i < text.length; i++) {
-    const ch = text[i];
+  for (let i = start; i < text2.length; i++) {
+    const ch = text2[i];
     if (inString) {
       if (escaped) escaped = false;
       else if (ch === "\\") escaped = true;
@@ -119,10 +139,10 @@ function balancedObjectAt(text, start) {
     else if (ch === "{") depth++;
     else if (ch === "}") {
       depth--;
-      if (depth === 0) return { json: text.slice(start, i + 1), balanced: true };
+      if (depth === 0) return { json: text2.slice(start, i + 1), balanced: true };
     }
   }
-  return { json: text.slice(start), balanced: false };
+  return { json: text2.slice(start), balanced: false };
 }
 function extractObjectsWithKey(raw, key) {
   const stripped = stripModelNoise(raw);
@@ -216,6 +236,9 @@ function escapeControlCharsInStrings(json) {
   return out;
 }
 
+// src/services/PlannedTask.ts
+var import_uuid2 = require("uuid");
+
 // src/services/ModeResolver.ts
 function resolveDefaultMode(modes, autonomousDefault = true) {
   if (!modes || modes.length === 0) return void 0;
@@ -223,32 +246,241 @@ function resolveDefaultMode(modes, autonomousDefault = true) {
   const tagged = modes.find((m) => m[tag]);
   if (tagged) return tagged.id;
   for (let i = modes.length - 1; i >= 0; i--) {
-    if (modes[i].id !== "plan") return modes[i].id;
+    if (!modes[i].readOnly && modes[i].id !== "plan") return modes[i].id;
   }
   return void 0;
 }
-function modeConflictsWithToggle(mode, autonomousDefault) {
-  if (autonomousDefault) return !!mode.safe && !mode.autonomous;
-  return !!mode.autonomous && !mode.safe;
-}
-function resolveTaskMode(emittedMode, runnerId, runnerModes, autonomousDefault = true) {
-  const rawMode = emittedMode || "build";
-  if (!runnerModes) return rawMode === "plan" ? "plan" : "build";
-  const modes = runnerModes[runnerId];
-  if (!modes || modes.length === 0) return rawMode;
-  if (!emittedMode) return resolveDefaultMode(modes, autonomousDefault) ?? "build";
-  const validIds = new Set(modes.map((m) => m.id));
-  if (rawMode === "build" || validIds.has(rawMode)) {
-    if (rawMode === "plan" || rawMode === "build") return rawMode;
-    const modeObj = modes.find((m) => m.id === rawMode);
-    if (modeObj && modeConflictsWithToggle(modeObj, autonomousDefault)) {
-      const fallback2 = resolveDefaultMode(modes, autonomousDefault);
-      return fallback2 ?? "build";
+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 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" : ""} \u2014 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 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;
+}
+
+// src/services/TaskEditValidator.ts
+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}"` };
+      }
     }
-    return rawMode;
   }
-  const fallback = resolveDefaultMode(modes, autonomousDefault);
-  return fallback ?? "build";
+  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(", ")}` };
+    }
+    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 };
+}
+
+// src/services/PlannedTask.ts
+var MODE_NOT_THE_PLANNERS = `"taskMode" is the user's to choose \u2014 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 \u2014 a manual task runs in no mode';
+var OPS_NOT_READ_ONLY = `"readOnly" is not for an ops task \u2014 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 \u2014 only an AI task can be an ops task";
+  if (isSubtask) return "is a subtask, which runs with its parent \u2014 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 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 } = 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 ? (0, import_uuid2.v4)() : 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] ?? "claude-code";
+  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 });
+      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;
 }
 
 // src/services/PlanValidator.ts
@@ -288,117 +520,53 @@ function parsePlanObject(json, raw, runners, runnerModes, autonomousDefault = tr
   throw new PlanParseError(first.message, raw, { semantic: first.taskId !== void 0 });
 }
 function validatePlanTasks(obj, runners, runnerModes, autonomousDefault = true) {
-  const rawTasks = isRecord(obj) ? obj.tasks : void 0;
+  const rawTasks = isRecord2(obj) ? obj.tasks : void 0;
   if (!Array.isArray(rawTasks)) {
     return { ok: false, errors: [{ field: "tasks", message: "Invalid plan: missing tasks array" }] };
   }
   if (rawTasks.length === 0) {
     return { ok: false, errors: [{ field: "tasks", message: "Plan contained no tasks" }] };
   }
-  const tasks = rawTasks.map((t) => parseTask(asRecord(t), runners, runnerModes, autonomousDefault));
-  const errors = verticalSliceErrors(tasks);
-  for (const t of tasks) {
-    if (!runners.includes(t.assignedRunner)) {
-      errors.push({
-        taskId: t.id,
-        field: "assignedRunner",
-        message: `Task "${t.title}" has invalid assignedRunner "${t.assignedRunner}". Expected one of: ${runners.join(", ")}`
-      });
-    }
-  }
-  return errors.length > 0 ? { ok: false, errors } : { ok: true, tasks };
+  const planned = rawTasks.map((t) => plannedTask(t, { runners, runnerModes, autonomousDefault }));
+  const tasks = planned.map((p) => p.task);
+  const errors = [
+    ...sliceRequired(tasks),
+    ...planned.flatMap((p) => p.errors),
+    ...checkPlanInvariants(tasks, runners)
+  ];
+  if (errors.length > 0) return { ok: false, errors };
+  const ignored = planned.flatMap((p) => p.ignored);
+  const warnings = [
+    ...ignored.some((i) => i.field === "taskMode") ? [`"taskMode" is not yours to set and was ignored: each task runs in its runner's mode for the user's autonomy level, or its read-only mode when you set "readOnly": true.`] : [],
+    ...ignored.filter((i) => i.field === "readOnly").map((i) => `${i.message} \u2014 it was ignored.`)
+  ];
+  return warnings.length > 0 ? { ok: true, tasks, warnings } : { ok: true, tasks };
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function asRecord(value) {
-  return isRecord(value) ? value : {};
-}
-var skillsAsked = /* @__PURE__ */ new WeakMap();
-function parseTask(raw, runners, runnerModes, autonomousDefault = true, inherited) {
-  const assignedRunner = typeof raw.assignedRunner === "string" ? raw.assignedRunner : runners[0] ?? "claude-code";
-  const taskType = raw.type === "user" ? "user" : "ai";
-  const title = String(raw.title ?? "");
-  const description = String(raw.description ?? "");
-  const autonomy = taskType === "ai" && typeof raw.autonomy === "string" && (raw.autonomy === "AFK" || raw.autonomy === "HITL") ? raw.autonomy : taskType === "ai" ? inherited?.autonomy : void 0;
-  const sliceType = typeof raw.sliceType === "string" && (raw.sliceType === "HITL" || raw.sliceType === "AFK") ? raw.sliceType : taskType === "ai" ? inherited?.sliceType : void 0;
-  const task = createTask({
-    id: String(raw.id ?? ""),
-    order: Number(raw.order ?? 0),
-    title,
-    description,
-    type: taskType,
-    dependencies: Array.isArray(raw.dependencies) ? raw.dependencies.map(String) : [],
-    // The planner sometimes omits `prompt` on an AI task while still filling in
-    // description/title — same fallback TaskOps.applyTaskOps uses for `add`, so
-    // a task never silently ends up unschedulable (getReadyTasks requires prompt).
-    prompt: raw.prompt ? String(raw.prompt) : description || title || void 0,
-    userSteps: Array.isArray(raw.userSteps) ? raw.userSteps.map(asRecord).map((s) => ({
-      order: Number(s.order ?? 0),
-      instruction: String(s.instruction ?? ""),
-      completed: false
-    })) : void 0,
-    subtasks: Array.isArray(raw.subtasks) ? raw.subtasks.map((s) => parseTask(asRecord(s), runners, runnerModes, autonomousDefault, { sliceType, autonomy })) : [],
-    assignedModel: raw.assignedModel ? {
-      modelId: String(raw.assignedModel.modelId ?? ""),
-      modelLabel: String(raw.assignedModel.modelLabel ?? ""),
-      thinkingEffort: raw.assignedModel.thinkingEffort
-    } : void 0,
-    assignedRunner,
-    thinkingEffort: raw.thinkingEffort ? String(raw.thinkingEffort) : void 0,
-    taskMode: resolveTaskMode(
-      raw.taskMode !== void 0 ? String(raw.taskMode) : void 0,
-      assignedRunner,
-      runnerModes,
-      autonomousDefault
-    ),
-    autonomy,
-    sliceType,
-    userStoriesCovered: Array.isArray(raw.userStoriesCovered) ? raw.userStoriesCovered.map(String) : void 0,
-    // A subtask runs with its parent, so only a top-level task carries it (ADR-0020).
-    ops: inherited ? void 0 : opsFlag(raw.ops),
-    // Not inherited: a subtask's skills are its own.
-    skills: skillNames(raw.skills)
+function sliceRequired(tasks) {
+  return flattenTasksWithParents(tasks).flatMap(({ task: t, parent }) => {
+    const where = taskWhere(t.title, parent?.title);
+    const errors = [];
+    if (!t.sliceType) errors.push({ taskId: t.id, field: "sliceType", message: `${where} is missing sliceType. Every task must specify sliceType ("AFK" or "HITL").` });
+    if (t.type === "ai" && !t.autonomy) errors.push({ taskId: t.id, field: "autonomy", message: `AI ${where} is missing autonomy. Every AI task must specify autonomy ("AFK" or "HITL").` });
+    return errors;
   });
-  if (Array.isArray(raw.skills)) skillsAsked.set(task, raw.skills);
-  return task;
-}
-function verticalSliceErrors(tasks, parentTitle) {
-  const where = (t) => parentTitle ? `subtask "${t.title}" of "${parentTitle}"` : `Task "${t.title}"`;
-  const errors = [];
-  for (const t of tasks) {
-    const fail = (field, message) => errors.push({ taskId: t.id, field, message });
-    if (!t.sliceType) {
-      fail("sliceType", `${where(t)} is missing sliceType. Every task must specify sliceType ("AFK" or "HITL").`);
-    }
-    if (t.type === "ai" && !t.autonomy) {
-      fail("autonomy", `AI ${where(t)} is missing autonomy. Every AI task must specify autonomy ("AFK" or "HITL").`);
-    }
-    if (t.autonomy === "AFK" && t.userSteps && t.userSteps.length > 0) {
-      fail("userSteps", `${where(t)} 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(t)} has sliceType "${t.sliceType}". User tasks must have sliceType "HITL".`);
-    }
-    if (t.subtasks.length > 0) {
-      errors.push(...verticalSliceErrors(t.subtasks, t.title));
-    }
-  }
-  return errors;
 }
 
 // src/services/PartialPlanParser.ts
 function parsePartialPlan(partial) {
-  const text = stripModelNoise(partial);
-  const arrayStart = findTasksArrayStart(text);
+  const text2 = stripModelNoise(partial);
+  const arrayStart = findTasksArrayStart(text2);
   if (arrayStart === -1) return [];
   const tasks = [];
   let depth = 0;
   let objText = "";
   let inString = false;
   let escaped = false;
-  for (let i = arrayStart; i < text.length; i++) {
-    const ch = text[i];
+  for (let i = arrayStart; i < text2.length; i++) {
+    const ch = text2[i];
     if (depth > 0) objText += ch;
     if (inString) {
       if (escaped) escaped = false;
@@ -425,20 +593,39 @@ function parsePartialPlan(partial) {
   if (depth > 0) tasks.push(rowFromObject(objText, "streaming"));
   return tasks;
 }
-function findTasksArrayStart(text) {
-  const key = /"tasks"\s*:\s*\[/.exec(text);
+function findTasksArrayStart(text2) {
+  const key = /"tasks"\s*:\s*\[/.exec(text2);
   return key ? key.index + key[0].length : -1;
 }
-function rowFromObject(objText, status) {
+function rowFromObject(fullText, status) {
+  const objText = withoutSubtasks(fullText);
   const model = stringField(objText, "modelLabel");
-  const mode = stringField(objText, "taskMode");
+  const readOnly = /"readOnly"\s*:\s*true/.test(objText);
   return {
     title: titleFromObject(objText),
     status,
     ...model ? { model } : {},
-    ...mode ? { mode } : {}
+    ...readOnly ? { readOnly: true } : {}
   };
 }
+function withoutSubtasks(objText) {
+  const key = /"subtasks"\s*:\s*\[/.exec(objText);
+  if (!key) return objText;
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = key.index + key[0].length - 1; i < objText.length; i++) {
+    const ch = objText[i];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+    } else if (ch === '"') inString = true;
+    else if (ch === "[") depth++;
+    else if (ch === "]" && --depth === 0) return objText.slice(0, key.index) + withoutSubtasks(objText.slice(i + 1));
+  }
+  return objText.slice(0, key.index);
+}
 function titleFromObject(objText) {
   const m = /"title"\s*:\s*"((?:[^"\\]|\\.)*)/.exec(objText);
   if (!m) return "";