@ordewell/core 0.10.1 → 0.10.3

package/dist/{Task-CxwnCJLi.d.ts → Task-CRVIqSfy.d.ts}

@@ -330,8 +330,26 @@ interface PreparedTask {
     setupFailed?: SetupFailure[];
     /** What the attempt this one replaces left unlanded, kept on a branch before its worktree went; absent when nothing was. */
     preserved?: PreservedWork[];
-    continuation?: 'restored' | 'fallback';
+    /** Set for a `restore` prepare: whether the previous attempt's work was put back, or every repo fell back to its tip. */
+    restoration?: 'restored' | 'fallback';
 }
+/**
+ * How a task workspace starts: `fresh` from the integration tips, `restore`
+ * with the previous attempt's preserved work merged on top of them — for a
+ * continue (ADR-0018, K1) and for a carry-over to another runner.
+ */
+type PrepareIntent = 'fresh' | 'restore';
+/**
+ * What a restoring attempt is told became of the previous attempt's work: in
+ * its working tree, or kept on `preserved` branches because restoring it
+ * conflicted with the integration tips.
+ */
+type PreviousWork = {
+    outcome: 'restored';
+} | {
+    outcome: 'fallback';
+    preserved: readonly PreservedWork[];
+};
 /** A task as a removal names it. */
 type IsolationTaskRef = Pick<IsolationTaskRecord, 'taskId' | 'order' | 'title'>;
 /**
@@ -400,11 +418,11 @@ interface IWorktreeIsolation {
     /**
      * Create the task workspace — one worktree per isolated repo from its
      * integration tip, the shared paths linked in — and return the cwd to spawn
-     * the Runner into. Fresh attempts start clean from the tips. A continuation
-     * restores the previous attempt's preserved work on top of them, falling
-     * back to the tips in every repo when any restoration conflicts (ADR-0018).
+     * the Runner into. Fresh attempts start clean from the tips. A `restore`
+     * puts the previous attempt's preserved work on top of them, falling back
+     * to the tips in every repo when any restoration conflicts (ADR-0018).
      */
-    prepare(task: Task, run: IsolationRun, intent?: 'fresh' | 'continuation'): Promise<PreparedTask>;
+    prepare(task: Task, run: IsolationRun, intent?: PrepareIntent): Promise<PreparedTask>;
     /**
      * Hand a conflicted task's kept workspace to a conflict repair (ADR-0015)
      * as it is — nothing is re-cut — and return the same cwd. Records each
@@ -914,7 +932,8 @@ interface TaskOutputSummary {
 type TaskType = 'ai' | 'user';
 /**
  * `skipped` is terminal and verdict-less: the task will not be waited for, and
- * nothing it did lands. Its dependents go ahead without it.
+ * nothing it did lands. Its dependents go ahead without it once the work it
+ * waited on is done.
  */
 type TaskStatus = 'pending' | 'approved' | 'in_progress' | 'completed' | 'failed' | 'blocked' | 'awaiting_user' | 'skipped';
 type TaskMode = string;
