harnery 0.16.0 → 0.18.0

package/src/core/supervisor/read.ts

@@ -1,3 +1,19 @@
+export { readSupervisorPlan, readSupervisorPlans } from "./plan-read.ts";
+export {
+  SUPERVISOR_PLAN_SCHEMA_VERSION,
+  type SupervisorPlanEvent,
+  type SupervisorPlanEventType,
+  type SupervisorPlanHistory,
+  type SupervisorPlanMilestone,
+  type SupervisorPlanOutcome,
+  type SupervisorPlanProposal,
+  type SupervisorPlanRecord,
+  type SupervisorPlanRequest,
+  type SupervisorPlanStatus,
+  type SupervisorPlanTemplate,
+  type SupervisorPlanWorkSpec,
+  type SupervisorReplanningPolicy,
+} from "./plan-types.ts";
 export type {
   SupervisorServiceConfig,
   SupervisorServiceGoalRuntime,
@@ -22,6 +38,7 @@ export {
   type SupervisorAutomationPolicy,
   type SupervisorIntent,
   type SupervisorLimits,
+  type SupervisorMission,
   type SupervisorNextAction,
   type SupervisorProjection,
   type SupervisorRecord,

package/src/core/supervisor/runner.ts

@@ -6,6 +6,8 @@ import {
   runWorkItem,
   type WorkRecord,
 } from "../work/index.ts";
+import type { SupervisorPlanOutcome } from "./plan-types.ts";
+import { runSupervisorPlanner } from "./planning.ts";
 import {
   acquireSupervisorLease,
   readSupervisorIgnoringLease,
@@ -40,7 +42,9 @@ export interface SupervisorRunReport {
   cycles: number;
   dispatches: number;
   acceptances: number;
+  replans: number;
   outcomes: SupervisorDispatchOutcome[];
+  plan_outcomes: SupervisorPlanOutcome[];
   projection: SupervisorProjection;
 }
 
@@ -70,7 +74,9 @@ export async function runSupervisor(input: RunSupervisorInput): Promise<Supervis
   let cycles = 0;
   let dispatches = 0;
   let acceptances = 0;
+  let replans = 0;
   const outcomes: SupervisorDispatchOutcome[] = [];
+  const planOutcomes: SupervisorPlanOutcome[] = [];
   try {
     const initial = readSupervisorIgnoringLease(coordRoot, input.goalId);
     const cycleLimit = mode === "tick" ? 1 : initial.intent.limits.max_cycles;
@@ -91,6 +97,39 @@ export async function runSupervisor(input: RunSupervisorInput): Promise<Supervis
 
       const before = graphFingerprint(record);
       let changed = false;
+      if (
+        record.projection.next_action === "replan" ||
+        record.projection.next_action === "plan_initial" ||
+        record.projection.next_action === "plan_milestone"
+      ) {
+        log(
+          `[${record.intent.title}] ${record.projection.next_action} at graph generation ${record.projection.plan_generation}`,
+        );
+        const plan = await runSupervisorPlanner({
+          coordRoot,
+          record,
+          engine: input.engine,
+          actor,
+          onLog: input.onLog,
+        });
+        replans++;
+        planOutcomes.push(plan);
+        record = refreshGraph(coordRoot, input.goalId, actor);
+        if (mode === "tick") {
+          return report(
+            "tick_complete",
+            `planner produced ${plan.status} plan ${plan.plan_id}`,
+            record,
+          );
+        }
+        if (record.projection.state === "succeeded") {
+          return report("succeeded", record.projection.reason, record);
+        }
+        if (record.projection.state !== "ready") {
+          return report(stopForProjection(record.projection), record.projection.reason, record);
+        }
+        continue;
+      }
       if (record.intent.automation.accept_passing_proof) {
         for (const work of record.work) {
           if (work.projection.state !== "in_review") continue;
@@ -206,7 +245,9 @@ export async function runSupervisor(input: RunSupervisorInput): Promise<Supervis
       cycles,
       dispatches,
       acceptances,
+      replans,
       outcomes,
+      plan_outcomes: planOutcomes,
       projection: record.projection,
     };
   }
@@ -255,7 +296,10 @@ function selectWithinAttemptBudget(record: SupervisorRecord, candidates: Candida
 }
 
 function graphFingerprint(record: SupervisorRecord): string {
-  return JSON.stringify(
+  return JSON.stringify([
+    record.projection.root_work_id,
+    record.projection.plan_generation,
+    record.projection.latest_plan_status,
     record.work.map((work) => [
       work.intent.id,
       work.projection.state,
@@ -263,7 +307,7 @@ function graphFingerprint(record: SupervisorRecord): string {
       work.projection.attempts_used,
       work.events.length,
     ]),
-  );
+  ]);
 }
 
 function stopForProjection(projection: SupervisorProjection): SupervisorStopReason {

package/src/core/supervisor/service.ts

@@ -406,6 +406,7 @@ export async function runSupervisorServiceSweep(
         cycles: report.cycles,
         dispatches: report.dispatches,
         acceptances: report.acceptances,
+        replans: report.replans,
       });
       persistRuntime(coordRoot, runtime, completedAt);
     } catch (error) {
@@ -614,6 +615,15 @@ function projectionFingerprint(projection: SupervisorRecord["projection"]): stri
     projection.next_action,
     projection.attempts_used,
     projection.attempts_remaining,
+    projection.root_work_id,
+    projection.root_materialized,
+    projection.plan_generation,
+    projection.replans_used,
+    projection.replans_remaining,
+    projection.milestones_completed,
+    projection.milestones_remaining,
+    projection.pending_plan_id,
+    projection.latest_plan_status,
     projection.ready_work,
     projection.resumable_work,
     projection.retryable_work,

package/src/core/supervisor/state.ts

@@ -12,16 +12,29 @@ import {
   writeFileSync,
 } from "node:fs";
 import { hostname } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { dirname, isAbsolute, join, resolve } from "node:path";
 import { assertWorkId, readWorkItem, type WorkRecord } from "../work/read.ts";
+import { workflowScriptDigest } from "../workflow/run-state.ts";
 import { normalizeWorkflowSpecialists } from "../workflow/specialists.ts";
 import type { WorkflowSpecialistProfile } from "../workflow/types.ts";
+import { readSupervisorPlans } from "./plan-read.ts";
+import {
+  type CreateSupervisorReplanningInput,
+  type SupervisorPlanHistory,
+  type SupervisorPlanRecord,
+  type SupervisorReplanningPolicy,
+  supervisorGraphFingerprint,
+} from "./plan-types.ts";
 
 export const SUPERVISOR_INTENT_SCHEMA_VERSION = 1 as const;
 
 const GOAL_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/;
 const MAX_TITLE = 200;
+const MAX_OBJECTIVE = 4_000;
+const MAX_ACCEPTANCE = 50;
 const MAX_INTENT_BYTES = 256 * 1024;
+const MAX_TEMPLATES = 20;
+const TEMPLATE_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
 const FOREIGN_LEASE_STALE_MS = 24 * 60 * 60 * 1_000;
 
 export interface SupervisorLimits {
@@ -39,6 +52,18 @@ export interface SupervisorAutomationPolicy {
   retry_blocked: boolean;
 }
 
+export interface SupervisorMission {
+  objective: string;
+  acceptance: string[];
+  max_milestones: number;
+}
+
+export interface CreateSupervisorMissionInput {
+  objective: string;
+  acceptance: readonly string[];
+  maxMilestones?: number;
+}
+
 export interface SupervisorIntent {
   schema_version: typeof SUPERVISOR_INTENT_SCHEMA_VERSION;
   id: string;
@@ -47,6 +72,8 @@ export interface SupervisorIntent {
   specialists: Record<string, WorkflowSpecialistProfile>;
   limits: SupervisorLimits;
   automation: SupervisorAutomationPolicy;
+  mission?: SupervisorMission;
+  replanning?: SupervisorReplanningPolicy;
   created_at: string;
 }
 
@@ -64,12 +91,17 @@ export type SupervisorNextAction =
   | "resolve_approval"
   | "review"
   | "retry"
+  | "replan"
+  | "plan_initial"
+  | "plan_milestone"
+  | "review_plan"
   | "none";
 
 export interface SupervisorProjection {
   id: string;
   title: string;
   root_work_id: string;
+  root_materialized: boolean;
   state: SupervisorState;
   reason: string;
   next_action: SupervisorNextAction;
@@ -81,38 +113,77 @@ export interface SupervisorProjection {
   attempts_used: number;
   attempts_remaining: number;
   specialists: string[];
+  plan_generation: number;
+  replans_used: number;
+  replans_remaining: number;
+  milestones_completed: number;
+  milestones_remaining: number;
+  pending_plan_id?: string;
+  latest_plan_status?: SupervisorPlanRecord["status"];
+  governed_work_ids: string[];
 }
 
 export interface SupervisorRecord {
   intent: SupervisorIntent;
   projection: SupervisorProjection;
   work: WorkRecord[];
+  plans: SupervisorPlanRecord[];
 }
 
 export interface CreateSupervisorInput {
   coordRoot: string;
-  rootWorkId: string;
+  rootWorkId?: string;
   specialists: Readonly<Record<string, WorkflowSpecialistProfile>>;
   title?: string;
   id?: string;
   limits?: Partial<SupervisorLimits>;
   automation?: Partial<SupervisorAutomationPolicy>;
+  mission?: CreateSupervisorMissionInput;
+  replanning?: CreateSupervisorReplanningInput;
 }
 
 export function createSupervisor(input: CreateSupervisorInput): SupervisorRecord {
   const coordRoot = resolve(input.coordRoot);
-  assertWorkId(input.rootWorkId);
-  const root = readWorkItem(coordRoot, input.rootWorkId);
   const id = input.id ?? newSupervisorId();
   assertSupervisorId(id);
+  const mission = input.mission ? normalizeMission(input.mission) : undefined;
+  if (mission && !input.replanning) {
+    throw new Error("supervisor mission requires a replanning policy");
+  }
+  if (!input.rootWorkId && !mission) {
+    throw new Error(
+      "supervisor creation without root work requires a mission and replanning policy",
+    );
+  }
+  if (input.rootWorkId) assertWorkId(input.rootWorkId);
+  const root = input.rootWorkId ? readWorkItem(coordRoot, input.rootWorkId) : undefined;
+  const replanning = input.replanning
+    ? normalizeReplanning(input.replanning, input.specialists)
+    : undefined;
+  if (
+    mission &&
+    !input.rootWorkId &&
+    replanning &&
+    replanning.max_replans <= mission.max_milestones
+  ) {
+    throw new Error(
+      "objective-first mission max_replans must exceed max_milestones to reserve completion review",
+    );
+  }
   const intent: SupervisorIntent = {
     schema_version: SUPERVISOR_INTENT_SCHEMA_VERSION,
     id,
-    title: bounded(input.title ?? root.intent.title, "supervisor title", MAX_TITLE),
-    root_work_id: input.rootWorkId,
+    title: bounded(
+      input.title ?? root?.intent.title ?? missionTitle(mission!),
+      "supervisor title",
+      MAX_TITLE,
+    ),
+    root_work_id: input.rootWorkId ?? missionRootId(id),
     specialists: normalizeWorkflowSpecialists(input.specialists),
     limits: normalizeLimits(input.limits),
     automation: normalizeAutomation(input.automation),
+    ...(mission ? { mission } : {}),
+    ...(replanning ? { replanning } : {}),
     created_at: new Date().toISOString(),
   };
   const path = supervisorIntentPath(coordRoot, id);
@@ -221,11 +292,18 @@ function readSupervisorInternal(
 ): SupervisorRecord {
   const coordRoot = resolve(coordRootRaw);
   const intent = readSupervisorIntent(coordRoot, goalId);
-  const work = collectSupervisorWork(coordRoot, intent.root_work_id);
+  const plans = readSupervisorPlans(coordRoot, intent.id, intent.root_work_id);
+  const activeRootExists = workIntentExists(coordRoot, plans.active_root_work_id);
+  if (!activeRootExists && (!intent.mission || plans.generation > 0)) {
+    throw new Error(`supervisor ${intent.id} root work is missing`);
+  }
+  const work = activeRootExists ? collectSupervisorWork(coordRoot, plans.active_root_work_id) : [];
+  const governed = collectGovernedWork(coordRoot, intent.root_work_id, plans, work);
   return {
     intent,
     work,
-    projection: deriveProjection(coordRoot, intent, work, ignoreLease),
+    plans: plans.plans,
+    projection: deriveProjection(coordRoot, intent, work, governed, plans, ignoreLease),
   };
 }
 
@@ -233,11 +311,12 @@ function deriveProjection(
   coordRoot: string,
   intent: SupervisorIntent,
   work: WorkRecord[],
+  governed: WorkRecord[],
+  plans: SupervisorPlanHistory,
   ignoreLease: boolean,
 ): SupervisorProjection {
-  const root = work.find((record) => record.intent.id === intent.root_work_id);
-  if (!root) throw new Error(`supervisor ${intent.id} root work is missing`);
-  const attemptsUsed = work.reduce((sum, record) => sum + record.projection.attempts_used, 0);
+  const root = work.find((record) => record.intent.id === plans.active_root_work_id);
+  const attemptsUsed = governed.reduce((sum, record) => sum + record.projection.attempts_used, 0);
   const readyWork = work
     .filter((record) => record.projection.state === "ready")
     .map((record) => record.intent.id);
@@ -280,10 +359,18 @@ function deriveProjection(
     ...cancelled,
     ...terminalBlocked,
   ]);
+  const initialRootAccepted =
+    intent.mission !== undefined &&
+    governed.some(
+      (record) =>
+        record.intent.id === intent.root_work_id && record.projection.state === "succeeded",
+    );
+  const milestonesCompleted = plans.milestones_completed + (initialRootAccepted ? 1 : 0);
   const base = {
     id: intent.id,
     title: intent.title,
-    root_work_id: intent.root_work_id,
+    root_work_id: plans.active_root_work_id,
+    root_materialized: root !== undefined,
     work_ids: work.map((record) => record.intent.id),
     ready_work: readyWork,
     resumable_work: resumableWork,
@@ -292,6 +379,14 @@ function deriveProjection(
     attempts_used: attemptsUsed,
     attempts_remaining: Math.max(0, intent.limits.max_total_attempts - attemptsUsed),
     specialists: Object.keys(intent.specialists),
+    plan_generation: plans.generation,
+    replans_used: plans.plans.length,
+    replans_remaining: Math.max(0, (intent.replanning?.max_replans ?? 0) - plans.plans.length),
+    milestones_completed: milestonesCompleted,
+    milestones_remaining: Math.max(0, (intent.mission?.max_milestones ?? 0) - milestonesCompleted),
+    pending_plan_id: plans.latest?.status === "proposed" ? plans.latest.request.id : undefined,
+    latest_plan_status: plans.latest?.status,
+    governed_work_ids: governed.map((record) => record.intent.id),
   };
   if (!ignoreLease && supervisorLeaseIsLive(coordRoot, intent.id)) {
     return {
@@ -301,6 +396,88 @@ function deriveProjection(
       next_action: "wait_for_run",
     };
   }
+  if (intent.mission && plans.completed) {
+    return {
+      ...base,
+      state: "succeeded",
+      reason: "mission completion was explicitly accepted",
+      next_action: "none",
+    };
+  }
+  if (plans.latest?.status === "proposed") {
+    return {
+      ...base,
+      state: "awaiting_attention",
+      reason: `replacement plan ${plans.latest.request.id} awaits explicit review`,
+      next_action: "review_plan",
+    };
+  }
+  if (plans.latest?.status === "awaiting_approval") {
+    return {
+      ...base,
+      state: "awaiting_attention",
+      reason: `planner workflow awaits approval ${plans.latest.approval_id}`,
+      next_action: "resolve_approval",
+    };
+  }
+  if (plans.latest?.status === "resumable") {
+    return {
+      ...base,
+      state: "ready",
+      reason: `planner workflow ${plans.latest.request.workflow_run_id} is resumable`,
+      next_action: "replan",
+    };
+  }
+  const triggerFingerprint = supervisorGraphFingerprint({
+    rootWorkId: plans.active_root_work_id,
+    generation: plans.generation,
+    work,
+  });
+  const latestHandledSameGraph =
+    plans.latest?.request.trigger_fingerprint === triggerFingerprint &&
+    plans.latest.request.prior_root_work_id === plans.active_root_work_id &&
+    plans.latest.status === "attention";
+  if (latestHandledSameGraph && plans.latest) {
+    return {
+      ...base,
+      state: "awaiting_attention",
+      reason: plans.latest.reason ?? `plan ${plans.latest.request.id} requires attention`,
+      next_action: "none",
+    };
+  }
+  if (!root && intent.mission) {
+    if (!intent.replanning || plans.plans.length >= intent.replanning.max_replans) {
+      return {
+        ...base,
+        state: "budget_exhausted",
+        reason: "mission exhausted its planning budget before creating an initial milestone",
+        next_action: "none",
+      };
+    }
+    return {
+      ...base,
+      state: "ready",
+      reason: "mission is ready for its initial bounded milestone plan",
+      next_action: "plan_initial",
+    };
+  }
+  if (!root) throw new Error(`supervisor ${intent.id} root work is missing`);
+  if (root.projection.state === "succeeded" && intent.mission) {
+    if (!intent.replanning || plans.plans.length >= intent.replanning.max_replans) {
+      return {
+        ...base,
+        state: "budget_exhausted",
+        reason: "mission exhausted its planning budget at a milestone boundary",
+        next_action: "none",
+      };
+    }
+    return {
+      ...base,
+      state: "ready",
+      reason: `milestone ${plans.milestones_completed} is accepted and requires mission reassessment`,
+      next_action: "plan_milestone",
+    };
+  }
   if (root.projection.state === "succeeded") {
     return {
       ...base,
@@ -379,6 +556,41 @@ function deriveProjection(
       next_action: "retry",
     };
   }
+  if (attemptsUsed >= intent.limits.max_total_attempts && cancelled.length === 0) {
+    return {
+      ...base,
+      state: "budget_exhausted",
+      reason: `goal exhausted its ${intent.limits.max_total_attempts} total attempts`,
+      next_action: "none",
+    };
+  }
+  const canReplan =
+    intent.replanning !== undefined &&
+    plans.plans.length < intent.replanning.max_replans &&
+    cancelled.length === 0 &&
+    !latestHandledSameGraph;
+  if (canReplan) {
+    return {
+      ...base,
+      state: "ready",
+      reason: terminalBlocked.length
+        ? `${terminalBlocked.length} terminally blocked work item${terminalBlocked.length === 1 ? " can" : "s can"} be replanned`
+        : "the active graph has no legal progress action and may be replanned",
+      next_action: "replan",
+    };
+  }
+  if (
+    intent.replanning &&
+    plans.plans.length >= intent.replanning.max_replans &&
+    cancelled.length === 0
+  ) {
+    return {
+      ...base,
+      state: "budget_exhausted",
+      reason: `goal exhausted its ${intent.replanning.max_replans} replans`,
+      next_action: "none",
+    };
+  }
   return {
     ...base,
     state: "blocked",
@@ -418,6 +630,19 @@ function validateIntent(intent: SupervisorIntent, goalId: string): void {
   }
   bounded(intent.title, "supervisor title", MAX_TITLE);
   assertWorkId(intent.root_work_id);
+  if (intent.mission) {
+    const normalizedMission = normalizeMission({
+      objective: intent.mission.objective,
+      acceptance: intent.mission.acceptance,
+      maxMilestones: intent.mission.max_milestones,
+    });
+    if (JSON.stringify(normalizedMission) !== JSON.stringify(intent.mission)) {
+      throw new Error(`supervisor intent ${goalId} mission is not canonical`);
+    }
+    if (!intent.replanning) {
+      throw new Error(`supervisor intent ${goalId} mission requires replanning`);
+    }
+  }
   const specialists = normalizeWorkflowSpecialists(intent.specialists);
   if (JSON.stringify(specialists) !== JSON.stringify(intent.specialists)) {
     throw new Error(`supervisor intent ${goalId} specialists are not canonical`);
@@ -430,6 +655,33 @@ function validateIntent(intent: SupervisorIntent, goalId: string): void {
   ) {
     throw new Error(`supervisor intent ${goalId} automation policy is not canonical`);
   }
+  if (intent.replanning) validateReplanning(intent.replanning, specialists, goalId);
+}
+
+function normalizeMission(input: CreateSupervisorMissionInput): SupervisorMission {
+  if (!Array.isArray(input.acceptance)) {
+    throw new Error("supervisor mission acceptance must be an array");
+  }
+  if (input.acceptance.length < 1 || input.acceptance.length > MAX_ACCEPTANCE) {
+    throw new Error(`supervisor mission acceptance must contain 1 to ${MAX_ACCEPTANCE} criteria`);
+  }
+  const acceptance = input.acceptance.map((criterion, index) =>
+    bounded(criterion, `supervisor mission acceptance[${index}]`, 500),
+  );
+  if (new Set(acceptance).size !== acceptance.length) {
+    throw new Error("supervisor mission acceptance criteria must be unique");
+  }
+  return {
+    objective: bounded(input.objective, "supervisor mission objective", MAX_OBJECTIVE),
+    acceptance,
+    max_milestones: positive(input.maxMilestones ?? 4, "supervisor mission max_milestones", 20),
+  };
+}
+
+function missionTitle(mission: SupervisorMission): string {
+  return mission.objective.length <= MAX_TITLE
+    ? mission.objective
+    : `${mission.objective.slice(0, MAX_TITLE - 1).trimEnd()}…`;
 }
 
 function normalizeLimits(input: Partial<SupervisorLimits> | undefined): SupervisorLimits {
@@ -465,6 +717,131 @@ function normalizeAutomation(
   };
 }
 
+function normalizeReplanning(
+  input: CreateSupervisorReplanningInput,
+  specialistsInput: Readonly<Record<string, WorkflowSpecialistProfile>>,
+): SupervisorReplanningPolicy {
+  const specialists = normalizeWorkflowSpecialists(specialistsInput);
+  const plannerSpecialist = bounded(input.plannerSpecialist, "planner specialist", 100);
+  if (!specialists[plannerSpecialist]) {
+    throw new Error(`planner specialist ${plannerSpecialist} is not present in the frozen team`);
+  }
+  const entries = Object.entries(input.templates);
+  if (entries.length < 1 || entries.length > MAX_TEMPLATES) {
+    throw new Error(`replanning templates must contain 1 to ${MAX_TEMPLATES} entries`);
+  }
+  const templates = Object.fromEntries(
+    entries
+      .sort(([left], [right]) => left.localeCompare(right))
+      .map(([id, template]) => {
+        if (!TEMPLATE_ID.test(id)) throw new Error(`invalid replanning template id ${id}`);
+        const path = resolve(template.workflowPath);
+        if (!existsSync(path))
+          throw new Error(`replanning template ${id} does not exist at ${path}`);
+        const maxAttempts = positive(
+          template.maxAttempts ?? 3,
+          `replanning template ${id} maxAttempts`,
+          100,
+        );
+        return [
+          id,
+          {
+            workflow: { path, sha256: workflowScriptDigest(path) },
+            max_attempts: maxAttempts,
+            root: boolean(template.root ?? false, `replanning template ${id} root`),
+          },
+        ];
+      }),
+  );
+  if (!Object.values(templates).some((template) => template.root)) {
+    throw new Error("replanning requires at least one root-capable template");
+  }
+  const maxWorkItemsPerPlan = positive(
+    input.maxWorkItemsPerPlan ?? 8,
+    "replanning max_work_items_per_plan",
+    25,
+  );
+  const maxTotalWorkItems = positive(
+    input.maxTotalWorkItems ?? 25,
+    "replanning max_total_work_items",
+    100,
+  );
+  if (maxWorkItemsPerPlan > maxTotalWorkItems) {
+    throw new Error("replanning max_work_items_per_plan cannot exceed max_total_work_items");
+  }
+  return {
+    planner_specialist: plannerSpecialist,
+    auto_apply: boolean(input.autoApply ?? false, "replanning auto_apply"),
+    max_replans: positive(input.maxReplans ?? 5, "replanning max_replans", 100),
+    max_work_items_per_plan: maxWorkItemsPerPlan,
+    max_total_work_items: maxTotalWorkItems,
+    templates,
+  };
+}
+
+function validateReplanning(
+  policy: SupervisorReplanningPolicy,
+  specialists: Record<string, WorkflowSpecialistProfile>,
+  goalId: string,
+): void {
+  if (!specialists[policy.planner_specialist]) {
+    throw new Error(`supervisor ${goalId} planner specialist is not in the frozen team`);
+  }
+  boolean(policy.auto_apply, "replanning auto_apply");
+  positive(policy.max_replans, "replanning max_replans", 100);
+  positive(policy.max_work_items_per_plan, "replanning max_work_items_per_plan", 25);
+  positive(policy.max_total_work_items, "replanning max_total_work_items", 100);
+  if (policy.max_work_items_per_plan > policy.max_total_work_items) {
+    throw new Error(`supervisor ${goalId} replanning work-item bounds are inconsistent`);
+  }
+  const entries = Object.entries(policy.templates ?? {});
+  if (entries.length < 1 || entries.length > MAX_TEMPLATES) {
+    throw new Error(`supervisor ${goalId} has invalid replanning templates`);
+  }
+  let rootCapable = false;
+  for (const [id, template] of entries) {
+    if (
+      !TEMPLATE_ID.test(id) ||
+      !isAbsolute(template.workflow?.path) ||
+      !/^[a-f0-9]{64}$/.test(template.workflow?.sha256) ||
+      !Number.isSafeInteger(template.max_attempts) ||
+      template.max_attempts < 1 ||
+      template.max_attempts > 100 ||
+      typeof template.root !== "boolean"
+    ) {
+      throw new Error(`supervisor ${goalId} replanning template ${id} is invalid`);
+    }
+    rootCapable ||= template.root;
+  }
+  if (!rootCapable) throw new Error(`supervisor ${goalId} has no root-capable replanning template`);
+}
+
+function collectGovernedWork(
+  coordRoot: string,
+  originalRootWorkId: string,
+  plans: SupervisorPlanHistory,
+  active: WorkRecord[],
+): WorkRecord[] {
+  const governed = new Map<string, WorkRecord>();
+  if (workIntentExists(coordRoot, originalRootWorkId)) {
+    for (const record of collectSupervisorWork(coordRoot, originalRootWorkId)) {
+      governed.set(record.intent.id, record);
+    }
+  }
+  for (const workId of plans.applied_work_ids)
+    governed.set(workId, readWorkItem(coordRoot, workId));
+  for (const record of active) governed.set(record.intent.id, record);
+  return [...governed.values()];
+}
+
+function workIntentExists(coordRoot: string, workId: string): boolean {
+  return existsSync(join(resolve(coordRoot), ".harnery", "work", workId, "intent.json"));
+}
+
+function missionRootId(goalId: string): string {
+  return `${goalId.slice(0, 87)}-mission-root`;
+}
+
 function supervisorDir(coordRoot: string, goalId: string): string {
   assertSupervisorId(goalId);
   return join(resolve(coordRoot), ".harnery", "supervisors", goalId);