harnery 0.30.0 → 0.31.1

package/dist/core/{supervisor → governor}/state.js

@@ -5,9 +5,9 @@ import { dirname, isAbsolute, join, resolve } from "node:path";
 import { assertWorkId, readWorkItem } from "../work/read.js";
 import { workflowScriptDigest } from "../workflow/run-state.js";
 import { normalizeWorkflowSpecialists } from "../workflow/specialists.js";
-import { readSupervisorPlans } from "./plan-read.js";
-import { MAX_SUPERVISOR_PLAN_REVIEWERS, MAX_SUPERVISOR_PLAN_REVISION_ROUNDS, supervisorGraphFingerprint, } from "./plan-types.js";
-export const SUPERVISOR_INTENT_SCHEMA_VERSION = 1;
+import { readGovernorPlans } from "./plan-read.js";
+import { governorGraphFingerprint, MAX_GOVERNOR_PLAN_REVIEWERS, MAX_GOVERNOR_PLAN_REVISION_ROUNDS, } from "./plan-types.js";
+export const GOVERNOR_INTENT_SCHEMA_VERSION = 1;
 const GOAL_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/;
 const MAX_TITLE = 200;
 const MAX_OBJECTIVE = 4_000;
@@ -23,16 +23,16 @@ const FOREIGN_LEASE_STALE_MS = 24 * 60 * 60 * 1_000;
  * rather than a policy field to keep the frozen replanning schema unchanged; an
  * environment failure self-bounds at one because it stops immediately. */
 const MAX_UNCHARGED_REPLANS = 3;