@@ -983,6 +1002,12 @@ interface Task {
      * waits for a manual retry. Set only with `awaitingReason` `usage-limit`.
      */
     resumeAt?: string;
+    /**
+     * The runner a task paused on its usage limit was moved off (ADR-0018, U1):
+     * its next attempt is a carry-over, a fresh session that starts from that
+     * attempt's files. Cleared once that attempt runs, and by a retry.
+     */
+    carriedFrom?: RunnerId;
     /** Why the task was skipped, as whoever skipped it put it; set only while `status` is `skipped`, and not always then. */
     skipReason?: string;
     /**
@@ -1274,9 +1299,17 @@ interface LegacyPlanState {
      * The tasks the user approved to run: every task when they executed the
      * plan, and each one they started or retried themselves since. A command
      * from anyone else starts only these (ADR-0029); a task the planner added
-     * after the approval waits for the user's.
+     * after the approval waits for the user's. Only tasks still in the plan: a
+     * task that leaves takes its approval with it.
      */
     approvedTasks?: string[];
+    /**
+     * The user approved the plan to run: Execute plan, signing off a review, or
+     * autorun's start (ADR-0029, ADR-0030). Kept apart from {@link status},
+     * which surfaces rewrite for display; a user's start of one task approves
+     * that task, not the plan.
+     */
+    approved?: boolean;
 }
 interface Message {
     id: string;
@@ -1290,7 +1323,8 @@ interface TaskSnapshot extends Task {
     retryCount: number;
     finalized: boolean;
 }
-type PlanState = {
+/** The plan a surface reads whole carries the approval record, so it can tell which tasks wait for the user (ADR-0035). */
+type PlanState = ({
     phase: 'planning';
     history: Message[];
     message: string;
@@ -1304,11 +1338,15 @@ type PlanState = {
     goal: string;
     runners: string[];
     status: PlanStatus;
-};
+}) & ApprovalRecord;
 declare function migratePlanState(raw: unknown): PlanState;
 
 declare function createTask(overrides?: Partial<Task>): Task;
-/** The runner set a plan has until one is chosen: the one runner every host ships. */
+/**
+ * The runner set a plan has until one is chosen. The one runner named outside
+ * its declaration on purpose: a default is a product choice that no manifest
+ * or connector implies.
+ */
 declare const DEFAULT_RUNNERS: readonly RunnerId[];
 declare function createEmptyPlan(): LegacyPlanState;
 declare function flattenTasks(tasks: readonly Task[]): Task[];
@@ -1337,5 +1375,14 @@ interface TaskWithParent {
 declare function flattenTasksWithParents(tasks: readonly Task[]): TaskWithParent[];
 /** A task paused on its runner's usage limit, whether it resumes on its own or waits for the user (#84). */
 declare function pausedOnLimit(task: Readonly<Task>): boolean;
+/** The user's approval record, as a plan carries it (ADR-0029). */
+type ApprovalRecord = Pick<LegacyPlanState, 'approved' | 'approvedTasks'>;
+/**
+ * A task the scheduler leaves for the user (ADR-0035): an AI task not started
+ * yet, in a plan they approved, outside their approval record — the planner
+ * added it since. It starts once they start it or execute the plan. In a plan
+ * they never approved nothing is theirs yet, so nothing is singled out.
+ */
+declare function waitsForApproval(task: Pick<Task, 'id' | 'type' | 'status'>, record: ApprovalRecord): boolean;
 
-export { type RunnerId as $, type AttemptUsage as A, BUILTIN_SKILL_NAMES as B, type ConversationMessage as C, DEFAULT_RUNNERS as D, type ExecutionActor as E, type IsolationView as F, type GuardTarget as G, type PlanIsolation as H, type IWorktreeIsolation as I, type PlanState as J, type PlanStatus as K, type LegacyPlanState as L, type ModelUsage as M, type PlanUsage as N, type PlannerUsage as O, type PendingPlanTurn as P, type PreparedTask as Q, type PreservedWork as R, type RefusedRemoval as S, type RepairEvidence as T, type RepoGroupLayout as U, type ResearchLogEntry as V, type ResearchProgress as W, type ResearchStep as X, type ResearchStepOutcome as Y, type ResearchToolType as Z, type RunSettings as _, type AwaitingReason as a, type SetupFailure as a0, type ShadowedSkill as a1, type SkillAppliesTo as a2, type SkillCatalog as a3, type SkillInfo as a4, type SkillLoad as a5, type SkillLoadNotice as a6, type SkillMetadata as a7, type SkillSource as a8, SkillsService as a9, endAttemptUsage as aA, flattenTasks as aB, flattenTasksWithParents as aC, isAwaitingReason as aD, isMeasured as aE, isSupervisorLevel as aF, isUserMessage as aG, migratePlanState as aH, partedPromptUsage as aI, pausedOnLimit as aJ, planUsage as aK, plannerContextFill as aL, rejoinPlanTree as aM, startAttemptUsage as aN, usageLine as aO, type SubagentOutcome as aa, type SupervisorLevel as ab, type Task as ac, type TaskDiffRead as ad, type TaskDiffResult as ae, type TaskIsolation as af, type TaskIsolationState as ag, type TaskModelAssignment as ah, type TaskSkillNotice as ai, type TaskSkillSnapshot as aj, type TaskSnapshot as ak, type TaskStatus as al, type TreeSnapshot as am, type UsageLine as an, type UsageRecord as ao, type UsageTotals as ap, type Verdict as aq, type VerificationCheck as ar, addAttemptUsage as as, addModelUsage as at, addPlannerUsage as au, addUsage as av, addUsageTotals as aw, createEmptyPlan as ax, createSkillsService as ay, createTask as az, DEFAULT_SUPERVISOR_RETRY_LIMIT as b, type DiscoveredModel as c, type ExecutionCommandName as d, type ExecutionRecord as e, type GuardTrip as f, type IntegrationDisposal as g, type InvalidSkill as h, type IsolationAvailability as i, type IsolationHandoff as j, type IsolationHandoffRepo as k, type IsolationInactiveReason as l, type IsolationLandedTask as m, type IsolationLanding as n, type IsolationMergeBlock as o, type IsolationMergeBlockReason as p, type IsolationMergeResult as q, type IsolationOutcome as r, type IsolationPruneResult as s, type IsolationRemoval as t, type IsolationRepo as u, type IsolationRun as v, type IsolationTaskRecord as w, type IsolationTaskRef as x, type IsolationTaskRepo as y, type IsolationTaskStatus as z };
+export { type ResearchStepOutcome as $, type ApprovalRecord as A, BUILTIN_SKILL_NAMES as B, type ConversationMessage as C, DEFAULT_RUNNERS as D, type ExecutionActor as E, type IsolationTaskStatus as F, type GuardTarget as G, type IsolationView as H, type IWorktreeIsolation as I, type PlanIsolation as J, type PlanState as K, type LegacyPlanState as L, type ModelUsage as M, type PlanStatus as N, type PlanUsage as O, type PendingPlanTurn as P, type PlannerUsage as Q, type PrepareIntent as R, type PreparedTask as S, type PreservedWork as T, type PreviousWork as U, type RefusedRemoval as V, type RepairEvidence as W, type RepoGroupLayout as X, type ResearchLogEntry as Y, type ResearchProgress as Z, type ResearchStep as _, type AttemptUsage as a, type ResearchToolType as a0, type RunSettings as a1, type RunnerId as a2, type SetupFailure as a3, type ShadowedSkill as a4, type SkillAppliesTo as a5, type SkillCatalog as a6, type SkillInfo as a7, type SkillLoad as a8, type SkillLoadNotice as a9, createEmptyPlan as aA, createSkillsService as aB, createTask as aC, endAttemptUsage as aD, flattenTasks as aE, flattenTasksWithParents as aF, isAwaitingReason as aG, isMeasured as aH, isSupervisorLevel as aI, isUserMessage as aJ, migratePlanState as aK, partedPromptUsage as aL, pausedOnLimit as aM, planUsage as aN, plannerContextFill as aO, rejoinPlanTree as aP, startAttemptUsage as aQ, usageLine as aR, waitsForApproval as aS, type SkillMetadata as aa, type SkillSource as ab, SkillsService as ac, type SubagentOutcome as ad, type SupervisorLevel as ae, type Task as af, type TaskDiffRead as ag, type TaskDiffResult as ah, type TaskIsolation as ai, type TaskIsolationState as aj, type TaskModelAssignment as ak, type TaskSkillNotice as al, type TaskSkillSnapshot as am, type TaskSnapshot as an, type TaskStatus as ao, type TreeSnapshot as ap, type UsageLine as aq, type UsageRecord as ar, type UsageTotals as as, type Verdict as at, type VerificationCheck as au, addAttemptUsage as av, addModelUsage as aw, addPlannerUsage as ax, addUsage as ay, addUsageTotals as az, type AwaitingReason as b, DEFAULT_SUPERVISOR_RETRY_LIMIT as c, type DiscoveredModel as d, type ExecutionCommandName as e, type ExecutionRecord as f, type GuardTrip as g, type IntegrationDisposal as h, type InvalidSkill as i, type IsolationAvailability as j, type IsolationHandoff as k, type IsolationHandoffRepo as l, type IsolationInactiveReason as m, type IsolationLandedTask as n, type IsolationLanding as o, type IsolationMergeBlock as p, type IsolationMergeBlockReason as q, type IsolationMergeResult as r, type IsolationOutcome as s, type IsolationPruneResult as t, type IsolationRemoval as u, type IsolationRepo as v, type IsolationRun as w, type IsolationTaskRecord as x, type IsolationTaskRef as y, type IsolationTaskRepo as z };

package/dist/{chunk-DNFT4SQG.mjs → chunk-645FALZX.mjs}

@@ -7,10 +7,10 @@ import {
   plannedTask,
   stripTrailingCommas,
   taskWhere
-} from "./chunk-DJAPDO6E.mjs";
+} from "./chunk-A57ITQE7.mjs";
 import {
   flattenTasksWithParents
-} from "./chunk-2IIRSBEQ.mjs";
+} from "./chunk-SM6BV6XS.mjs";
 
 // src/services/PlanValidator.ts
 function parsePlanJson(raw, runners, runnerModes, autonomousDefault = true) {
@@ -27,7 +27,7 @@ function parsePlanJson(raw, runners, runnerModes, autonomousDefault = true) {
   }
   if (matches.length === 0 && sawUnbalanced) {
     throw new PlanParseError(
-      "Plan response appears truncated \u2014 the model likely hit its output length limit before finishing the JSON.",
+      "Plan response appears truncated: the model likely hit its output length limit before finishing the JSON.",
       raw,
       { truncated: true }
     );
@@ -67,7 +67,7 @@ function validatePlanTasks(obj, runners, runnerModes, autonomousDefault = true)
   const ignored = planned.flatMap((p) => p.ignored);
   const warnings = [
     ...ignored.some((i) => i.field === "taskMode") ? [`"taskMode" is not yours to set and was ignored: each task runs in its runner's mode for the user's autonomy level, or its read-only mode when you set "readOnly": true.`] : [],
-    ...ignored.filter((i) => i.field === "readOnly").map((i) => `${i.message} \u2014 it was ignored.`)
+    ...ignored.filter((i) => i.field === "readOnly").map((i) => `${i.message}: it was ignored.`)
   ];
   return warnings.length > 0 ? { ok: true, tasks, warnings } : { ok: true, tasks };
 }
@@ -94,4 +94,4 @@ export {
   validatePlanTasks,
   looksLikePlanAttempt
 };
-//# sourceMappingURL=chunk-DNFT4SQG.mjs.map
+//# sourceMappingURL=chunk-645FALZX.mjs.map

package/dist/chunk-645FALZX.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 = true,\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 = true,\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 = true,\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),\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-DJAPDO6E.mjs → chunk-A57ITQE7.mjs}

