@ordewell/core 0.10.12 → 0.11.0

package/dist/{chunk-24EL4Z2W.mjs → chunk-YAFNYNFX.mjs}

@@ -7,7 +7,221 @@ import {
   flattenTasksWithParents,
   inheritedSkills,
   skillNames
-} from "./chunk-PFH7WFIB.mjs";
+} from "./chunk-QTZ5XTBY.mjs";
+
+// 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 scriptBodyOf(task) {
+  if (task.type !== "script" || scriptBodyErrors(task).length > 0) return null;
+  const timeoutMs = task.timeoutMs ?? DEFAULT_SCRIPT_TIMEOUT_MS;
+  return task.commands ? { commands: task.commands.map((argv) => [...argv]), timeoutMs } : { script: task.script ?? "", timeoutMs };
+}
+function sameScriptBody(a, b) {
+  return JSON.stringify(bodyKey(a)) === JSON.stringify(bodyKey(b));
+}
+function rewrittenScripts(before, after) {
+  const prior = new Map(flattenTasks(before).map((t) => [t.id, t]));
+  return flattenTasks(after).filter((t) => {
+    const was = prior.get(t.id);
+    return was !== void 0 && (t.type === "script" || was.type === "script") && !sameScriptBody(was, t);
+  }).map((t) => t.id);
+}
+function bodyKey(task) {
+  return task.type === "script" ? [task.commands ?? null, task.script ?? null, task.timeoutMs ?? DEFAULT_SCRIPT_TIMEOUT_MS] : null;
+}
+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);
+  });
+}
+function clearedBodyFields(changes) {
+  for (const field of SCRIPT_BODY_FIELDS) if (changes[field] === null) changes[field] = void 0;
+  return changes;
+}
+var PLAIN_WORD = /^[A-Za-z0-9_@%+=:,./-]+$/;
+var UNSEEN = /[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/u;
+function commandLine(argv) {
+  return argv.map(quotedWord).join(" ");
+}
+function quotedWord(word) {
+  if (PLAIN_WORD.test(word)) return word;
+  if (!UNSEEN.test(word)) return `'${word.replace(/'/g, `'\\''`)}'`;
+  return `$'${[...word].map(escaped).join("")}'`;
+}
+var ESCAPES = { "\\": "\\\\", "'": "\\'", "\n": "\\n", "\r": "\\r", "	": "\\t" };
+function escaped(char) {
+  return ESCAPES[char] ?? (UNSEEN.test(char) ? codeOf(char) : char);
+}
+function codeOf(char) {
+  const code = char.codePointAt(0) ?? 0;
+  const hex = code.toString(16).toUpperCase();
+  return code <= 255 ? `\\x${hex.padStart(2, "0")}` : code <= 65535 ? `\\u${hex.padStart(4, "0")}` : `\\U${hex.padStart(8, "0")}`;
+}
+function scriptBodyText(body) {
+  const shown = "commands" in body ? body.commands.map(commandLine) : [body.script.replace(/\r\n|[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/gu, (char) => char === "\r\n" || char === "\n" || char === "	" ? char : `<U+${(char.codePointAt(0) ?? 0).toString(16).toUpperCase().padStart(4, "0")}>`)];
+  return [...shown, "", `Time limit: ${timeLimitText(body.timeoutMs)}.`].join("\n");
+}
+function scriptTaskText(task) {
+  const body = scriptBodyOf(task);
+  return body ? scriptBodyText(body) : "This script task has no valid body, so it cannot run.";
+}
+function timeLimitText(ms) {
+  const units = [[36e5, "hour"], [6e4, "minute"], [1e3, "second"], [1, "millisecond"]];
+  const [size, name] = units.find(([unit]) => ms % unit === 0) ?? units[units.length - 1];
+  const n = ms / size;
+  return `${n} ${name}${n === 1 ? "" : "s"}`;
+}
+
+// src/models/Loop.ts
+var DEFAULT_LOOP_ROUNDS = 3;
+var MAX_LOOP_ROUNDS = 10;
+function loopRoundOf(check) {
+  return check.loopRound ?? 1;
+}
+function foundWanting(check) {
+  return check.verdict?.outcome === "fail" && check.verdict.reported === "failed";
+}
+function betweenRounds(check) {
+  return !!check.loop && check.status === "failed" && foundWanting(check) && loopRoundOf(check) < check.loop.maxRounds;
+}
+function outOfRounds(check) {
+  return !!check.loop && check.status === "failed" && foundWanting(check) && loopRoundOf(check) >= check.loop.maxRounds;
+}
+function checkOf(tasks, taskId) {
+  return tasks.find((t) => t.loop?.body.includes(taskId));
+}
+function inLoop(tasks, task) {
+  return !!task.loop || checkOf(tasks, task.id) !== void 0;
+}
+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;
+}
+function loopRemovalRefusal(task) {
+  return task.loop ? `"${task.title}" is a loop's check: remove its body tasks first, or drop its loop ("loop": null), so they do not run on their own` : null;
+}
+function loopReshapeRefusal(tasks, target, action) {
+  if (target.loop) return `"${target.title}" is a loop's check and cannot be ${action}: drop its loop first ("loop": null)`;
+  return checkOf(tasks, target.id) ? `"${target.title}" is in a loop's body and cannot be ${action}: take it out of the loop first` : null;
+}
 
 // src/services/JsonExtractor.ts
 var PLAN_ENVELOPE_KEY = "tasks";
@@ -70,12 +284,12 @@ function opensWithJsonObject(prefix) {
 function balancedObjectAt(text2, start) {
   let depth = 0;
   let inString = false;
-  let escaped = false;
+  let escaped2 = false;
   for (let i = start; i < text2.length; i++) {
     const ch = text2[i];
     if (inString) {
-      if (escaped) escaped = false;
-      else if (ch === "\\") escaped = true;
+      if (escaped2) escaped2 = false;
+      else if (ch === "\\") escaped2 = true;
       else if (ch === '"') inString = false;
       continue;
     }
@@ -96,12 +310,12 @@ function extractObjectsWithKey(raw, key) {
   let sawBrace = false;
   let sawUnbalanced = false;
   let inString = false;
-  let escaped = false;
+  let escaped2 = false;
   for (let i = 0; i < stripped.length; i++) {
     const ch = stripped[i];
     if (inString) {
-      if (escaped) escaped = false;
-      else if (ch === "\\") escaped = true;
+      if (escaped2) escaped2 = false;
+      else if (ch === "\\") escaped2 = true;
       else if (ch === '"') inString = false;
       continue;
     }
@@ -141,17 +355,17 @@ function stripTrailingCommas(json) {
 function escapeControlCharsInStrings(json) {
   let out = "";
   let inString = false;
-  let escaped = false;
+  let escaped2 = false;
   for (const ch of json) {
     if (inString) {
-      if (escaped) {
+      if (escaped2) {
         out += ch;
-        escaped = false;
+        escaped2 = false;
         continue;
       }
       if (ch === "\\") {
         out += ch;
-        escaped = true;
+        escaped2 = true;
         continue;
       }
       if (ch === '"') {
@@ -184,7 +398,7 @@ function escapeControlCharsInStrings(json) {
 function runnerModesFrom(registry, runners) {
   return Object.fromEntries(runners.map((r) => [r, registry.getManifest(r)?.modes ?? []]));
 }
-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]);
@@ -210,6 +424,13 @@ function parseAutonomyLevel(arg) {
       return null;
   }
 }
+function parseAutonomyFlag(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (!normalized) return void 0;
+  if (normalized === "true" || normalized === "1") return true;
+  if (normalized === "false" || normalized === "0") return false;
+  return parseAutonomyLevel(normalized) ?? void 0;
+}
 function taggedReadOnlyMode(modes) {
   return modes?.find((m) => m.readOnly)?.id;
 }
@@ -227,7 +448,7 @@ 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) {
+function plannedMode(runner, runnerModes, { readOnly, current }, autonomousDefault = false) {
   if (!runnerModes) return { ok: true, mode: void 0 };
   const modes = runnerModes[runner] ?? [];
   const readOnlyId = readOnlyMode(modes);
@@ -251,8 +472,8 @@ function carryPlannedModes(before, rewrite, catalog) {
   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);
+    if (t.type !== "ai" || !was || was.type !== "ai" || t.taskMode === taggedReadOnlyMode(catalog.runnerModes[t.assignedRunner])) return { ...t, subtasks };
+    const mode = plannedMode(t.assignedRunner, catalog.runnerModes, { readOnly: false, current: was.taskMode }, catalog.autonomousDefault ?? false);
     return { ...t, subtasks, ...mode.ok && mode.mode !== void 0 ? { taskMode: mode.mode } : {} };
   };
   return rewrite.map(carry);
@@ -318,9 +539,8 @@ function liveModelRefusal(task) {
 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])];
+function assignableRunners(writer, enabled) {
+  if (writer === "plan" || writer === "edit") return [...enabled];
   return void 0;
 }
 function sameAssignment(a, b) {
@@ -343,7 +563,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));
@@ -355,7 +575,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) {
@@ -367,7 +587,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);
@@ -457,14 +677,25 @@ function resolveAssignments(tasks, planned, catalog) {
 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`;
+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;
@@ -488,6 +719,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 = uuidv4 } = at;
@@ -501,17 +751,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;
@@ -534,7 +793,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,
@@ -542,10 +802,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({
@@ -568,30 +831,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}` });
@@ -609,6 +892,27 @@ function detectCycle(tasks) {
 }
 
 export {
+  DEFAULT_SCRIPT_TIMEOUT_MS,
+  SCRIPT_BODY_FIELDS,
+  scriptBodyOf,
+  sameScriptBody,
+  rewrittenScripts,
+  notAScriptsFields,
+  clearedBodyFields,
+  commandLine,
+  scriptBodyText,
+  scriptTaskText,
+  timeLimitText,
+  DEFAULT_LOOP_ROUNDS,
+  MAX_LOOP_ROUNDS,
+  loopRoundOf,
+  betweenRounds,
+  outOfRounds,
+  checkOf,
+  inLoop,
+  loopSpec,
+  loopRemovalRefusal,
+  loopReshapeRefusal,
   PLAN_ENVELOPE_KEY,
   TASK_OPS_ENVELOPE_KEY,
   TASK_QUERY_ENVELOPE_KEY,
@@ -622,6 +926,7 @@ export {
   runnerModesFrom,
   autonomyLevelLabel,
   parseAutonomyLevel,
+  parseAutonomyFlag,
   taggedReadOnlyMode,
   readOnlyMode,
   unavailableTaskModeMessage,
@@ -637,6 +942,7 @@ export {
   MODE_NOT_THE_PLANNERS,
   MANUAL_NOT_READ_ONLY,
   OPS_NOT_READ_ONLY,
+  notOnAScriptMessage,
   opsPlacementRefusal,
   taskWhere,
   requestedSkills,
@@ -644,4 +950,4 @@ export {
   checkPlanInvariants,
   detectCycle
 };
-//# sourceMappingURL=chunk-24EL4Z2W.mjs.map
+//# sourceMappingURL=chunk-YAFNYNFX.mjs.map