@ordewell/core 0.10.11 → 0.11.0

package/dist/parsing.d.mts

@@ -1,5 +1,5 @@
-import { a7 as RunnerId, am as Task } from './Task-CfBM0wkV.mjs';
-import { R as RunnerModeInfo } from './ModeResolver-6TQXVsde.mjs';
+import { az as RunnerId, aS as Task } from './Task-BL4Idm9r.mjs';
+import { R as RunnerModeInfo } from './ModeResolver-BDAgouuE.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 { a7 as RunnerId, am as Task } from './Task-CfBM0wkV.js';
-import { R as RunnerModeInfo } from './ModeResolver-CoJAJD-f.js';
+import { az as RunnerId, aS as Task } from './Task-BL4Idm9r.js';
+import { R as RunnerModeInfo } from './ModeResolver-DyXeZ9ib.js';
 
 declare function parsePlanJson(raw: string, runners: RunnerId[], runnerModes?: Record<RunnerId, RunnerModeInfo[]>, autonomousDefault?: boolean): Task[];
 

package/dist/parsing.js

@@ -101,12 +101,13 @@ function findDependencyCycle(tasks) {
 // src/models/Task.ts
 function createTask(overrides = {}) {
   const skills = skillNames(overrides.skills);
+  const type = overrides.type ?? "ai";
   return {
     id: overrides.id ?? (0, import_uuid.v4)(),
     order: overrides.order ?? 0,
     title: overrides.title ?? "",
     description: overrides.description ?? "",
-    type: overrides.type ?? "ai",
+    type,
     status: overrides.status ?? "pending",
     dependencies: overrides.dependencies ?? [],
     prompt: overrides.prompt,
@@ -114,16 +115,25 @@ function createTask(overrides = {}) {
     subtasks: overrides.subtasks ?? [],
     verdict: overrides.verdict,
     outputSummary: overrides.outputSummary,
+    ...overrides.handoff ? { handoff: structuredClone(overrides.handoff) } : {},
+    ...overrides.attempted ? { attempted: true } : {},
     ...overrides.attemptUsage ? { attemptUsage: structuredClone(overrides.attemptUsage) } : {},
     assignedModel: overrides.assignedModel,
     assignedRunner: overrides.assignedRunner ?? DEFAULT_RUNNERS[0],
-    taskMode: overrides.taskMode ?? "build",
+    // A script task runs in no mode (ADR-0035): one given it would read as a mode it runs in.
+    taskMode: overrides.taskMode ?? (type === "script" ? void 0 : "build"),
     autonomy: overrides.autonomy,
     sliceType: overrides.sliceType,
     userStoriesCovered: overrides.userStoriesCovered,
     ...opsFlag(overrides.ops, overrides.type) ? { ops: true } : {},
     ...skills ? { skills } : {},
-    ...overrides.addedBy === "supervisor" ? { addedBy: "supervisor" } : {}
+    ...overrides.addedBy === "supervisor" ? { addedBy: "supervisor" } : {},
+    ...overrides.commands !== void 0 ? { commands: overrides.commands.map((argv) => [...argv]) } : {},
+    ...overrides.script !== void 0 ? { script: overrides.script } : {},
+    ...overrides.timeoutMs !== void 0 ? { timeoutMs: overrides.timeoutMs } : {},
+    ...overrides.loop ? { loop: { body: [...overrides.loop.body], maxRounds: overrides.loop.maxRounds } } : {},
+    ...overrides.loopRound !== void 0 ? { loopRound: overrides.loopRound } : {},
+    ...overrides.research !== void 0 ? { research: overrides.research } : {}
   };
 }
 var SKILL_NAME = new RegExp(`^${SKILL_NAME_PATTERN}$`);
@@ -293,7 +303,7 @@ function escapeControlCharsInStrings(json) {
 var import_uuid2 = require("uuid");
 
 // src/services/ModeResolver.ts
-function resolveDefaultMode(modes, autonomousDefault = true) {
+function resolveDefaultMode(modes, autonomousDefault = false) {
   if (!modes || modes.length === 0) return void 0;
   const tag = autonomousDefault ? "autonomous" : "safe";
   const tagged = modes.find((m) => m[tag]);
@@ -316,7 +326,7 @@ function unavailableModeReason(modes, id) {
 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) {
+function plannedMode(runner, runnerModes, { readOnly, current }, autonomousDefault = false) {
   if (!runnerModes) return { ok: true, mode: void 0 };
   const modes = runnerModes[runner] ?? [];
   const readOnlyId = readOnlyMode(modes);
@@ -399,7 +409,7 @@ function modeFor(write, task, moved) {
     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";
+  const becameAi = before !== void 0 && before.type !== "ai";
   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));
@@ -411,7 +421,7 @@ function modeFor(write, task, moved) {
       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);
+  const mode = plannedMode(runner, catalog.runnerModes, { readOnly, current: task.taskMode }, catalog.autonomousDefault ?? false);
   return mode.ok ? { ok: true, mode: mode.mode ?? task.taskMode } : mode;
 }
 function resolveAssignment(write) {
@@ -423,7 +433,7 @@ function resolveAssignment(write) {
   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: [] };
+  if (written.type !== "ai") 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);
@@ -492,17 +502,162 @@ function modelFor(write, moved) {
   return { ok: true, assignment: disowned || !allows(id) ? refill(written.thinkingEffort) : settled(written) };
 }
 
+// src/models/ScriptTask.ts
+var DEFAULT_SCRIPT_TIMEOUT_MS = 10 * 6e4;
+var MAX_SCRIPT_TIMEOUT_MS = 24 * 60 * 6e4;
+var SCRIPT_BODY_FIELDS = ["commands", "script", "timeoutMs"];
+var NOT_A_SCRIPTS_FIELDS = ["assignedModel", "taskMode", "prompt", "skills", "userSteps", "ops"];
+function scriptBodyErrors(task) {
+  if (task.type !== "script") {
+    return SCRIPT_BODY_FIELDS.filter((f) => task[f] !== void 0).map((field) => ({ field, message: `has "${field}", which only a script task has: set "type": "script", or leave it out` }));
+  }
+  const errors = [];
+  const { commands, script, timeoutMs } = task;
+  if (commands !== void 0 && script !== void 0) {
+    errors.push({ field: "commands", message: 'has both "commands" and "script": a script task runs exactly one of them' });
+  } else if (commands === void 0 && script === void 0) {
+    errors.push({ field: "commands", message: 'is a script task with neither "commands" nor "script": give it the argument vectors to run, or the script' });
+  }
+  if (commands !== void 0) errors.push(...commandsErrors(commands));
+  if (script !== void 0 && (typeof script !== "string" || !script.trim())) {
+    errors.push({ field: "script", message: 'has an empty "script": write the script it runs' });
+  }
+  if (timeoutMs !== void 0 && !(typeof timeoutMs === "number" && Number.isInteger(timeoutMs) && timeoutMs > 0 && timeoutMs <= MAX_SCRIPT_TIMEOUT_MS)) {
+    errors.push({ field: "timeoutMs", message: `has "timeoutMs" ${JSON.stringify(timeoutMs)}: the time limit is a whole number of milliseconds from 1 to ${MAX_SCRIPT_TIMEOUT_MS}, or left out for ten minutes` });
+  }
+  return errors;
+}
+function commandsErrors(commands) {
+  const shape = 'a list of argument vectors, each a list of strings, like [["git", "push", "origin", "main"]]';
+  if (!Array.isArray(commands) || commands.length === 0) return [{ field: "commands", message: `has "commands" that is not ${shape}` }];
+  for (const [i, argv] of commands.entries()) {
+    const n = i + 1;
+    if (!Array.isArray(argv) || !argv.every((word) => typeof word === "string")) {
+      return [{ field: "commands", message: `has command ${n} that is not an argument vector: "commands" is ${shape}` }];
+    }
+    if (argv.length === 0) return [{ field: "commands", message: `has command ${n} as an empty argument vector: name the program it runs` }];
+    if (!argv[0].trim()) return [{ field: "commands", message: `has command ${n} naming no program: its first word is the program it runs` }];
+  }
+  return [];
+}
+function notAScriptsFields(task) {
+  return NOT_A_SCRIPTS_FIELDS.filter((f) => {
+    const value = task[f];
+    return value !== void 0 && value !== false && !(Array.isArray(value) && value.length === 0);
+  });
+}
+
+// src/models/Loop.ts
+var DEFAULT_LOOP_ROUNDS = 3;
+var MAX_LOOP_ROUNDS = 10;
+var SHAPE = 'is not {"body": ["<task id>", ...], "maxRounds"?: <rounds>}';
+function roundsMessage(value) {
+  return `has "maxRounds" ${JSON.stringify(value)}: a loop runs its check from 1 to ${MAX_LOOP_ROUNDS} times, or ${DEFAULT_LOOP_ROUNDS} when it is left out`;
+}
+function isRoundCount(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= MAX_LOOP_ROUNDS;
+}
+function loopSpec(value) {
+  if (value === void 0 || value === null) return { loop: void 0 };
+  if (typeof value !== "object" || Array.isArray(value)) return { error: `has a "loop" that ${SHAPE}` };
+  const { body, maxRounds } = value;
+  if (!Array.isArray(body) || !body.every((id) => typeof id === "string" || typeof id === "number")) return { error: `has a "loop" whose "body" ${SHAPE}` };
+  if (body.length === 0) return { error: 'has a "loop" with an empty "body": name the tasks that fix what it finds' };
+  if (maxRounds !== void 0 && !isRoundCount(maxRounds)) return { error: roundsMessage(maxRounds) };
+  return { loop: { body: body.map(String), maxRounds: maxRounds ?? DEFAULT_LOOP_ROUNDS } };
+}
+function loopErrors(tasks) {
+  const rows = flattenTasksWithParents(tasks);
+  const byId = new Map(rows.map((row) => [row.task.id, row]));
+  const errors = [];
+  const bodyOwner = /* @__PURE__ */ new Map();
+  for (const { task: check, parent } of rows) {
+    const loop = check.loop;
+    if (!loop) continue;
+    const where = parent ? `subtask "${check.title}" of "${parent.title}"` : `Task "${check.title}"`;
+    const fail = (message) => errors.push({ taskId: check.id, field: "loop", message: `${where} ${message}` });
+    if (parent) fail(`has a "loop", but only a top-level task can be a loop's check`);
+    if (check.type === "user") fail("is a manual task, so it cannot be a loop's check: a check is an AI task, which reports through task_complete, or a script task, whose exit status decides");
+    if (check.subtasks?.length) fail("is a loop's check, which has no subtasks: each round runs it again whole");
+    if (!isRoundCount(loop.maxRounds)) fail(roundsMessage(loop.maxRounds));
+    if (!Array.isArray(loop.body) || loop.body.length === 0) fail('has a "loop" with an empty "body": name the tasks that fix what it finds');
+    const named = /* @__PURE__ */ new Set();
+    for (const id of loop.body ?? []) {
+      const row = byId.get(id);
+      if (named.has(id)) {
+        fail(`names "${row?.task.title ?? id}" twice in its loop's "body"`);
+        continue;
+      }
+      named.add(id);
+      if (!row) {
+        fail(`names "${id}" in its loop's "body", which is no task in the plan`);
+        continue;
+      }
+      const body = row.task;
+      if (body.id === check.id) {
+        fail(`names itself in its loop's "body": the body is the tasks that fix what it finds`);
+        continue;
+      }
+      if (row.parent) {
+        fail(`names subtask "${body.title}" of "${row.parent.title}" in its loop's "body": only a top-level task can be in a loop's body`);
+        continue;
+      }
+      const other = bodyOwner.get(id);
+      if (other) {
+        fail(`names "${body.title}" in its loop's "body", which is in the body of "${other.title}"'s loop too: a task belongs to one loop only`);
+        continue;
+      }
+      bodyOwner.set(id, check);
+      if (body.loop) fail(`names "${body.title}" in its loop's "body", which has a loop of its own: a loop has no loop inside its body`);
+      if (body.type === "user") fail(`names manual task "${body.title}" in its loop's "body": a body is AI or script tasks, which Ordewell runs again each round`);
+      if (body.subtasks?.length) fail(`names "${body.title}" in its loop's "body", which has subtasks: each round runs a body task again whole, so make each step a task of the body`);
+    }
+  }
+  for (const [bodyId, check] of bodyOwner) {
+    const body = byId.get(bodyId).task;
+    const where = `Task "${body.title}" is in the body of "${check.title}"'s loop`;
+    if (!body.dependencies.includes(check.id)) {
+      errors.push({ taskId: body.id, field: "dependencies", message: `${where}, so it depends on "${check.title}": the check's report is what it fixes. Add "${check.title}" to its dependencies` });
+    }
+    for (const dep of body.dependencies) {
+      if (dep === check.id || check.dependencies.includes(dep) || bodyOwner.get(dep) === check) continue;
+      errors.push({ taskId: body.id, field: "dependencies", message: `${where}, so it depends only on "${check.title}", on what "${check.title}" depends on, or on other tasks of that body; "${byId.get(dep)?.task.title ?? dep}" is none of these` });
+    }
+  }
+  for (const { task } of rows) {
+    for (const dep of task.dependencies) {
+      const check = bodyOwner.get(dep);
+      if (!check || bodyOwner.get(task.id) === check) continue;
+      const body = byId.get(dep).task;
+      const message = task.id === check.id ? `Task "${task.title}" depends on "${body.title}" from its own loop's body: the body runs after the check, so the check cannot wait for it` : `Task "${task.title}" depends on "${body.title}", which is in the body of "${check.title}"'s loop and runs only if "${check.title}" fails: depend on "${check.title}" instead`;
+      errors.push({ taskId: task.id, field: "dependencies", message });
+    }
+  }
+  return errors;
+}
+
 // src/services/PlannedTask.ts
 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`;
+var OPS_NOT_READ_ONLY = '"readOnly" is not for an ops task: it acts in the workspace, while a read-only task lands nothing';
 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;
 }
+var NOT_ON_A_SCRIPT = ["assignedRunner", "assignedModel", "thinkingEffort", "taskMode", "readOnly", "prompt", "skills", "userSteps", "ops", "subtasks"];
+function notOnAScript(raw) {
+  return NOT_ON_A_SCRIPT.filter((f) => {
+    const value = raw[f];
+    return value !== void 0 && value !== null && value !== false && !(Array.isArray(value) && value.length === 0);
+  });
+}
+function notOnAScriptMessage(fields) {
+  return `is a script task, which runs its "commands" or "script" with no model: leave out ${fields.map((f) => `"${f}"`).join(", ")}`;
+}
 function opsPlacementRefusal(type, isSubtask) {
+  if (type === "script") return 'is a script task, which is an ops task by nature: leave "ops" out';
   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;
@@ -523,6 +678,25 @@ function modelOf(raw, from) {
   }
   return from && effort !== void 0 ? { ...from, thinkingEffort: effort } : from;
 }
+function bodyFields(raw, base) {
+  const pick = (field) => raw[field] !== void 0 && raw[field] !== null ? raw[field] : base[field];
+  const judged = { commands: pick("commands"), script: pick("script"), timeoutMs: pick("timeoutMs") };
+  const malformed = /* @__PURE__ */ new Set();
+  const commands = isCommands(judged.commands) ? judged.commands : void 0;
+  if (judged.commands !== void 0 && !commands) malformed.add("commands");
+  const script = typeof judged.script === "string" ? judged.script : void 0;
+  if (judged.script !== void 0 && script === void 0) malformed.add("script");
+  const timeoutMs = typeof judged.timeoutMs === "number" ? judged.timeoutMs : void 0;
+  if (judged.timeoutMs !== void 0 && timeoutMs === void 0) malformed.add("timeoutMs");
+  return {
+    fields: { ...commands ? { commands } : {}, ...script !== void 0 ? { script } : {}, ...timeoutMs !== void 0 ? { timeoutMs } : {} },
+    raw: judged,
+    malformed
+  };
+}
+function isCommands(value) {
+  return Array.isArray(value) && value.every((argv) => Array.isArray(argv) && argv.every((word) => typeof word === "string"));
+}
 function plannedTask(spec, catalog, at = {}) {
   const raw = isRecord(spec) ? spec : {};
   const { parent, from, freshIds, newId = import_uuid2.v4 } = at;
@@ -536,17 +710,26 @@ function plannedTask(spec, catalog, at = {}) {
   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 type = raw.type === "user" || raw.type === "ai" || raw.type === "script" ? raw.type : base.type ?? "ai";
   const ai = type === "ai";
+  const script = type === "script";
   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 notScripts = script ? notOnAScript(raw) : [];
+  if (notScripts.length > 0) errors.push({ taskId: id, field: notScripts[0], message: `${where} ${notOnAScriptMessage(notScripts)}` });
+  const body = bodyFields(raw, base);
+  const shapeErrors = scriptBodyErrors({ type, ...body.raw }).filter((e) => body.malformed.has(e.field));
+  for (const e of shapeErrors) errors.push({ taskId: id, field: e.field, message: `${where} ${e.message}` });
+  const loop = loopSpec(raw.loop);
+  if ("error" in loop) errors.push({ taskId: id, field: "loop", message: `${where} ${loop.error}` });
+  if (raw.ops === true && !ai && !script) errors.push({ taskId: id, field: "ops", message: `${where} ${opsPlacementRefusal(type, !!parent)}` });
+  if (raw.taskMode !== void 0 && !script) ignored.push({ taskId: id, field: "taskMode", message: `${where}: ${MODE_NOT_THE_PLANNERS}` });
+  if (type === "user" && 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);
+  if (raw.research !== void 0 && typeof raw.research !== "boolean") errors.push({ taskId: id, field: "research", message: `${where}: "research" must be a boolean` });
   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;
@@ -569,7 +752,8 @@ function plannedTask(spec, catalog, at = {}) {
     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),
+    // What a merge or split carries over for a runner is nothing a script runs.
+    prompt: script ? void 0 : 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,
@@ -577,10 +761,13 @@ function plannedTask(spec, catalog, at = {}) {
     autonomy,
     sliceType,
     userStoriesCovered: Array.isArray(raw.userStoriesCovered) ? raw.userStoriesCovered.map(String) : base.userStoriesCovered,
-    ops,
-    skills: from ? inheritedSkills(raw.skills, base.skills) : skillNames(raw.skills)
+    ops: script ? void 0 : ops,
+    research: typeof raw.research === "boolean" ? raw.research : base.research,
+    skills: script ? void 0 : from ? inheritedSkills(raw.skills, base.skills) : skillNames(raw.skills),
+    ...body.fields,
+    ..."loop" in loop && loop.loop ? { loop: loop.loop } : {}
   };
-  let taskMode = base.taskMode;
+  let taskMode = script ? void 0 : base.taskMode;
   let landedModel = assignedModel;
   if (ai && catalog.runners.includes(assignedRunner)) {
     const resolved = resolveAssignment({
@@ -603,30 +790,50 @@ function plannedTask(spec, catalog, at = {}) {
   if (Array.isArray(raw.skills)) skillsAsked.set(task, raw.skills);
   return { task, errors, ignored, renamed, adjustments };
 }
+function checkPlanRunners(tasks, runners) {
+  if (!runners) return [];
+  return flattenTasksWithParents(tasks).filter(({ task: t }) => t.type === "ai" && !runners.includes(t.assignedRunner)).map(({ task: t, parent }) => ({
+    taskId: t.id,
+    field: "assignedRunner",
+    message: `${taskWhere(t.title, parent?.title)} has invalid assignedRunner "${t.assignedRunner}". Expected one of: ${runners.join(", ")}`
+  }));
+}
 function checkPlanInvariants(tasks, runners, runnerModes) {
   const rows = flattenTasksWithParents(tasks);
   const errors = [];
   const seen = /* @__PURE__ */ new Set();
+  const body = new Set(tasks.flatMap((t) => t.loop?.body ?? []));
   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.research !== void 0 && typeof t.research !== "boolean") fail("research", `${where}: "research" must be a boolean`);
+    const readOnly = runnerModes ? taggedReadOnlyMode(runnerModes[t.assignedRunner]) : "plan";
+    if (t.research && (t.type !== "ai" || parent !== null || t.ops || body.has(t.id) || readOnly === void 0 || t.taskMode !== readOnly)) {
+      fail("research", `${where}: research is only for top-level read-only AI tasks, never a loop's body`);
+    }
     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;
+    const opsRefused = t.ops && t.type !== "script" ? 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 (t.type === "script") {
+      if (parent !== null) fail("type", `${where} is a script task: only a top-level task can be one, as only a top-level task can be an ops task`);
+      if (t.subtasks?.length) fail("subtasks", `${where} is a script task, which has no subtasks: make each step a command of its own, or a task of its own`);
+      const extra = notAScriptsFields(t);
+      if (extra.length > 0) fail(extra[0], `${where} ${notOnAScriptMessage(extra)}`);
     }
-    if (runners && t.type !== "user" && !runners.includes(t.assignedRunner)) {
-      fail("assignedRunner", `${where} has invalid assignedRunner "${t.assignedRunner}". Expected one of: ${runners.join(", ")}`);
+    for (const e of scriptBodyErrors(t)) fail(e.field, `${where} ${e.message}`);
+    if (t.ops && t.taskMode !== void 0 && t.taskMode === taggedReadOnlyMode(runnerModes?.[t.assignedRunner])) {
+      fail("taskMode", `${where} is an ops task, which acts in the workspace, so it cannot use the read-only profile`);
     }
   }
+  errors.push(...checkPlanRunners(tasks, runners));
+  errors.push(...loopErrors(tasks));
   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}` });
@@ -641,7 +848,7 @@ function findCycle(tasks) {
 }
 
 // src/services/PlanValidator.ts
-function parsePlanJson(raw, runners, runnerModes, autonomousDefault = true) {
+function parsePlanJson(raw, runners, runnerModes, autonomousDefault = false) {
   const { matches, fallback, sawUnbalanced } = extractObjectsWithKey(raw, PLAN_ENVELOPE_KEY);
   const candidates = matches.length > 0 ? [...matches].reverse() : [fallback.json];
   let lastError = null;
@@ -662,7 +869,7 @@ function parsePlanJson(raw, runners, runnerModes, autonomousDefault = true) {
   }
   throw lastError ?? new PlanParseError("Invalid plan: missing tasks array", raw);
 }
-function parsePlanObject(json, raw, runners, runnerModes, autonomousDefault = true) {
+function parsePlanObject(json, raw, runners, runnerModes, autonomousDefault = false) {
   const cleaned = stripTrailingCommas(escapeControlCharsInStrings(json));
   let parsed;
   try {
@@ -676,7 +883,7 @@ function parsePlanObject(json, raw, runners, runnerModes, autonomousDefault = tr
   const [first] = result.errors;
   throw new PlanParseError(first.message, raw, { semantic: first.taskId !== void 0 });
 }
-function validatePlanTasks(obj, runners, runnerModes, autonomousDefault = true) {
+function validatePlanTasks(obj, runners, runnerModes, autonomousDefault = false) {
   const rawTasks = isRecord2(obj) ? obj.tasks : void 0;
   if (!Array.isArray(rawTasks)) {
     return { ok: false, errors: [{ field: "tasks", message: "Invalid plan: missing tasks array" }] };