@@ -1,4 +1,5 @@
 import {
+  DEFAULT_RUNNERS,
   addTaskToPlan,
   createTask,
   flattenTasks,
@@ -11,7 +12,7 @@ import {
   resolveTaskRef,
   skillNames,
   updateTaskInPlan
-} from "./chunk-2IIRSBEQ.mjs";
+} from "./chunk-SM6BV6XS.mjs";
 
 // src/services/JsonExtractor.ts
 var PLAN_ENVELOPE_KEY = "tasks";
@@ -241,7 +242,7 @@ function plannedMode(runner, runnerModes, { readOnly, current }, autonomousDefau
     const reason2 = unavailableModeReason(modes, taggedReadOnlyMode(modes));
     return {
       ok: false,
-      error: `Runner "${runner}" has no read-only mode${reason2 ? " available on this host" : ""} \u2014 assign a read-only task to ${able.length > 0 ? `one of: ${able.join(", ")}` : "no runner: none of the enabled runners has one"}, or drop "readOnly"${reason2 ? `. ${reason2}` : ""}`
+      error: `Runner "${runner}" has no read-only mode${reason2 ? " available on this host" : ""}: assign a read-only task to ${able.length > 0 ? `one of: ${able.join(", ")}` : "no runner: none of the enabled runners has one"}, or drop "readOnly"${reason2 ? `. ${reason2}` : ""}`
     };
   }
   const keep = current !== void 0 && modes.some((m) => m.id === current) && !(readOnly === false && current === taggedReadOnlyMode(modes));
