harnery 0.30.0 → 0.31.0

package/src/core/governor/read.ts

@@ -0,0 +1,59 @@
+export {
+  readGovernorPlan,
+  readGovernorPlanReviewReceipt,
+  readGovernorPlans,
+} from "./plan-read.ts";
+export {
+  GOVERNOR_PLAN_SCHEMA_VERSION,
+  type GovernorPlanEvent,
+  type GovernorPlanEventType,
+  type GovernorPlanHistory,
+  type GovernorPlanMilestone,
+  type GovernorPlanOutcome,
+  type GovernorPlanProposal,
+  type GovernorPlanRecord,
+  type GovernorPlanRequest,
+  type GovernorPlanReviewFinding,
+  type GovernorPlanReviewReceipt,
+  type GovernorPlanReviewReviewer,
+  type GovernorPlanReviewRound,
+  type GovernorPlanReviewStatus,
+  type GovernorPlanReviewSummary,
+  type GovernorPlanReviewVerdict,
+  type GovernorPlanStatus,
+  type GovernorPlanTemplate,
+  type GovernorPlanWorkSpec,
+  type GovernorReplanningPolicy,
+  MAX_GOVERNOR_PLAN_REVIEWERS,
+  MAX_GOVERNOR_PLAN_REVISION_ROUNDS,
+} from "./plan-types.ts";
+export type {
+  GovernorServiceConfig,
+  GovernorServiceGoalRuntime,
+  GovernorServiceGoalState,
+  GovernorServiceProcessState,
+  GovernorServiceRuntime,
+  GovernorServiceStatus,
+  GovernorServiceStatusRecord,
+} from "./service.ts";
+export {
+  governorServiceLogPath,
+  readGovernorServiceConfig,
+  readGovernorServiceRuntime,
+  readGovernorServiceStatus,
+} from "./service-read.ts";
+export {
+  assertGovernorId,
+  collectGovernorWork,
+  GOVERNOR_INTENT_SCHEMA_VERSION,
+  type GovernorAutomationPolicy,
+  type GovernorIntent,
+  type GovernorLimits,
+  type GovernorMission,
+  type GovernorNextAction,
+  type GovernorProjection,
+  type GovernorRecord,
+  type GovernorState,
+  listGovernors,
+  readGovernor,
+} from "./state.ts";

package/src/core/{supervisor → governor}/runner.ts

@@ -6,16 +6,16 @@ import {
   runWorkItem,
   type WorkRecord,
 } from "../work/index.ts";
-import type { SupervisorPlanOutcome } from "./plan-types.ts";
-import { runSupervisorPlanner } from "./planning.ts";
+import type { GovernorPlanOutcome } from "./plan-types.ts";
+import { runGovernorPlanner } from "./planning.ts";
 import {
-  acquireSupervisorLease,
-  readSupervisorIgnoringLease,
-  type SupervisorProjection,
-  type SupervisorRecord,
+  acquireGovernorLease,
+  type GovernorProjection,
+  type GovernorRecord,
+  readGovernorIgnoringLease,
 } from "./state.ts";
 
-export type SupervisorStopReason =
+export type GovernorStopReason =
   | "succeeded"
   | "awaiting_attention"
   | "blocked"
@@ -23,7 +23,7 @@ export type SupervisorStopReason =
   | "no_progress"
   | "tick_complete";
 
