@ordewell/core 0.10.12 → 0.11.1

package/dist/{chunk-KWS3VEER.mjs → chunk-MYXMIVWA.mjs}

@@ -7,13 +7,13 @@ import {
   plannedTask,
   stripTrailingCommas,
   taskWhere
-} from "./chunk-24EL4Z2W.mjs";
+} from "./chunk-YAFNYNFX.mjs";
 import {
   flattenTasksWithParents
-} from "./chunk-PFH7WFIB.mjs";
+} from "./chunk-QTZ5XTBY.mjs";
 
 // 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;
@@ -34,7 +34,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 {
@@ -48,7 +48,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 = isRecord(obj) ? obj.tasks : void 0;
   if (!Array.isArray(rawTasks)) {
     return { ok: false, errors: [{ field: "tasks", message: "Invalid plan: missing tasks array" }] };
@@ -94,4 +94,4 @@ export {
   validatePlanTasks,
   looksLikePlanAttempt
 };
-//# sourceMappingURL=chunk-KWS3VEER.mjs.map
+//# sourceMappingURL=chunk-MYXMIVWA.mjs.map

package/dist/chunk-MYXMIVWA.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/services/PlanValidator.ts"],"sourcesContent":["import { Task, RunnerId, flattenTasksWithParents } from '../models/Task';\nimport { extractObjectsWithKey, stripTrailingCommas, escapeControlCharsInStrings, PlanParseError, PLAN_ENVELOPE_KEY } from './JsonExtractor';\nimport type { RunnerModeInfo } from './ModeResolver';\nimport { plannedTask, checkPlanInvariants, taskWhere, type PlanTaskError } from './PlannedTask';\n\nexport function parsePlanJson(\n  raw: string,\n  runners: RunnerId[],\n  runnerModes?: Record<RunnerId, RunnerModeInfo[]>,\n  autonomousDefault = false,\n): Task[] {\n  const { matches, fallback, sawUnbalanced } = extractObjectsWithKey(raw, PLAN_ENVELOPE_KEY);\n\n  // A reply can carry several tasks-keyed objects — a schema echo from the\n  // prompt, an inline draft, then the real plan. The model's LAST emission is\n  // its final answer, so candidates are tried back to front and the first one\n  // that fully parses and validates wins.\n  const candidates = matches.length > 0 ? [...matches].reverse() : [fallback.json];\n\n  let lastError: PlanParseError | null = null;\n  for (const json of candidates) {\n    try {\n      return parsePlanObject(json, raw, runners, runnerModes, autonomousDefault);\n    } catch (err) {\n      if (!(err instanceof PlanParseError)) throw err;\n      // Prefer surfacing the error from the most plan-like candidate: the\n      // last one carrying a tasks key (tried first).\n      if (!lastError) lastError = err;\n    }\n  }\n\n  // No usable tasks object anywhere, but an object ran off the end of the\n  // text: the plan was almost certainly cut off mid-stream.\n  if (matches.length === 0 && sawUnbalanced) {\n    throw new PlanParseError(\n      'Plan response appears truncated: the model likely hit its output length limit before finishing the JSON.',\n      raw,\n      { truncated: true },\n    );\n  }\n  throw lastError ?? new PlanParseError('Invalid plan: missing tasks array', raw);\n}\n\nfunction parsePlanObject(\n  json: string,\n  raw: string,\n  runners: RunnerId[],\n  runnerModes?: Record<RunnerId, RunnerModeInfo[]>,\n  autonomousDefault = false,\n): Task[] {\n  const cleaned = stripTrailingCommas(escapeControlCharsInStrings(json));\n\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(cleaned);\n  } catch (err) {\n    const detail = err instanceof Error ? err.message : String(err);\n    throw new PlanParseError(`Plan response was not valid JSON: ${detail}`, raw);\n  }\n\n  const result = validatePlanTasks(parsed, runners, runnerModes, autonomousDefault);\n  if (result.ok) return result.tasks;\n  const [first] = result.errors;\n  // An envelope problem (no tasks array, an empty one) keeps the generic\n  // re-emit; only a rule broken by a task is worth naming in the corrective.\n  throw new PlanParseError(first.message, raw, { semantic: first.taskId !== undefined });\n}\n\nexport type { PlanTaskError } from './PlannedTask';\nexport { requestedSkills } from './PlannedTask';\n\n/** `warnings` name what was accepted but not used, for a channel that can tell the planner. */\nexport type PlanTasksResult = { ok: true; tasks: Task[]; warnings?: string[] } | { ok: false; errors: PlanTaskError[] };\n\n/**\n * Every check a plan's tasks must pass, on an already-parsed `{ tasks }`\n * object — what a plan is held to whichever channel it arrived on. All\n * problems are reported, the slice classification first, so the first is the\n * one the text path's corrective names.\n */\nexport function validatePlanTasks(\n  obj: unknown,\n  runners: RunnerId[],\n  runnerModes?: Record<RunnerId, RunnerModeInfo[]>,\n  autonomousDefault = false,\n): PlanTasksResult {\n  const rawTasks = isRecord(obj) ? obj.tasks : undefined;\n  if (!Array.isArray(rawTasks)) {\n    return { ok: false, errors: [{ field: 'tasks', message: 'Invalid plan: missing tasks array' }] };\n  }\n  if (rawTasks.length === 0) {\n    return { ok: false, errors: [{ field: 'tasks', message: 'Plan contained no tasks' }] };\n  }\n\n  const planned = rawTasks.map((t) => plannedTask(t, { runners, runnerModes, autonomousDefault }));\n  const tasks = planned.map((p) => p.task);\n  const errors = [\n    ...sliceRequired(tasks),\n    ...planned.flatMap((p) => p.errors),\n    ...checkPlanInvariants(tasks, runners, runnerModes),\n  ];\n\n  if (errors.length > 0) return { ok: false, errors };\n  const ignored = planned.flatMap((p) => p.ignored);\n  const warnings = [\n    ...(ignored.some((i) => i.field === 'taskMode')\n      ? ['\"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.']\n      : []),\n    ...ignored.filter((i) => i.field === 'readOnly').map((i) => `${i.message}: it was ignored.`),\n  ];\n  return warnings.length > 0 ? { ok: true, tasks, warnings } : { ok: true, tasks };\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\n/**\n * Whether a reply that failed {@link parsePlanJson} actually LOOKED like a\n * plan attempt — a balanced tasks-keyed object, or JSON that got cut off.\n * Distinguishes \"the model tried to emit a plan and botched it\" (worth a\n * corrective retry) from prose that merely mentions `\"tasks\"` (leave alone).\n */\nexport function looksLikePlanAttempt(raw: string): boolean {\n  const { matches, sawUnbalanced } = extractObjectsWithKey(raw, PLAN_ENVELOPE_KEY);\n  if (matches.length > 0) return true;\n  return sawUnbalanced && raw.includes(`\"${PLAN_ENVELOPE_KEY}\"`);\n}\n\n/**\n * A whole plan says how each task is sliced: an edit may leave it to the\n * task's parent or the tasks it was made from, a submitted plan may not.\n */\nfunction sliceRequired(tasks: readonly Task[]): PlanTaskError[] {\n  return flattenTasksWithParents(tasks).flatMap(({ task: t, parent }) => {\n    const where = taskWhere(t.title, parent?.title);\n    const errors: PlanTaskError[] = [];\n    if (!t.sliceType) errors.push({ taskId: t.id, field: 'sliceType', message: `${where} is missing sliceType. Every task must specify sliceType (\"AFK\" or \"HITL\").` });\n    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\").` });\n    return errors;\n  });\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-PFH7WFIB.mjs → chunk-QTZ5XTBY.mjs}

@@ -68,18 +68,18 @@ function dependencyTargetErrors(tasks, taskId, dependencies) {
 }
 function findDependencyCycle(tasks) {
   const byId = new Map([...walkPlan(tasks)].map(({ task }) => [task.id, task]));
-  const path = [];
+  const path2 = [];
   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);
+    const at = path2.indexOf(id);
+    if (at >= 0) return path2.slice(at);
+    path2.push(id);
     for (const dep of byId.get(id)?.dependencies ?? []) {
       const hit = visit(dep);
       if (hit) return hit;
     }
-    path.pop();
+    path2.pop();
     done.add(id);
     return null;
   };
@@ -101,6 +101,138 @@ function canSetDependencies(tasks, taskId, dependencies) {
   return cycle ? { ok: false, error: `Dependency cycle detected: ${[...cycle, cycle[0]].map((t) => `"${t.title}"`).join(" \u2192 ")}` } : { ok: true };
 }
 
+// src/services/repoPath.ts
+var SELF_REPO = ".";
+
+// src/services/isolationRecord.ts
+import * as path from "path";
+function integrationBranchFor(runId) {
+  return `ordewell/${runId}/integration`;
+}
+function repoRootOf(workspaceRoot, repoPath) {
+  return path.join(workspaceRoot, repoPath);
+}
+function noRemoval() {
+  return { preserved: [], refused: [] };
+}
+var PrepareFailedError = class extends Error {
+  constructor(failure, preserved) {
+    super(failure instanceof Error ? failure.message : String(failure));
+    this.failure = failure;
+    this.preserved = preserved;
+    this.name = failure instanceof Error ? failure.name : "Error";
+    this.cause = failure;
+  }
+  failure;
+  preserved;
+};
+function absorbRemoval(into, from) {
+  into.preserved.push(...from.preserved);
+  into.refused.push(...from.refused);
+  return into;
+}
+function layoutOf(run) {
+  return { repos: run.repos.map((r) => r.path), shared: [...run.shared] };
+}
+var ISOLATION_STATE = {
+  active: "active",
+  merged: "integrated",
+  conflict: "conflict",
+  repairing: "repairing",
+  kept: "kept",
+  failed: "kept"
+};
+var isKnownStatus = (status) => Object.prototype.hasOwnProperty.call(ISOLATION_STATE, status);
+function changedReposOf(record) {
+  return Object.entries(record.repos).filter(([, r]) => r.changed).map(([repoPath]) => repoPath);
+}
+function taskIsolationOf(record, repairLimit) {
+  return {
+    state: ISOLATION_STATE[record.status],
+    branch: record.branch,
+    worktree: record.workspace,
+    repos: changedReposOf(record),
+    ...record.conflictRepo ? { conflictRepo: record.conflictRepo } : {},
+    ...record.conflictFiles?.length ? { conflictFiles: record.conflictFiles } : {},
+    ...record.repairs && repairLimit !== void 0 ? { repair: { attempt: record.repairs, limit: repairLimit } } : {},
+    ...record.repairedFiles?.length ? { repairedFiles: record.repairedFiles } : {}
+  };
+}
+function handoffOf(run) {
+  const merged = Object.values(run.tasks).filter((r) => r.status === "merged" && !r.inHead).sort((a, b) => a.order - b.order);
+  const entry = (r) => ({
+    taskId: r.taskId,
+    order: r.order,
+    title: r.title,
+    ...r.repairedFiles?.length ? { repairedFiles: r.repairedFiles } : {}
+  });
+  return {
+    repos: run.repos.map((repo) => ({
+      path: repo.path,
+      integrationBranch: repo.integrationBranch,
+      baseRef: repo.baseRef,
+      ...repo.baseBranch ? { baseBranch: repo.baseBranch } : {},
+      ...repo.startedDetached ? { startedDetached: true } : {},
+      landed: merged.filter((r) => r.repos[repo.path]?.changed).map(entry)
+    })),
+    landed: merged.map(entry)
+  };
+}
+function isAdr0013(run) {
+  return "integrationBranch" in run && typeof run.integrationBranch === "string";
+}
+function fromAdr0013Task(r) {
+  return {
+    taskId: r.taskId,
+    order: r.order,
+    title: r.title,
+    branch: r.branch,
+    workspace: r.worktree,
+    status: r.status,
+    // A merged task's branch was merged into the one repo there was; what it
+    // changed was never recorded, and landing is what `changed` stands for.
+    repos: { [SELF_REPO]: { worktree: r.worktree, linked: r.linked ?? [], ...r.status === "merged" ? { changed: true } : {} } },
+    ...r.status === "conflict" ? { conflictRepo: SELF_REPO } : {}
+  };
+}
+function migratePlanIsolation(state) {
+  const { run, resolvers } = state;
+  if (!isAdr0013(run)) return { run, resolvers: resolvers ?? {} };
+  const repo = {
+    path: SELF_REPO,
+    root: repoRootOf(run.workspaceRoot, SELF_REPO),
+    baseRef: run.baseRef,
+    ...run.baseBranch ? { baseBranch: run.baseBranch } : {},
+    integrationBranch: run.integrationBranch
+  };
+  const tasks = Object.fromEntries(Object.entries(run.tasks ?? {}).map(([id, r]) => [id, fromAdr0013Task(r)]));
+  return { run: { id: run.id, workspaceRoot: run.workspaceRoot, repos: [repo], shared: [], sharedRepos: [], tasks }, resolvers: resolvers ?? {} };
+}
+function migratePlanStateIsolation(plan) {
+  if (plan.isolation?.run) plan.isolation = migratePlanIsolation(plan.isolation);
+}
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isArray = (value) => Array.isArray(value);
+function carriesIsolation(plan) {
+  if (!isRecord(plan) || !isRecord(plan.isolation)) return false;
+  const { run } = plan.isolation;
+  if (!isRecord(run) || !isRecord(run.tasks)) return false;
+  if (isArray(run.repos)) {
+    return run.repos.some((repo) => isRecord(repo) && typeof repo.path === "string" && typeof repo.integrationBranch === "string" && typeof repo.baseRef === "string");
+  }
+  return typeof run.integrationBranch === "string" && typeof run.baseRef === "string";
+}
+function isolationViewOfPlan(plan, repairLimit) {
+  if (!carriesIsolation(plan)) return null;
+  const { run } = migratePlanIsolation(plan.isolation);
+  const tasks = {};
+  for (const [taskId, record] of Object.entries(run.tasks)) {
+    if (!isKnownStatus(record.status)) continue;
+    tasks[taskId] = taskIsolationOf(record, repairLimit);
+  }
+  return { tasks, handoff: handoffOf(run) };
+}
+
 // src/services/TaskRefs.ts
 function taskOrderLabel(task, parent) {
   return parent ? `${parent.label ?? parent.order}.${task.order}` : String(task.order);
@@ -169,6 +301,40 @@ function migrateLoadedTasks(tasks) {
     migrateLoadedTasks(task.subtasks ?? []);
   }
 }
+function dropRetiredPlanFields(plan) {
+  const raw = plan;
+  delete raw.researchBudget;
+  const settings = plan.runSettings;
+  if (settings) {
+    delete settings.researchMaxParallel;
+    delete settings.researchMaxPerMessage;
+  }
+  for (const turn of plan.pendingTurns ?? []) delete turn.budgetStarted;
+  for (const task of flattenTasks(plan.tasks)) delete task.researchWait;
+}
+function carryOverQueuedEdits(plan) {
+  const queued = plan.queuedMessages ?? [];
+  delete plan.queuedMessages;
+  if (queued.length === 0) return;
+  const carried = queued.map(({ id, text, timestamp, skills }) => ({ id, source: "user", text, timestamp, ...skills ? { skills } : {} }));
+  plan.pendingTurns = [...plan.pendingTurns ?? [], ...carried];
+}
+function migrateLoadedPlan(plan, { adopting = true } = {}) {
+  plan.approved ??= plan.status !== "draft" && plan.status !== "rejected";
+  if (!plan.approvedTasks && plan.approved) {
+    plan.approvedTasks = flattenTasks(plan.tasks).map((t) => t.id);
+  }
+  if (adopting) {
+    for (const task of flattenTasks(plan.tasks)) delete task.resumeAt;
+  }
+  migratePlanStateIsolation(plan);
+  delete plan.runnerTransport;
+  for (const key of ["supervisorLevel", "mergeAtGatesAutomatically", "supervisorRetryLimit", "wakeUpReadBudget"]) {
+    delete plan[key];
+  }
+  dropRetiredPlanFields(plan);
+  carryOverQueuedEdits(plan);
+}
 function isUserMessage(entry) {
   return entry.role === "user" && entry.kind !== "skill_load" && entry.kind !== "wake_up";
 }
@@ -254,12 +420,13 @@ function migratePlanState(raw) {
 }
 function createTask(overrides = {}) {
   const skills = skillNames(overrides.skills);
+  const type = overrides.type ?? "ai";
   return {
     id: overrides.id ?? uuidv4(),
     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,
@@ -267,16 +434,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}$`);
@@ -295,6 +471,9 @@ function inheritedSkills(chosen, inherited) {
 function opsFlag(value, type = "ai") {
   return value === true && type === "ai" ? true : void 0;
 }
+function runsAsOps(task) {
+  return task.type === "script" || opsFlag(task.ops, task.type) === true;
+}
 function inheritedOps(from, chosen) {
   return chosen ?? from.every((t) => opsFlag(t.ops) === true);
 }
@@ -342,11 +521,19 @@ function addTaskToPlan(tasks, partial) {
 }
 function removeTaskFromPlan(tasks, taskId) {
   const removed = subtreeIds(tasks, taskId);
-  const prune = (level) => level.filter((t) => !removed.has(t.id)).map((t) => ({
-    ...t,
-    dependencies: t.dependencies.filter((depId) => !removed.has(depId)),
-    subtasks: prune(t.subtasks)
-  }));
+  const prune = (level) => level.filter((t) => !removed.has(t.id)).map((t) => {
+    const pruned = {
+      ...t,
+      dependencies: t.dependencies.filter((depId) => !removed.has(depId)),
+      subtasks: prune(t.subtasks)
+    };
+    if (!t.loop?.body.some((id) => removed.has(id))) return pruned;
+    const body = t.loop.body.filter((id) => !removed.has(id));
+    if (body.length > 0) return { ...pruned, loop: { ...t.loop, body } };
+    delete pruned.loop;
+    delete pruned.loopRound;
+    return pruned;
+  });
   return renumberTasks(prune(tasks));
 }
 function updateTaskInPlan(tasks, taskId, changes) {
@@ -364,6 +551,9 @@ function renumberTasks(tasks) {
     subtasks: renumberTasks(t.subtasks)
   }));
 }
+function waitsMidAttempt(task) {
+  return task.status === "awaiting_user" && (task.awaitingReason === "checkpoint" || task.awaitingReason === "input");
+}
 function pausedOnLimit(task) {
   return task.status === "awaiting_user" && task.awaitingReason === "usage-limit";
 }
@@ -377,7 +567,7 @@ function approvalRecordOf(plan) {
   };
 }
 function waitsForApproval(task, record) {
-  return record.approved === true && task.type === "ai" && (task.status === "pending" || task.status === "approved") && !(record.approvedTasks ?? []).includes(task.id);
+  return record.approved === true && task.type !== "user" && (task.status === "pending" || task.status === "approved") && !(record.approvedTasks ?? []).includes(task.id);
 }
 function stampOrigin(before, after, bySupervisor) {
   const prior = new Map(flattenTasks([...before]).map((t) => [t.id, t]));
@@ -404,20 +594,26 @@ function keepExecutionState(current, rewrite) {
     const result = tasks.map((t) => {
       const prior = existing.get(t.id);
       if (prior && SETTLED_STATUSES.has(prior.status)) return { ...prior };
+      if (prior?.status === "failed" && prior.type === "script" !== (t.type === "script")) return { ...prior };
       return {
         ...t,
         status: prior?.status ?? "pending",
         skipReason: prior?.skipReason,
         verdict: prior?.verdict,
         outputSummary: prior?.outputSummary,
+        handoff: prior?.handoff,
         runnerSessionId: prior?.runnerSessionId,
         runnerSessionOwner: prior?.runnerSessionOwner,
         carriedFrom: prior?.carriedFrom,
         attemptSkills: prior?.attemptSkills,
+        attempted: prior?.attempted,
         attemptUsage: prior?.attemptUsage,
+        loopRound: prior?.loopRound,
         // Where a task that has run ran is fixed, like its runner session (ADR-0020).
         ...prior?.status === "failed" ? { ops: prior.ops } : {},
         forcedPastGate: prior?.forcedPastGate,
+        reportTo: prior?.reportTo,
+        researchOrigin: prior?.researchOrigin,
         subtasks: overlay(t.subtasks ?? [], prior?.subtasks ?? [])
       };
     });
@@ -443,6 +639,19 @@ export {
   dependencyTargetErrors,
   findDependencyCycle,
   canSetDependencies,
+  SELF_REPO,
+  integrationBranchFor,
+  repoRootOf,
+  noRemoval,
+  PrepareFailedError,
+  absorbRemoval,
+  layoutOf,
+  changedReposOf,
+  taskIsolationOf,
+  handoffOf,
+  migratePlanIsolation,
+  migratePlanStateIsolation,
+  isolationViewOfPlan,
   taskOrderLabel,
   taskRef,
   titledTaskRef,
@@ -452,6 +661,8 @@ export {
   resolveUserTaskRef,
   isAwaitingReason,
   migrateLoadedTasks,
+  dropRetiredPlanFields,
+  migrateLoadedPlan,
   isUserMessage,
   migratePlanState,
   createTask,
@@ -459,6 +670,7 @@ export {
   skillNames,
   inheritedSkills,
   opsFlag,
+  runsAsOps,
   inheritedOps,
   DEFAULT_RUNNERS,
   createEmptyPlan,
@@ -469,6 +681,7 @@ export {
   removeTaskFromPlan,
   updateTaskInPlan,
   renumberTasks,
+  waitsMidAttempt,
   pausedOnLimit,
   waitsForReset,
   approvalRecordOf,
@@ -476,4 +689,4 @@ export {
   stampOrigin,
   keepExecutionState
 };
-//# sourceMappingURL=chunk-PFH7WFIB.mjs.map
+//# sourceMappingURL=chunk-QTZ5XTBY.mjs.map