@@ -300,6 +301,7 @@ function blockedByLabel(refs) {
 function skippedLabel(reason) {
   return reason ? `Skipped: ${reason}` : "Skipped";
 }
+var WAITS_FOR_APPROVAL_LABEL = "Waiting for your approval to start";
 function approvalLabel(count) {
   if (!count) return null;
   return count > 1 ? `Waiting for approval (${count})` : "Waiting for approval";
@@ -315,6 +317,9 @@ function resumeLabel(task, now = /* @__PURE__ */ new Date()) {
   return Number.isNaN(at.getTime()) ? null : `Resumes at ${resumeTime(at, now)}`;
 }
 
+// src/services/TaskOps.ts
+import { v4 as uuidv42 } from "uuid";
+
 // src/services/ModelAllowlistResolver.ts
 function effectiveAllowlist(allowlist, runner, modelsByRunner) {
   if (!allowlist || allowlist.length === 0) return void 0;
@@ -422,9 +427,9 @@ function coerceAssignments(tasks, perRunnerAllowlist, modelsByRunner) {
 
 // src/services/PlannedTask.ts
 import { v4 as uuidv4 } from "uuid";
-var MODE_NOT_THE_PLANNERS = `"taskMode" is the user's to choose \u2014 set "readOnly": true on a task that must not change files, and leave it out otherwise`;
-var MANUAL_NOT_READ_ONLY = '"readOnly" is for AI tasks \u2014 a manual task runs in no mode';
-var OPS_NOT_READ_ONLY = `"readOnly" is not for an ops task \u2014 it runs commands, in the session's mode, and a read-only mode refuses them`;
+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`;
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -432,8 +437,8 @@ function text(value) {
   return typeof value === "string" || typeof value === "number" ? String(value) : void 0;
 }
 function opsPlacementRefusal(type, isSubtask) {
-  if (type !== "ai") return "is a manual task \u2014 only an AI task can be an ops task";
-  if (isSubtask) return "is a subtask, which runs with its parent \u2014 only a top-level task can be an ops task";
+  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;
 }
 function taskWhere(title, parentTitle) {
@@ -457,7 +462,7 @@ function modelOf(raw, from) {
 }
 function plannedTask(spec, catalog, at = {}) {
   const raw = isRecord(spec) ? spec : {};
-  const { parent, from, freshIds } = at;
+  const { parent, from, freshIds, newId = uuidv4 } = at;
   const base = from?.fields ?? {};
   const errors = [];
   const ignored = [];
@@ -465,11 +470,11 @@ function plannedTask(spec, catalog, at = {}) {
   const title = text(raw.title) ?? "";
   const where = taskWhere(title, parent?.title);
   const plannerId = text(raw.id);
-  const id = freshIds || !plannerId ? uuidv4() : plannerId;
+  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 ai = type === "ai";
-  const assignedRunner = text(raw.assignedRunner) ?? base.assignedRunner ?? catalog.runners[0] ?? "claude-code";
+  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}` });
@@ -496,7 +501,7 @@ function plannedTask(spec, catalog, at = {}) {
   const subtasks = [];
   if (Array.isArray(raw.subtasks)) {
     for (const s of raw.subtasks) {
-      const child = plannedTask(s, catalog, { parent: { title, sliceType, autonomy, readOnly }, freshIds });
+      const child = plannedTask(s, catalog, { parent: { title, sliceType, autonomy, readOnly }, freshIds, newId });
       subtasks.push(child.task);
       errors.push(...child.errors);
       ignored.push(...child.ignored);
@@ -608,7 +613,7 @@ function checkModelAndModeValidity(runner, assignedModel, taskMode, catalog) {
   if (taskMode !== void 0) {
     const modes = catalog.runnerModes[runner];
     if (modes && modes.length > 0 && !modes.some((m) => m.id === taskMode)) {
-      return { ok: false, error: `Runner "${runner}" has no task mode "${taskMode}" \u2014 valid modes: ${modes.map((m) => m.id).join(", ")}` };
+      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}` };
@@ -619,7 +624,7 @@ function typeCoherenceCheck(target, changes) {
   if (!changes.type || changes.type === target.type) return null;
   if (changes.type === "user") {
     if (!Array.isArray(changes.userSteps) || changes.userSteps.length === 0) {
-      return { ok: false, error: `"${target.title}" cannot become a manual task without user steps \u2014 include "userSteps" in this edit` };
+      return { ok: false, error: `"${target.title}" cannot become a manual task without user steps: include "userSteps" in this edit` };
     }
     return {
       ok: true,
@@ -629,7 +634,7 @@ function typeCoherenceCheck(target, changes) {
     };
   }
   if (!changes.prompt || !changes.prompt.trim()) {
-    return { ok: false, error: `"${target.title}" cannot become an AI task without a prompt \u2014 include "prompt" in this edit` };
+    return { ok: false, error: `"${target.title}" cannot become an AI task without a prompt: include "prompt" in this edit` };
   }
   return { ok: true, clear: target.userSteps && target.userSteps.length > 0 ? ["userSteps"] : [] };
 }
@@ -879,6 +884,17 @@ function changedFields(target, changes, catalog) {
   if ("taskMode" in changes && isReadOnly({ ...target, ...changes }, catalog) !== isReadOnly(target, catalog)) fields.push("readOnly");
   return fields;
 }
+var keptIds = /* @__PURE__ */ new WeakMap();
+function idsOf(op) {
+  if (typeof op !== "object" || op === null) return uuidv42;
+  const ids = keptIds.get(op) ?? [];
+  keptIds.set(op, ids);
+  let next = 0;
+  return () => {
+    if (next === ids.length) ids.push(uuidv42());
+    return ids[next++];
+  };
+}
 function applyTaskOps(currentTasks, newOps, runners, catalog, held = []) {
   const ops = [...held, ...newOps];
   const opLabel = (i) => i < held.length ? `earlier op ${i + 1} (${ops[i].op})` : `op ${i - held.length + 1} (${ops[i].op})`;
@@ -994,6 +1010,7 @@ function applyTaskOps(currentTasks, newOps, runners, catalog, held = []) {
   let lastLabel = opLabel(0);
   for (const [i, op] of ops.entries()) {
     const label = opLabel(i);
+    const newId = idsOf(op);
     switch (op.op) {
       case "update": {
         const prep = prepareEdit(op, i, label, "planner");
@@ -1023,7 +1040,7 @@ function applyTaskOps(currentTasks, newOps, runners, catalog, held = []) {
           errors.push(`${label}: new task needs a title`);
           break;
         }
-        const planned = plannedTask(spec, intake, { freshIds: true });
+        const planned = plannedTask(spec, intake, { freshIds: true, newId });
         const refused = refusalOf(planned);
         if (refused) {
           errors.push(`${label}: ${refused}`);
@@ -1119,6 +1136,7 @@ function applyTaskOps(currentTasks, newOps, runners, catalog, held = []) {
         const stories = [...new Set(toMerge.flatMap((t) => t.userStoriesCovered ?? []))];
         const planned = plannedTask(spec, intake, {
           freshIds: true,
+          newId,
           from: {
             readOnly: !writes,
             fields: {
@@ -1212,6 +1230,7 @@ function applyTaskOps(currentTasks, newOps, runners, catalog, held = []) {
           }
           const planned = plannedTask(spec, intake, {
             freshIds: true,
+            newId,
             from: {
               readOnly: isReadOnly(target, catalog),
               fields: {
@@ -1302,7 +1321,7 @@ function applyTaskOps(currentTasks, newOps, runners, catalog, held = []) {
       tasks = renumberTasks(repaired.tasks);
     }
   }
-  return errors.length ? { ok: false, tasks: currentTasks, errors, summary: [] } : { ok: true, tasks, errors: [], summary };
+  return errors.length ? { ok: false, tasks: currentTasks, errors, summary: [] } : { ok: true, tasks, errors: [], summary, handles: handleId };
 }
 
 export {
@@ -1316,10 +1335,6 @@ export {
   extractJsonObject,
   stripTrailingCommas,
   escapeControlCharsInStrings,
-  effectiveAllowlist,
-  filterModelsForPrompt,
-  clampThinkingEffort,
-  coerceAssignments,
   runnerModesFrom,
   resolveDefaultMode,
   autonomyLevelLabel,
@@ -1330,12 +1345,17 @@ export {
   unavailableTaskModeMessage,
   carryPlannedModes,
   readOnlyRunners,
+  effectiveAllowlist,
+  filterModelsForPrompt,
+  clampThinkingEffort,
+  coerceAssignments,
   isTaskRunning,
   NOT_STARTED,
   taskStatusKind,
   awaitingLabel,
   blockedByLabel,
   skippedLabel,
+  WAITS_FOR_APPROVAL_LABEL,
   approvalLabel,
   resumeTime,
   resumeLabel,
@@ -1355,4 +1375,4 @@ export {
   canSplitTask,
   applyTaskOps
 };
-//# sourceMappingURL=chunk-DJAPDO6E.mjs.map
+//# sourceMappingURL=chunk-A57ITQE7.mjs.map