-export function createSupervisor(input) {
+export function createGovernor(input) {
     const coordRoot = resolve(input.coordRoot);
-    const id = input.id ?? newSupervisorId();
-    assertSupervisorId(id);
+    const id = input.id ?? newGovernorId();
+    assertGovernorId(id);
     const mission = input.mission ? normalizeMission(input.mission) : undefined;
     if (mission && !input.replanning) {
-        throw new Error("supervisor mission requires a replanning policy");
+        throw new Error("governor mission requires a replanning policy");
     }
     if (!input.rootWorkId && !mission) {
-        throw new Error("supervisor creation without root work requires a mission and replanning policy");
+        throw new Error("governor creation without root work requires a mission and replanning policy");
     }
     if (input.rootWorkId)
         assertWorkId(input.rootWorkId);
@@ -48,9 +48,9 @@ export function createSupervisor(input) {
         throw new Error("objective-first mission max_replans must exceed max_milestones to reserve completion review");
     }
     const intent = {
-        schema_version: SUPERVISOR_INTENT_SCHEMA_VERSION,
+        schema_version: GOVERNOR_INTENT_SCHEMA_VERSION,
         id,
-        title: bounded(input.title ?? root?.intent.title ?? missionTitle(mission), "supervisor title", MAX_TITLE),
+        title: bounded(input.title ?? root?.intent.title ?? missionTitle(mission), "governor title", MAX_TITLE),
         root_work_id: input.rootWorkId ?? missionRootId(id),
         specialists: normalizeWorkflowSpecialists(input.specialists),
         limits,
@@ -59,39 +59,39 @@ export function createSupervisor(input) {
         ...(replanning ? { replanning } : {}),
         created_at: new Date().toISOString(),
     };
-    const path = supervisorIntentPath(coordRoot, id);
+    const path = governorIntentPath(coordRoot, id);
     mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
     chmodSync(dirname(path), 0o700);
     writePrivateJson(path, intent);
-    return readSupervisor(coordRoot, id);
+    return readGovernor(coordRoot, id);
 }
-export function readSupervisor(coordRoot, goalId) {
-    return readSupervisorInternal(coordRoot, goalId, false);
+export function readGovernor(coordRoot, goalId) {
+    return readGovernorInternal(coordRoot, goalId, false);
 }
-/** @internal Runner seam; ignores the lease held by this supervisor process. */
-export function readSupervisorIgnoringLease(coordRoot, goalId) {
-    return readSupervisorInternal(coordRoot, goalId, true);
+/** @internal Runner seam; ignores the lease held by this governor process. */
+export function readGovernorIgnoringLease(coordRoot, goalId) {
+    return readGovernorInternal(coordRoot, goalId, true);
 }
-export function listSupervisors(coordRoot) {
-    const base = join(resolve(coordRoot), ".harnery", "supervisors");
+export function listGovernors(coordRoot) {
+    const base = join(resolve(coordRoot), ".harnery", "governors");
     if (!existsSync(base))
         return [];
     const records = [];
     for (const name of readdirSync(base)) {
-        if (!GOAL_ID.test(name) || !existsSync(supervisorIntentPath(coordRoot, name)))
+        if (!GOAL_ID.test(name) || !existsSync(governorIntentPath(coordRoot, name)))
             continue;
-        records.push(readSupervisor(coordRoot, name));
+        records.push(readGovernor(coordRoot, name));
     }
     return records.sort((left, right) => right.intent.created_at.localeCompare(left.intent.created_at));
 }
-export function collectSupervisorWork(coordRoot, rootWorkId) {
+export function collectGovernorWork(coordRoot, rootWorkId) {
     const records = new Map();
     const visiting = new Set();
     const visit = (workId) => {
         if (records.has(workId))
             return;
         if (visiting.has(workId))
-            throw new Error(`supervisor work graph contains a cycle at ${workId}`);
+            throw new Error(`governor work graph contains a cycle at ${workId}`);
         visiting.add(workId);
         const record = readWorkItem(coordRoot, workId);
         for (const dependency of record.intent.dependencies)
@@ -102,17 +102,17 @@ export function collectSupervisorWork(coordRoot, rootWorkId) {
     visit(rootWorkId);
     return Array.from(records.values());
 }
-export function assertSupervisorId(goalId) {
+export function assertGovernorId(goalId) {
     if (!GOAL_ID.test(goalId))
-        throw new Error(`invalid supervisor id ${JSON.stringify(goalId)}`);
+        throw new Error(`invalid governor id ${JSON.stringify(goalId)}`);
 }
-export function newSupervisorId() {
+export function newGovernorId() {
     return `goal-${new Date().toISOString().replace(/[:.]/g, "-")}-${randomBytes(3).toString("hex")}`;
 }
-/** @internal Runner seam; one exclusive crash-recoverable supervisor lease. */
-export function acquireSupervisorLease(coordRoot, goalId) {
-    readSupervisorIntent(coordRoot, goalId);
-    const path = join(supervisorDir(coordRoot, goalId), "lease.json");
+/** @internal Runner seam; one exclusive crash-recoverable governor lease. */
+export function acquireGovernorLease(coordRoot, goalId) {
+    readGovernorIntent(coordRoot, goalId);
+    const path = join(governorDir(coordRoot, goalId), "lease.json");
     const owner = {
         pid: process.pid,
         host: hostname(),
@@ -140,11 +140,11 @@ export function acquireSupervisorLease(coordRoot, goalId) {
     if (!acquire()) {
         const existing = readLease(path);
         if (existing && leaseIsLive(existing)) {
-            throw new Error(`supervisor ${goalId} is already running under pid ${existing.pid} on ${existing.host}`);
+            throw new Error(`governor ${goalId} is already running under pid ${existing.pid} on ${existing.host}`);
         }
         unlinkSync(path);
         if (!acquire())
-            throw new Error(`supervisor ${goalId} lease raced with another process`);
+            throw new Error(`governor ${goalId} lease raced with another process`);
     }
     return () => {
         try {
@@ -157,15 +157,15 @@ export function acquireSupervisorLease(coordRoot, goalId) {
         }
     };
 }
-function readSupervisorInternal(coordRootRaw, goalId, ignoreLease) {
+function readGovernorInternal(coordRootRaw, goalId, ignoreLease) {
     const coordRoot = resolve(coordRootRaw);
-    const intent = readSupervisorIntent(coordRoot, goalId);
-    const plans = readSupervisorPlans(coordRoot, intent.id, intent.root_work_id);
+    const intent = readGovernorIntent(coordRoot, goalId);
+    const plans = readGovernorPlans(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`);
+        throw new Error(`governor ${intent.id} root work is missing`);
     }
-    const work = activeRootExists ? collectSupervisorWork(coordRoot, plans.active_root_work_id) : [];
+    const work = activeRootExists ? collectGovernorWork(coordRoot, plans.active_root_work_id) : [];
     const governed = collectGovernedWork(coordRoot, intent.root_work_id, plans, work);
     return {
         intent,
@@ -184,8 +184,13 @@ function deriveProjection(coordRoot, intent, work, governed, plans, ignoreLease)
     // Replans, like per-item attempts (ADR 0046), are budgeted by the CHARGED
     // count: an uncharged planner failure (environment/upstream) does not spend
     // max_replans. replans_used stays the raw count for display.
-    const unchargedReplans = plans.plans.filter((plan) => plan.status === "failed" && (plan.class === "environment" || plan.class === "upstream")).length;
+    const unchargedReplans = plans.plans.filter((plan) => plan.status === "failed" && isUnchargedPlanClass(plan.class)).length;
     const chargedReplans = plans.plans.length - unchargedReplans;
+    // Attribute the consumed replans that did not advance the graph so the
+    // projection can distinguish planner no-proposal exhaustion from reviewer
+    // rejection through existing plan seams (review receipt presence), rather than
+    // reporting both as a single undifferentiated replan exhaustion.
+    const replanConsumption = classifyReplanConsumption(plans);
     const readyWork = work
         .filter((record) => record.projection.state === "ready")
         .map((record) => record.intent.id);
@@ -209,6 +214,15 @@ function deriveProjection(coordRoot, intent, work, governed, plans, ignoreLease)
     const terminalBlocked = work
         .filter((record) => record.projection.state === "blocked" && record.projection.next_action === "none")
         .map((record) => record.intent.id);
+    // Work stopped on a person, kept apart from the rest of terminalBlocked. Every
+    // other terminal block is something an agent could in principle clear; this one
+    // can only be cleared by a ruling, so it is the thing worth saying out loud.
+    const decisionBlocked = work
+        .filter((record) => record.projection.blocked_on_decision !== undefined)
+        .map((record) => ({
+        work_id: record.intent.id,
+        decision_id: record.projection.blocked_on_decision || undefined,
+    }));
     const attentionWork = unique([
         ...pendingApproval,
         ...(intent.automation.accept_passing_proof ? [] : reviews),
@@ -220,6 +234,12 @@ function deriveProjection(coordRoot, intent, work, governed, plans, ignoreLease)
     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 resumableDispatchable = intent.automation.resume_approved ? resumableWork : [];
+    const attemptDispatchable = [
+        ...readyWork,
+        ...(intent.automation.retry_blocked ? retryableWork : []),
+    ];
+    const dispatchable = [...resumableDispatchable, ...attemptDispatchable];
     const base = {
         id: intent.id,
         title: intent.title,
@@ -230,6 +250,7 @@ function deriveProjection(coordRoot, intent, work, governed, plans, ignoreLease)
         resumable_work: resumableWork,
         retryable_work: retryableWork,
         attention_work: attentionWork,
+        decision_blocked_work: decisionBlocked,
         attempts_used: attemptsUsed,
         attempts_remaining: Math.max(0, intent.limits.max_total_attempts - chargedUsed),
         specialists: Object.keys(intent.specialists),
@@ -240,13 +261,14 @@ function deriveProjection(coordRoot, intent, work, governed, plans, ignoreLease)
         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,
+        ...(replanConsumption.planner_no_proposal > 0 ? { replan_consumption: replanConsumption } : {}),
         governed_work_ids: governed.map((record) => record.intent.id),
     };
-    if (!ignoreLease && supervisorLeaseIsLive(coordRoot, intent.id)) {
+    if (!ignoreLease && governorLeaseIsLive(coordRoot, intent.id)) {
         return {
             ...base,
             state: "running",
-            reason: "the foreground supervisor holds the goal lease",
+            reason: "the foreground governor holds the goal lease",
             next_action: "wait_for_run",
         };
     }
@@ -258,6 +280,19 @@ function deriveProjection(coordRoot, intent, work, governed, plans, ignoreLease)
             next_action: "none",
         };
     }
+    // ADR 0050: a mission whose completion was reopened dispatches the reopened work
+    // before anything else. Without this the goal falls through to the milestone
+    // branch below, which still sees a succeeded root when the reopened item is one
+    // of its children, and would spend a replan reassessing a mission whose real
+    // remaining work is already sitting in ready_work.
+    if (intent.mission && plans.latest?.status === "reopened" && dispatchable.length > 0) {
+        return {
+            ...base,
+            state: "ready",
+            reason: `mission completion was reopened; ${dispatchable.length} work item${dispatchable.length === 1 ? " is" : "s are"} dispatchable`,
+            next_action: "run",
+        };
+    }
     if (plans.latest?.status === "proposed") {
         return {
             ...base,
@@ -298,6 +333,17 @@ function deriveProjection(coordRoot, intent, work, governed, plans, ignoreLease)
             next_action: "none",
         };
     }
+    if (plans.latest?.status === "failed" && plans.latest.class === "decision") {
+        // The planner concluded that a human must rule before this can be planned.
+        // Stop and say so. Replanning would re-ask a question the planner already
+        // answered correctly, which is how a goal spins without a person noticing.
+        return {
+            ...base,
+            state: "blocked",
+            reason: `planning is waiting on a human decision: ${plans.latest.reason ?? "the planner did not say which"}`,
+            next_action: "none",
+        };
+    }
     if (plans.latest?.status === "failed" && plans.latest.class === "upstream") {
         // The vendor refused. Uncharged replans do not spend max_replans, so the
         // only brake on an unending outage is this consecutive bound; at the limit
@@ -305,7 +351,7 @@ function deriveProjection(coordRoot, intent, work, governed, plans, ignoreLease)
         let trailingUncharged = 0;
         for (let index = plans.plans.length - 1; index >= 0; index--) {
             const plan = plans.plans[index];
-            if (plan.status !== "failed" || (plan.class !== "environment" && plan.class !== "upstream")) {
+            if (plan.status !== "failed" || !isUnchargedPlanClass(plan.class)) {
                 break;
             }
             trailingUncharged++;
@@ -322,7 +368,7 @@ function deriveProjection(coordRoot, intent, work, governed, plans, ignoreLease)
         // dispatchable — the vendor may have recovered. canReplan reads
         // chargedReplans, so these uncharged attempts do not exhaust max_replans.
     }
-    const triggerFingerprint = supervisorGraphFingerprint({
+    const triggerFingerprint = governorGraphFingerprint({
         rootWorkId: plans.active_root_work_id,
         generation: plans.generation,
         work,
@@ -331,12 +377,15 @@ function deriveProjection(coordRoot, intent, work, governed, plans, ignoreLease)
         plans.latest.request.prior_root_work_id === plans.active_root_work_id &&
         plans.latest.status === "attention";
     if (latestHandledSameGraph && plans.latest) {
+        const canRetry = intent.replanning !== undefined && chargedReplans < intent.replanning.max_replans;
         return {
             ...base,
             state: "awaiting_attention",
-            reason: plans.latest.reason ?? `plan ${plans.latest.request.id} requires attention`,
+            reason: canRetry
+                ? (plans.latest.reason ?? `plan ${plans.latest.request.id} requires attention`)
+                : exhaustedAttentionReason(plans.latest, replanConsumption),
             attention_plan_id: plans.latest.request.id,
-            next_action: intent.replanning && chargedReplans < intent.replanning.max_replans ? "retry_plan" : "none",
+            next_action: canRetry ? "retry_plan" : "none",
         };
     }
     if (!root && intent.mission) {
@@ -344,7 +393,7 @@ function deriveProjection(coordRoot, intent, work, governed, plans, ignoreLease)
             return {
                 ...base,
                 state: "budget_exhausted",
-                reason: "mission exhausted its planning budget before creating an initial milestone",
+                reason: replanBudgetReason("mission exhausted its planning budget before creating an initial milestone", replanConsumption),
                 next_action: "none",
             };
         }
@@ -356,13 +405,13 @@ function deriveProjection(coordRoot, intent, work, governed, plans, ignoreLease)
         };
     }
     if (!root)
-        throw new Error(`supervisor ${intent.id} root work is missing`);
+        throw new Error(`governor ${intent.id} root work is missing`);
     if (root.projection.state === "succeeded" && intent.mission) {
         if (!intent.replanning || chargedReplans >= intent.replanning.max_replans) {
             return {
                 ...base,
                 state: "budget_exhausted",
-                reason: "mission exhausted its planning budget at a milestone boundary",
+                reason: replanBudgetReason("mission exhausted its planning budget at a milestone boundary", replanConsumption),
                 next_action: "none",
             };
         }
@@ -381,12 +430,6 @@ function deriveProjection(coordRoot, intent, work, governed, plans, ignoreLease)
             next_action: "none",
         };
     }
-    const resumableDispatchable = intent.automation.resume_approved ? resumableWork : [];
-    const attemptDispatchable = [
-        ...readyWork,
-        ...(intent.automation.retry_blocked ? retryableWork : []),
-    ];
-    const dispatchable = [...resumableDispatchable, ...attemptDispatchable];
     if (intent.automation.accept_passing_proof && reviews.length > 0) {
         return {
             ...base,
@@ -479,45 +522,122 @@ function deriveProjection(coordRoot, intent, work, governed, plans, ignoreLease)
         return {
             ...base,
             state: "budget_exhausted",
-            reason: `goal exhausted its ${intent.replanning.max_replans} replans`,
+            reason: replanBudgetReason(`goal exhausted its ${intent.replanning.max_replans} replans`, replanConsumption),
             next_action: "none",
         };
     }
     return {
         ...base,
         state: "blocked",
-        reason: attentionWork.length > 0
-            ? `${attentionWork.length} work item${attentionWork.length === 1 ? " needs" : "s need"} intervention`
-            : "goal graph has no legal progress action",
+        // Lead with the decisions when there are any. "3 work items need
+        // intervention" reads as a queue an agent will get to; "waiting on you to
+        // rule on X" is the only phrasing that reaches the person who can clear it.
+        reason: decisionBlocked.length > 0
+            ? `${decisionBlocked.length} work item${decisionBlocked.length === 1 ? " is" : "s are"} waiting on a human decision: ${describeDecisionBlocks(decisionBlocked)}`
+            : attentionWork.length > 0
+                ? `${attentionWork.length} work item${attentionWork.length === 1 ? " needs" : "s need"} intervention`
+                : "goal graph has no legal progress action",
         next_action: "none",
     };
 }
-function readSupervisorIntent(coordRoot, goalId) {
-    assertSupervisorId(goalId);
-    const path = supervisorIntentPath(coordRoot, goalId);
+/** Bounded, operator-readable list of what is waiting on a ruling. */
+function describeDecisionBlocks(blocks) {
+    const shown = blocks
+        .slice(0, 3)
+        .map((b) => (b.decision_id ? `${b.work_id} (${b.decision_id})` : b.work_id))
+        .join(", ");
+    return blocks.length > 3 ? `${shown}, +${blocks.length - 3} more` : shown;
+}
+/**
+ * Classify each consumed replan that did not advance the graph, using existing
+ * plan seams only. A plan carries a review receipt exactly when a proposal was
+ * produced and independently reviewed, so its presence separates a reviewer
+ * rejection from a planner run that produced no reviewable proposal. Uncharged
+ * environment/upstream planner failures (ADR 0046) do not spend the replan
+ * budget and are attributed to their outside precondition, not counted here.
+ */
+/** Whether a failed plan told us nothing about the plan, and so must not spend
+ * a replan (ADR 0046). All three classes mean "replanning this cannot help":
+ * the binary is missing, the vendor is down, or a person has to rule. */
+function isUnchargedPlanClass(value) {
+    return value === "environment" || value === "upstream" || value === "decision";
+}
+function classifyReplanConsumption(plans) {
+    let reviewerRejection = 0;
+    let plannerNoProposal = 0;
+    for (const plan of plans.plans) {
+        if (plan.status === "failed" && isUnchargedPlanClass(plan.class)) {
+            continue;
+        }
+        if (plan.review && plan.review.status !== "passed") {
+            reviewerRejection++;
+        }
+        else if (!plan.review &&
+            (plan.status === "attention" ||
+                plan.status === "interrupted" ||
+                plan.status === "failed" ||
+                plan.status === "retry_requested")) {
+            // `retry_requested` is a planner no-proposal attention the operator asked to
+            // replan: the original run still produced no reviewable proposal and still
+            // spent a charged replan, so it belongs in this bucket even though a later
+            // plan superseded it. Omitting it would misattribute a retried no-proposal
+            // to nothing and let the reason read as pure review exhaustion.
+            plannerNoProposal++;
+        }
+    }
+    return { reviewer_rejection: reviewerRejection, planner_no_proposal: plannerNoProposal };
+}
+/**
+ * Reason for a goal held at `awaiting_attention/none` because its latest plan is
+ * an unresolved attention and no replan slot remains. The latest plan's own
+ * per-plan reason always leads (a reviewed-and-rejected latest reports its
+ * review-round exhaustion verbatim), then `replanBudgetReason` names the planner
+ * no-proposal share of the consumed budget. This keeps the `projection.reason`
+ * field carrying the same truth the operator-visible row does: a goal whose
+ * budget was mostly spent by planner no-proposal runs is not attributed wholesale
+ * to review just because its final, reviewed plan happened to be rejected.
+ */
+function exhaustedAttentionReason(latest, consumption) {
+    const fallback = latest.reason ?? `plan ${latest.request.id} requires attention`;
+    return replanBudgetReason(fallback, consumption);
+}
+/**
+ * Append planner no-proposal attribution to a replan-exhaustion reason. Returns
+ * the base reason unchanged when no consumed replan was a planner no-proposal
+ * outcome, so goals without that history project exactly as before.
+ */
+function replanBudgetReason(base, consumption) {
+    if (consumption.planner_no_proposal <= 0)
+        return base;
+    const count = consumption.planner_no_proposal;
+    return `${base}; ${count} replan${count === 1 ? "" : "s"} ended with the planner producing no proposal`;
+}
+function readGovernorIntent(coordRoot, goalId) {
+    assertGovernorId(goalId);
+    const path = governorIntentPath(coordRoot, goalId);
     if (!existsSync(path))
-        throw new Error(`supervisor ${goalId} does not exist`);
+        throw new Error(`governor ${goalId} does not exist`);
     const size = statSync(path).size;
     if (size <= 0 || size > MAX_INTENT_BYTES) {
-        throw new Error(`supervisor intent has invalid size ${size}`);
+        throw new Error(`governor intent has invalid size ${size}`);
     }
     let intent;
     try {
         intent = JSON.parse(readFileSync(path, "utf8"));
     }
     catch (error) {
-        throw new Error(`cannot parse supervisor intent ${goalId}: ${error.message}`);
+        throw new Error(`cannot parse governor intent ${goalId}: ${error.message}`);
     }
     validateIntent(intent, goalId);
     return intent;
 }
 function validateIntent(intent, goalId) {
-    if (intent.schema_version !== SUPERVISOR_INTENT_SCHEMA_VERSION ||
+    if (intent.schema_version !== GOVERNOR_INTENT_SCHEMA_VERSION ||
         intent.id !== goalId ||
         !validTimestamp(intent.created_at)) {
-        throw new Error(`supervisor intent ${goalId} has an unsupported or mismatched schema`);
+        throw new Error(`governor intent ${goalId} has an unsupported or mismatched schema`);
     }
-    bounded(intent.title, "supervisor title", MAX_TITLE);
+    bounded(intent.title, "governor title", MAX_TITLE);
     assertWorkId(intent.root_work_id);
     if (intent.mission) {
         const normalizedMission = normalizeMission({
@@ -526,40 +646,40 @@ function validateIntent(intent, goalId) {
             maxMilestones: intent.mission.max_milestones,
         });
         if (JSON.stringify(normalizedMission) !== JSON.stringify(intent.mission)) {
-            throw new Error(`supervisor intent ${goalId} mission is not canonical`);
+            throw new Error(`governor intent ${goalId} mission is not canonical`);
         }
         if (!intent.replanning) {
-            throw new Error(`supervisor intent ${goalId} mission requires replanning`);
+            throw new Error(`governor 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`);
+        throw new Error(`governor intent ${goalId} specialists are not canonical`);
     }
     if (JSON.stringify(normalizeLimits(intent.limits)) !== JSON.stringify(intent.limits)) {
-        throw new Error(`supervisor intent ${goalId} limits are not canonical`);
+        throw new Error(`governor intent ${goalId} limits are not canonical`);
     }
     if (JSON.stringify(normalizeAutomation(intent.automation)) !== JSON.stringify(intent.automation)) {
-        throw new Error(`supervisor intent ${goalId} automation policy is not canonical`);
+        throw new Error(`governor intent ${goalId} automation policy is not canonical`);
     }
     if (intent.replanning)
         validateReplanning(intent.replanning, specialists, intent.limits, goalId);
 }
 function normalizeMission(input) {
     if (!Array.isArray(input.acceptance)) {
-        throw new Error("supervisor mission acceptance must be an array");
+        throw new Error("governor 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`);
+        throw new Error(`governor mission acceptance must contain 1 to ${MAX_ACCEPTANCE} criteria`);
     }
-    const acceptance = input.acceptance.map((criterion, index) => bounded(criterion, `supervisor mission acceptance[${index}]`, 500));
+    const acceptance = input.acceptance.map((criterion, index) => bounded(criterion, `governor mission acceptance[${index}]`, 500));
     if (new Set(acceptance).size !== acceptance.length) {
-        throw new Error("supervisor mission acceptance criteria must be unique");
+        throw new Error("governor mission acceptance criteria must be unique");
     }
     return {
-        objective: bounded(input.objective, "supervisor mission objective", MAX_OBJECTIVE),
+        objective: bounded(input.objective, "governor mission objective", MAX_OBJECTIVE),
         acceptance,
-        max_milestones: positive(input.maxMilestones ?? 4, "supervisor mission max_milestones", 20),
+        max_milestones: positive(input.maxMilestones ?? 4, "governor mission max_milestones", 20),
     };
 }
 function missionTitle(mission) {
@@ -569,12 +689,12 @@ function missionTitle(mission) {
 }
 function normalizeLimits(input) {
     return {
-        max_cycles: positive(input?.max_cycles ?? 50, "supervisor max_cycles", 1_000),
-        max_runtime_ms: positive(input?.max_runtime_ms ?? 4 * 60 * 60 * 1_000, "supervisor max_runtime_ms", 7 * 24 * 60 * 60 * 1_000),
-        max_parallel_work: positive(input?.max_parallel_work ?? 1, "supervisor max_parallel_work", 20),
-        max_total_attempts: positive(input?.max_total_attempts ?? 100, "supervisor max_total_attempts", 10_000),
-        max_agents_per_work: positive(input?.max_agents_per_work ?? 20, "supervisor max_agents_per_work", 1_000),
-        agent_concurrency: positive(input?.agent_concurrency ?? 4, "supervisor agent_concurrency", 100),
+        max_cycles: positive(input?.max_cycles ?? 50, "governor max_cycles", 1_000),
+        max_runtime_ms: positive(input?.max_runtime_ms ?? 4 * 60 * 60 * 1_000, "governor max_runtime_ms", 7 * 24 * 60 * 60 * 1_000),
+        max_parallel_work: positive(input?.max_parallel_work ?? 1, "governor max_parallel_work", 20),
+        max_total_attempts: positive(input?.max_total_attempts ?? 100, "governor max_total_attempts", 10_000),
+        max_agents_per_work: positive(input?.max_agents_per_work ?? 20, "governor max_agents_per_work", 1_000),
+        agent_concurrency: positive(input?.agent_concurrency ?? 4, "governor agent_concurrency", 100),
     };
 }
 function normalizeAutomation(input) {
@@ -637,8 +757,8 @@ function normalizeReviewPolicy(input, specialists, plannerSpecialist, limits) {
     if (!Array.isArray(input.reviewerSpecialists) || input.reviewerSpecialists.length < 1) {
         throw new Error("replanning review requires at least one reviewer specialist");
     }
-    if (input.reviewerSpecialists.length > MAX_SUPERVISOR_PLAN_REVIEWERS) {
-        throw new Error(`replanning review cannot exceed ${MAX_SUPERVISOR_PLAN_REVIEWERS} reviewer specialists`);
+    if (input.reviewerSpecialists.length > MAX_GOVERNOR_PLAN_REVIEWERS) {
+        throw new Error(`replanning review cannot exceed ${MAX_GOVERNOR_PLAN_REVIEWERS} reviewer specialists`);
     }
     const reviewerSpecialists = input.reviewerSpecialists.map((specialist, index) => bounded(specialist, `reviewer specialist[${index}]`, 100));
     if (new Set(reviewerSpecialists).size !== reviewerSpecialists.length) {
@@ -652,7 +772,7 @@ function normalizeReviewPolicy(input, specialists, plannerSpecialist, limits) {
             throw new Error("reviewer specialist cannot be the planner specialist");
         }
     }
-    const maxRevisionRounds = nonNegative(input.maxRevisionRounds, "replanning review max_revision_rounds", MAX_SUPERVISOR_PLAN_REVISION_ROUNDS);
+    const maxRevisionRounds = nonNegative(input.maxRevisionRounds, "replanning review max_revision_rounds", MAX_GOVERNOR_PLAN_REVISION_ROUNDS);
     const worstCaseAgents = 1 + reviewerSpecialists.length * (maxRevisionRounds + 1) + maxRevisionRounds;
     if (worstCaseAgents > limits.max_agents_per_work) {
         throw new Error(`replanning review worst-case ${worstCaseAgents} agents exceeds max_agents_per_work ${limits.max_agents_per_work}`);
@@ -664,18 +784,18 @@ function normalizeReviewPolicy(input, specialists, plannerSpecialist, limits) {
 }
 function validateReplanning(policy, specialists, limits, goalId) {
     if (!specialists[policy.planner_specialist]) {
-        throw new Error(`supervisor ${goalId} planner specialist is not in the frozen team`);
+        throw new Error(`governor ${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`);
+        throw new Error(`governor ${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`);
+        throw new Error(`governor ${goalId} has invalid replanning templates`);
     }
     let rootCapable = false;
     for (const [id, template] of entries) {
@@ -686,45 +806,45 @@ function validateReplanning(policy, specialists, limits, goalId) {
             template.max_attempts < 1 ||
             template.max_attempts > 100 ||
             typeof template.root !== "boolean") {
-            throw new Error(`supervisor ${goalId} replanning template ${id} is invalid`);
+            throw new Error(`governor ${goalId} replanning template ${id} is invalid`);
         }
         rootCapable ||= template.root;
     }
     if (!rootCapable)
-        throw new Error(`supervisor ${goalId} has no root-capable replanning template`);
+        throw new Error(`governor ${goalId} has no root-capable replanning template`);
     if (policy.review !== undefined) {
         const review = policy.review;
         if (!Array.isArray(review.reviewer_specialists) ||
             review.reviewer_specialists.length < 1 ||
-            review.reviewer_specialists.length > MAX_SUPERVISOR_PLAN_REVIEWERS ||
+            review.reviewer_specialists.length > MAX_GOVERNOR_PLAN_REVIEWERS ||
             !Number.isSafeInteger(review.max_revision_rounds) ||
             review.max_revision_rounds < 0 ||
-            review.max_revision_rounds > MAX_SUPERVISOR_PLAN_REVISION_ROUNDS) {
-            throw new Error(`supervisor ${goalId} replanning review policy is invalid`);
+            review.max_revision_rounds > MAX_GOVERNOR_PLAN_REVISION_ROUNDS) {
+            throw new Error(`governor ${goalId} replanning review policy is invalid`);
         }
         if (new Set(review.reviewer_specialists).size !== review.reviewer_specialists.length) {
-            throw new Error(`supervisor ${goalId} replanning reviewers are not unique`);
+            throw new Error(`governor ${goalId} replanning reviewers are not unique`);
         }
         for (const specialist of review.reviewer_specialists) {
             if (!specialists[specialist]) {
-                throw new Error(`supervisor ${goalId} reviewer specialist is not in the frozen team`);
+                throw new Error(`governor ${goalId} reviewer specialist is not in the frozen team`);
             }
             if (specialist === policy.planner_specialist) {
-                throw new Error(`supervisor ${goalId} reviewer specialist cannot be planner`);
+                throw new Error(`governor ${goalId} reviewer specialist cannot be planner`);
             }
         }
         const worstCaseAgents = 1 +
             review.reviewer_specialists.length * (review.max_revision_rounds + 1) +
             review.max_revision_rounds;
         if (worstCaseAgents > limits.max_agents_per_work) {
-            throw new Error(`supervisor ${goalId} review policy exceeds the agent budget`);
+            throw new Error(`governor ${goalId} review policy exceeds the agent budget`);
         }
     }
 }
 function collectGovernedWork(coordRoot, originalRootWorkId, plans, active) {
     const governed = new Map();
     if (workIntentExists(coordRoot, originalRootWorkId)) {
-        for (const record of collectSupervisorWork(coordRoot, originalRootWorkId)) {
+        for (const record of collectGovernorWork(coordRoot, originalRootWorkId)) {
             governed.set(record.intent.id, record);
         }
     }
@@ -740,15 +860,15 @@ function workIntentExists(coordRoot, workId) {
 function missionRootId(goalId) {
     return `${goalId.slice(0, 87)}-mission-root`;
 }
-function supervisorDir(coordRoot, goalId) {
-    assertSupervisorId(goalId);
-    return join(resolve(coordRoot), ".harnery", "supervisors", goalId);
+function governorDir(coordRoot, goalId) {
+    assertGovernorId(goalId);
+    return join(resolve(coordRoot), ".harnery", "governors", goalId);
 }
-function supervisorIntentPath(coordRoot, goalId) {
-    return join(supervisorDir(coordRoot, goalId), "intent.json");
+function governorIntentPath(coordRoot, goalId) {
+    return join(governorDir(coordRoot, goalId), "intent.json");
 }
-function supervisorLeaseIsLive(coordRoot, goalId) {
-    const lease = readLease(join(supervisorDir(coordRoot, goalId), "lease.json"));
+function governorLeaseIsLive(coordRoot, goalId) {
+    const lease = readLease(join(governorDir(coordRoot, goalId), "lease.json"));
     return lease ? leaseIsLive(lease) : false;
 }
 function readLease(path) {
@@ -787,7 +907,7 @@ function leaseIsLive(lease) {
 function writePrivateJson(path, value) {
     const body = `${JSON.stringify(value, null, 2)}\n`;
     if (Buffer.byteLength(body) > MAX_INTENT_BYTES) {
-        throw new Error(`supervisor intent exceeds ${MAX_INTENT_BYTES} bytes`);
+        throw new Error(`governor intent exceeds ${MAX_INTENT_BYTES} bytes`);
     }
     writeFileSync(path, body, { encoding: "utf8", flag: "wx", mode: 0o600 });
     chmodSync(path, 0o600);
@@ -816,7 +936,7 @@ function nonNegative(value, field, max) {
 }
 function boolean(value, field) {
     if (typeof value !== "boolean")
-        throw new Error(`supervisor ${field} must be boolean`);
+        throw new Error(`governor ${field} must be boolean`);
     return value;
 }
 function validTimestamp(value) {