-export interface SupervisorDispatchOutcome {
+export interface GovernorDispatchOutcome {
   work_id: string;
   action: "run" | "resume" | "retry";
   status: "completed" | "parked" | "failed";
@@ -31,10 +31,10 @@ export interface SupervisorDispatchOutcome {
   error?: string;
 }
 
-export interface SupervisorRunReport {
+export interface GovernorRunReport {
   goal_id: string;
   mode: "tick" | "run";
-  stop_reason: SupervisorStopReason;
+  stop_reason: GovernorStopReason;
   reason: string;
   started_at: string;
   ended_at: string;
@@ -43,12 +43,12 @@ export interface SupervisorRunReport {
   dispatches: number;
   acceptances: number;
   replans: number;
-  outcomes: SupervisorDispatchOutcome[];
-  plan_outcomes: SupervisorPlanOutcome[];
-  projection: SupervisorProjection;
+  outcomes: GovernorDispatchOutcome[];
+  plan_outcomes: GovernorPlanOutcome[];
+  projection: GovernorProjection;
 }
 
-export interface RunSupervisorInput {
+export interface RunGovernorInput {
   coordRoot: string;
   goalId: string;
   mode?: "tick" | "run";
@@ -63,22 +63,22 @@ interface Candidate {
   consumesAttempt: boolean;
 }
 
-export async function runSupervisor(input: RunSupervisorInput): Promise<SupervisorRunReport> {
+export async function runGovernor(input: RunGovernorInput): Promise<GovernorRunReport> {
   const coordRoot = resolve(input.coordRoot);
   const mode = input.mode ?? "run";
-  const actor = input.actor?.trim() || `supervisor:${input.goalId}`;
+  const actor = input.actor?.trim() || `governor:${input.goalId}`;
   const log = input.onLog ?? (() => undefined);
   const startedAt = new Date().toISOString();
   const startedMs = Date.now();
-  const release = acquireSupervisorLease(coordRoot, input.goalId);
+  const release = acquireGovernorLease(coordRoot, input.goalId);
   let cycles = 0;
   let dispatches = 0;
   let acceptances = 0;
   let replans = 0;
-  const outcomes: SupervisorDispatchOutcome[] = [];
-  const planOutcomes: SupervisorPlanOutcome[] = [];
+  const outcomes: GovernorDispatchOutcome[] = [];
+  const planOutcomes: GovernorPlanOutcome[] = [];
   try {
-    const initial = readSupervisorIgnoringLease(coordRoot, input.goalId);
+    const initial = readGovernorIgnoringLease(coordRoot, input.goalId);
     const cycleLimit = mode === "tick" ? 1 : initial.intent.limits.max_cycles;
     const deadline = startedMs + initial.intent.limits.max_runtime_ms;
     while (cycles < cycleLimit) {
@@ -92,7 +92,7 @@ export async function runSupervisor(input: RunSupervisorInput): Promise<Supervis
         return report("succeeded", record.projection.reason, record);
       }
       if (Date.now() >= deadline) {
-        return report("budget_exhausted", "supervisor wall-time limit reached", record);
+        return report("budget_exhausted", "governor wall-time limit reached", record);
       }
 
       const before = graphFingerprint(record);
@@ -105,7 +105,7 @@ export async function runSupervisor(input: RunSupervisorInput): Promise<Supervis
         log(
           `[${record.intent.title}] ${record.projection.next_action} at graph generation ${record.projection.plan_generation}`,
         );
-        const plan = await runSupervisorPlanner({
+        const plan = await runGovernorPlanner({
           coordRoot,
           record,
           engine: input.engine,
@@ -135,7 +135,7 @@ export async function runSupervisor(input: RunSupervisorInput): Promise<Supervis
           if (work.projection.state !== "in_review") continue;
           acceptWorkItem(coordRoot, work.intent.id, {
             actor,
-            reason: "passing proof accepted by frozen supervisor policy",
+            reason: "passing proof accepted by frozen governor policy",
           });
           acceptances++;
           changed = true;
@@ -175,7 +175,7 @@ export async function runSupervisor(input: RunSupervisorInput): Promise<Supervis
                 action: candidate.action,
                 status: "completed",
                 run_id: result.runId,
-              } satisfies SupervisorDispatchOutcome;
+              } satisfies GovernorDispatchOutcome;
             } catch (error) {
               const latest = reconcileWorkItem(coordRoot, candidate.record.intent.id, actor);
               return {
@@ -184,7 +184,7 @@ export async function runSupervisor(input: RunSupervisorInput): Promise<Supervis
                 status: latest.projection.state === "awaiting_approval" ? "parked" : "failed",
                 run_id: latest.projection.latest_run_id,
                 error: boundedError((error as Error).message),
-              } satisfies SupervisorDispatchOutcome;
+              } satisfies GovernorDispatchOutcome;
             }
           }),
         );
@@ -202,12 +202,12 @@ export async function runSupervisor(input: RunSupervisorInput): Promise<Supervis
           before === after ? "no_progress" : "tick_complete",
           before === after
             ? "the tick found no legal progress action"
-            : "one bounded supervisor cycle completed",
+            : "one bounded governor cycle completed",
           record,
         );
       }
       if (Date.now() >= deadline) {
-        return report("budget_exhausted", "supervisor wall-time limit reached", record);
+        return report("budget_exhausted", "governor wall-time limit reached", record);
       }
       if (record.projection.state === "budget_exhausted") {
         return report("budget_exhausted", record.projection.reason, record);
@@ -219,20 +219,20 @@ export async function runSupervisor(input: RunSupervisorInput): Promise<Supervis
         return report(stopForProjection(record.projection), record.projection.reason, record);
       }
       if (before === after) {
-        return report("no_progress", "a supervisor cycle produced no durable state change", record);
+        return report("no_progress", "a governor cycle produced no durable state change", record);
       }
     }
     const final = refreshGraph(coordRoot, input.goalId, actor);
-    return report("budget_exhausted", `supervisor cycle limit reached (${cycleLimit})`, final);
+    return report("budget_exhausted", `governor cycle limit reached (${cycleLimit})`, final);
   } finally {
     release();
   }
 
   function report(
-    stopReason: SupervisorStopReason,
+    stopReason: GovernorStopReason,
     reason: string,
-    record: SupervisorRecord,
-  ): SupervisorRunReport {
+    record: GovernorRecord,
+  ): GovernorRunReport {
     const endedAt = new Date().toISOString();
     return {
       goal_id: input.goalId,
@@ -253,13 +253,13 @@ export async function runSupervisor(input: RunSupervisorInput): Promise<Supervis
   }
 }
 
-function refreshGraph(coordRoot: string, goalId: string, actor: string): SupervisorRecord {
-  const before = readSupervisorIgnoringLease(coordRoot, goalId);
+function refreshGraph(coordRoot: string, goalId: string, actor: string): GovernorRecord {
+  const before = readGovernorIgnoringLease(coordRoot, goalId);
   for (const work of before.work) reconcileWorkItem(coordRoot, work.intent.id, actor);
-  return readSupervisorIgnoringLease(coordRoot, goalId);
+  return readGovernorIgnoringLease(coordRoot, goalId);
 }
 
-function selectCandidates(record: SupervisorRecord): Candidate[] {
+function selectCandidates(record: GovernorRecord): Candidate[] {
   const candidates: Candidate[] = [];
   for (const work of record.work) {
     if (work.projection.state === "ready") {
@@ -285,7 +285,7 @@ function selectCandidates(record: SupervisorRecord): Candidate[] {
   return candidates;
 }
 
-function selectWithinAttemptBudget(record: SupervisorRecord, candidates: Candidate[]): Candidate[] {
+function selectWithinAttemptBudget(record: GovernorRecord, candidates: Candidate[]): Candidate[] {
   let remaining = record.projection.attempts_remaining;
   return candidates.filter((candidate) => {
     if (!candidate.consumesAttempt) return true;
@@ -295,7 +295,7 @@ function selectWithinAttemptBudget(record: SupervisorRecord, candidates: Candida
   });
 }
 
-function graphFingerprint(record: SupervisorRecord): string {
+function graphFingerprint(record: GovernorRecord): string {
   return JSON.stringify([
     record.projection.root_work_id,
     record.projection.plan_generation,
@@ -310,7 +310,7 @@ function graphFingerprint(record: SupervisorRecord): string {
   ]);
 }
 
-function stopForProjection(projection: SupervisorProjection): SupervisorStopReason {
+function stopForProjection(projection: GovernorProjection): GovernorStopReason {
   if (projection.state === "budget_exhausted") return "budget_exhausted";
   if (projection.state === "blocked") return "blocked";
   return "awaiting_attention";

package/src/core/{supervisor → governor}/service-read.ts

@@ -2,21 +2,21 @@ import { existsSync, readFileSync, statSync } from "node:fs";
 import { hostname } from "node:os";
 import { join, resolve } from "node:path";
 import type {
-  SupervisorServiceConfig,
-  SupervisorServiceRuntime,
-  SupervisorServiceStatus,
-  SupervisorServiceStatusRecord,
+  GovernorServiceConfig,
+  GovernorServiceRuntime,
+  GovernorServiceStatus,
+  GovernorServiceStatusRecord,
 } from "./service.ts";
 
 const MAX_FILE_BYTES = 512 * 1024;
 const MAX_GOALS = 100;
 const FOREIGN_STATUS_STALE_MS = 30_000;
 
-export function readSupervisorServiceConfig(coordRootRaw: string): SupervisorServiceConfig {
+export function readGovernorServiceConfig(coordRootRaw: string): GovernorServiceConfig {
   const coordRoot = resolve(coordRootRaw);
-  const config = readBoundedJson<SupervisorServiceConfig>(
+  const config = readBoundedJson<GovernorServiceConfig>(
     join(serviceDir(coordRoot), "config.json"),
-    "supervisor service configuration",
+    "governor service configuration",
   );
   if (
     config.schema_version !== 1 ||
@@ -35,18 +35,18 @@ export function readSupervisorServiceConfig(coordRootRaw: string): SupervisorSer
     typeof config.engine.subscription_only !== "boolean" ||
     typeof config.engine.allow_api_billing !== "boolean"
   ) {
-    throw new Error("supervisor service configuration has an unsupported schema");
+    throw new Error("governor service configuration has an unsupported schema");
   }
   return config;
 }
 
-export function readSupervisorServiceRuntime(
+export function readGovernorServiceRuntime(
   coordRootRaw: string,
-): SupervisorServiceRuntime | undefined {
+): GovernorServiceRuntime | undefined {
   const coordRoot = resolve(coordRootRaw);
   const path = join(serviceDir(coordRoot), "runtime.json");
   if (!existsSync(path)) return undefined;
-  const runtime = readBoundedJson<SupervisorServiceRuntime>(path, "supervisor service runtime");
+  const runtime = readBoundedJson<GovernorServiceRuntime>(path, "governor service runtime");
   if (
     runtime.schema_version !== 1 ||
     !validTimestamp(runtime.config_created_at) ||
@@ -55,23 +55,23 @@ export function readSupervisorServiceRuntime(
     typeof runtime.goals !== "object" ||
     Array.isArray(runtime.goals)
   ) {
-    throw new Error("supervisor service runtime has an unsupported schema");
+    throw new Error("governor service runtime has an unsupported schema");
   }
   return runtime;
 }
 
-export function readSupervisorServiceStatus(coordRootRaw: string): SupervisorServiceStatus {
+export function readGovernorServiceStatus(coordRootRaw: string): GovernorServiceStatus {
   const coordRoot = resolve(coordRootRaw);
   const record = readStatusRecord(coordRoot);
-  let config: SupervisorServiceConfig | undefined;
-  let runtime: SupervisorServiceRuntime | undefined;
+  let config: GovernorServiceConfig | undefined;
+  let runtime: GovernorServiceRuntime | undefined;
   try {
-    config = readSupervisorServiceConfig(coordRoot);
+    config = readGovernorServiceConfig(coordRoot);
   } catch {
     // Unconfigured or corrupt service state is represented without throwing.
   }
   try {
-    runtime = readSupervisorServiceRuntime(coordRoot);
+    runtime = readGovernorServiceRuntime(coordRoot);
   } catch {
     // Runtime is recoverable and must not make the dashboard unreadable.
   }
@@ -80,15 +80,15 @@ export function readSupervisorServiceStatus(coordRootRaw: string): SupervisorSer
   return { running, stale: !running && record.state !== "stopped", record, config, runtime };
 }
 
-export function supervisorServiceLogPath(coordRoot: string): string {
+export function governorServiceLogPath(coordRoot: string): string {
   return join(serviceDir(resolve(coordRoot)), "service.log");
 }
 
-function readStatusRecord(coordRoot: string): SupervisorServiceStatusRecord | undefined {
+function readStatusRecord(coordRoot: string): GovernorServiceStatusRecord | undefined {
   const path = join(serviceDir(coordRoot), "status.json");
   if (!existsSync(path)) return undefined;
   try {
-    const value = readBoundedJson<SupervisorServiceStatusRecord>(path, "supervisor service status");
+    const value = readBoundedJson<GovernorServiceStatusRecord>(path, "governor service status");
     if (
       value.schema_version !== 1 ||
       !Number.isSafeInteger(value.pid) ||
@@ -106,7 +106,7 @@ function readStatusRecord(coordRoot: string): SupervisorServiceStatusRecord | un
   }
 }
 
-function statusOwnerIsLive(record: SupervisorServiceStatusRecord): boolean {
+function statusOwnerIsLive(record: GovernorServiceStatusRecord): boolean {
   if (record.state === "stopped") return false;
   if (record.host === hostname()) {
     try {
@@ -132,7 +132,7 @@ function readBoundedJson<T>(path: string, label: string): T {
 }
 
 function serviceDir(coordRoot: string): string {
-  return join(coordRoot, ".harnery", "supervisor-service");
+  return join(coordRoot, ".harnery", "governor-service");
 }
 
 function positive(value: unknown): value is number {