@ordewell/core 0.10.5 → 0.10.6

package/dist/parsing.d.mts

@@ -1,5 +1,5 @@
-import { a3 as RunnerId, ah as Task } from './Task-D4QHjdGv.mjs';
-import { R as RunnerModeInfo } from './ModeResolver-B4hhABNf.mjs';
+import { a4 as RunnerId, ai as Task } from './Task-C0o4i3Nn.mjs';
+import { R as RunnerModeInfo } from './ModeResolver-4qNjxcDs.mjs';
 
 declare function parsePlanJson(raw: string, runners: RunnerId[], runnerModes?: Record<RunnerId, RunnerModeInfo[]>, autonomousDefault?: boolean): Task[];
 

package/dist/parsing.d.ts

@@ -1,5 +1,5 @@
-import { a3 as RunnerId, ah as Task } from './Task-D4QHjdGv.js';
-import { R as RunnerModeInfo } from './ModeResolver-CUR5jCSU.js';
+import { a4 as RunnerId, ai as Task } from './Task-C0o4i3Nn.js';
+import { R as RunnerModeInfo } from './ModeResolver-DGK2rWHE.js';
 
 declare function parsePlanJson(raw: string, runners: RunnerId[], runnerModes?: Record<RunnerId, RunnerModeInfo[]>, autonomousDefault?: boolean): Task[];
 

package/dist/parsing.js

@@ -34,9 +34,68 @@ 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/services/PlanTree.ts
+function* walkPlan(tasks) {
+  function* walk(level, ancestors, parentLabel) {
+    for (const task of level) {
+      const label = parentLabel ? `${parentLabel}.${task.order}` : String(task.order);
+      yield { task, parent: ancestors.at(-1), ancestors, siblings: level, label };
+      yield* walk(task.subtasks ?? [], [...ancestors, task], label);
+    }
+  }
+  yield* walk(tasks, []);
+}
+function taskPlacement(tasks, id) {
+  for (const row of walkPlan(tasks)) if (row.task.id === id) return row;
+  return void 0;
+}
+function subtreeIds(tasks, id) {
+  const found = taskPlacement(tasks, id);
+  return new Set(found ? [...walkPlan([found.task])].map(({ task }) => task.id) : []);
+}
+function dependencyTargetErrors(tasks, taskId, dependencies) {
+  const found = taskPlacement(tasks, taskId);
+  if (!found) return ["Task not found"];
+  const descendants = subtreeIds(tasks, taskId);
+  const errors = [];
+  for (const dep of dependencies) {
+    if (dep === taskId) {
+      errors.push(`"${found.task.title}" cannot depend on itself`);
+      continue;
+    }
+    const target = taskPlacement(tasks, dep)?.task;
+    if (!target) {
+      errors.push(`Unknown dependency "${dep}"`);
+      continue;
+    }
+    if (found.ancestors.some((t) => t.id === dep) || descendants.has(dep)) {
+      errors.push(`"${found.task.title}" cannot depend on "${target.title}", its ancestor or descendant`);
+    }
+  }
+  return errors;
+}
+function findDependencyCycle(tasks) {
+  const byId = new Map([...walkPlan(tasks)].map(({ task }) => [task.id, task]));
+  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 id of byId.keys()) {
+    const hit = visit(id);
+    if (hit) return hit.map((key) => byId.get(key));
+  }
+  return null;
 }
 
 // src/models/Task.ts
@@ -85,14 +144,7 @@ function opsFlag(value, type = "ai") {
 }
 var DEFAULT_RUNNERS = ["claude-code"];
 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;
+  return [...walkPlan(tasks)].map(({ task, parent, label }) => ({ task, parent: parent ?? null, label, ref: `#${label}` }));
 }
 
 // src/services/JsonExtractor.ts
@@ -300,32 +352,144 @@ function effectiveAllowlist(allowlist, runner, modelsByRunner) {
   const kept = allowlist.filter((id) => own.has(id) || !elsewhere.has(id));
   return kept.length > 0 ? kept : void 0;
 }
+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/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}"` };
-      }
+// 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 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 };
   }
-  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}` };
+  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) };
   }
-  return { ok: true };
+  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) };
 }
 
 // src/services/PlannedTask.ts
@@ -366,6 +530,7 @@ function plannedTask(spec, catalog, at = {}) {
   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);
@@ -382,18 +547,7 @@ function plannedTask(spec, catalog, at = {}) {
   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);
@@ -404,10 +558,11 @@ function plannedTask(spec, catalog, at = {}) {
       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 task = createTask({
+  const fields = {
     id,
     order: Number(raw.order ?? 0),
     title,
@@ -419,17 +574,36 @@ function plannedTask(spec, catalog, at = {}) {
     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)
-  });
+  };
+  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 };
+  return { task, errors, ignored, renamed, adjustments };
 }
-function checkPlanInvariants(tasks, runners) {
+function checkPlanInvariants(tasks, runners, runnerModes) {
   const rows = flattenTasksWithParents(tasks);
   const errors = [];
   const seen = /* @__PURE__ */ new Set();
@@ -446,14 +620,16 @@ function checkPlanInvariants(tasks, runners) {
     }
     const opsRefused = t.ops ? opsPlacementRefusal(t.type, parent !== null) : null;
     if (opsRefused) fail("ops", `${where} ${opsRefused}`);
-    if (t.type !== "user" && !runners.includes(t.assignedRunner)) {
+    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(", ")}`);
     }
   }
-  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` });
+    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));
@@ -461,27 +637,7 @@ function checkPlanInvariants(tasks, runners) {
   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;
+  return findDependencyCycle(tasks);
 }
 
 // src/services/PlanValidator.ts
@@ -533,7 +689,7 @@ function validatePlanTasks(obj, runners, runnerModes, autonomousDefault = true)
   const errors = [
     ...sliceRequired(tasks),
     ...planned.flatMap((p) => p.errors),
-    ...checkPlanInvariants(tasks, runners)
+    ...checkPlanInvariants(tasks, runners, runnerModes)
   ];
   if (errors.length > 0) return { ok: false, errors };
   const ignored = planned.flatMap((p) => p.ignored);