harnery 0.16.0 → 0.18.0

package/dist/core/supervisor/planning.js

@@ -0,0 +1,579 @@
+import { randomBytes, randomUUID } from "node:crypto";
+import { appendFileSync, chmodSync, existsSync, linkSync, mkdirSync, readFileSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { createWorkItem, readWorkItem } from "../work/index.js";
+import { readWorkflowProof, runWorkflow, WorkflowParkedError, workflowScriptDigest, } from "../workflow/index.js";
+import { readSupervisorPlan, readSupervisorPlans } from "./plan-read.js";
+import { SUPERVISOR_PLAN_SCHEMA_VERSION, supervisorGraphFingerprint, } from "./plan-types.js";
+const PLAN_KEY = /^[a-z][a-z0-9-]{0,31}$/;
+const TEMPLATE_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+const MAX_RECORD_BYTES = 256 * 1024;
+const MAX_EVENTS_BYTES = 512 * 1024;
+const MAX_REASON = 2_000;
+export async function runSupervisorPlanner(input) {
+    const coordRoot = resolve(input.coordRoot);
+    const policy = input.record.intent.replanning;
+    if (!policy)
+        throw new Error(`supervisor ${input.record.intent.id} does not allow replanning`);
+    const history = readSupervisorPlans(coordRoot, input.record.intent.id, input.record.intent.root_work_id);
+    const triggerFingerprint = supervisorGraphFingerprint({
+        rootWorkId: input.record.projection.root_work_id,
+        generation: input.record.projection.plan_generation,
+        work: input.record.work,
+    });
+    const trigger = planTrigger(input.record);
+    const resumable = history.latest?.status === "resumable" &&
+        history.latest.request.trigger_fingerprint === triggerFingerprint &&
+        history.latest.request.prior_root_work_id === input.record.projection.root_work_id
+        ? history.latest
+        : undefined;
+    const request = resumable
+        ? resumable.request
+        : createPlanRequest(coordRoot, input.record, history.plans.length + 1, triggerFingerprint, trigger);
+    const scriptPath = planScriptPath(coordRoot, input.record.intent.id, request.id);
+    if (resumable) {
+        appendPlanEvent(coordRoot, input.record.intent.id, request.id, {
+            event: "plan.resumed",
+            actor: input.actor,
+            reason: `resuming planner workflow after approval ${resumable.approval_id}`,
+            approval_id: resumable.approval_id,
+        });
+    }
+    let proposalWritten = false;
+    try {
+        const report = await runWorkflow(scriptPath, {
+            ...input.engine,
+            coordRoot,
+            ...(resumable
+                ? { resumeRunId: request.workflow_run_id }
+                : { runId: request.workflow_run_id }),
+            specialists: input.record.intent.specialists,
+            maxAgents: 1,
+            concurrency: 1,
+            onLog: input.onLog,
+        });
+        const proposal = normalizeProposal(request.id, report.result, input.record, history.materialized_work_ids.length, request.trigger ?? "recovery");
+        writeExclusiveJson(planProposalPath(coordRoot, input.record.intent.id, request.id), proposal, "supervisor plan proposal");
+        appendPlanEvent(coordRoot, input.record.intent.id, request.id, {
+            event: "plan.proposed",
+            actor: input.actor,
+            reason: proposal.rationale,
+        });
+        proposalWritten = true;
+        if (proposal.decision === "attention") {
+            appendPlanEvent(coordRoot, input.record.intent.id, request.id, {
+                event: "plan.attention",
+                actor: input.actor,
+                reason: proposal.rationale,
+            });
+            return outcome(readSupervisorPlan(coordRoot, input.record.intent.id, request.id));
+        }
+        if (policy.auto_apply) {
+            return applySupervisorPlanProposal({
+                coordRoot,
+                record: input.record,
+                planId: request.id,
+                actor: input.actor,
+                reason: "proposal applied by frozen supervisor replanning policy",
+            });
+        }
+        return outcome(readSupervisorPlan(coordRoot, input.record.intent.id, request.id));
+    }
+    catch (error) {
+        if (proposalWritten)
+            throw error;
+        if (error instanceof WorkflowParkedError) {
+            appendPlanEvent(coordRoot, input.record.intent.id, request.id, {
+                event: "plan.awaiting_approval",
+                actor: input.actor,
+                reason: `planner workflow parked for approval ${error.approvalId}`,
+                approval_id: error.approvalId,
+            });
+            return outcome(readSupervisorPlan(coordRoot, input.record.intent.id, request.id));
+        }
+        appendPlanEvent(coordRoot, input.record.intent.id, request.id, {
+            event: "plan.failed",
+            actor: input.actor,
+            reason: bounded(error.message, "plan failure", MAX_REASON),
+        });
+        throw error;
+    }
+}
+export function applySupervisorPlanProposal(input) {
+    const coordRoot = resolve(input.coordRoot);
+    const policy = input.record.intent.replanning;
+    if (!policy)
+        throw new Error(`supervisor ${input.record.intent.id} does not allow replanning`);
+    const plan = readSupervisorPlan(coordRoot, input.record.intent.id, input.planId);
+    if (plan.status === "applied" || plan.status === "completed")
+        return outcome(plan);
+    if (plan.status !== "proposed" ||
+        !plan.proposal ||
+        !["apply", "complete"].includes(plan.proposal.decision)) {
+        throw new Error(`supervisor plan ${input.planId} cannot be applied from ${plan.status}`);
+    }
+    if (plan.request.prior_root_work_id !== input.record.projection.root_work_id) {
+        throw new Error(`supervisor plan ${input.planId} targets stale root ${plan.request.prior_root_work_id}`);
+    }
+    const history = readSupervisorPlans(coordRoot, input.record.intent.id, input.record.intent.root_work_id);
+    const proposal = normalizeProposal(input.planId, plan.proposal, input.record, history.materialized_work_ids.filter((workId) => !workId.startsWith(`${input.planId}-`)).length, plan.request.trigger ?? "recovery");
+    if (proposal.decision === "complete") {
+        appendPlanEvent(coordRoot, input.record.intent.id, input.planId, {
+            event: "plan.completed",
+            actor: input.actor,
+            reason: input.reason ?? proposal.rationale,
+        });
+        return outcome(readSupervisorPlan(coordRoot, input.record.intent.id, input.planId));
+    }
+    const ids = new Map();
+    const created = [];
+    for (const spec of proposal.work) {
+        const template = policy.templates[spec.template];
+        if (!template)
+            throw new Error(`plan work ${spec.key} references unknown template ${spec.template}`);
+        if (workflowScriptDigest(template.workflow.path) !== template.workflow.sha256) {
+            throw new Error(`replanning template ${spec.template} changed after goal creation`);
+        }
+        const workId = `${input.planId}-${spec.key}`;
+        const dependencies = spec.dependencies.map((dependency) => ids.get(dependency) ?? dependency);
+        const expected = {
+            title: spec.title,
+            objective: spec.objective,
+            acceptance: spec.acceptance,
+            dependencies,
+            workflow: template.workflow,
+            max_attempts: template.max_attempts,
+            source: {
+                kind: "workflow",
+                ref: `supervisor:${input.record.intent.id}/plan:${input.planId}`,
+            },
+        };
+        if (existsSync(join(coordRoot, ".harnery", "work", workId, "intent.json"))) {
+            const current = readWorkItem(coordRoot, workId).intent;
+            const actual = {
+                title: current.title,
+                objective: current.objective,
+                acceptance: current.acceptance,
+                dependencies: current.dependencies,
+                workflow: current.workflow,
+                max_attempts: current.max_attempts,
+                source: current.source,
+            };
+            if (JSON.stringify(actual) !== JSON.stringify(expected)) {
+                throw new Error(`partial plan work ${workId} conflicts with the durable proposal`);
+            }
+        }
+        else {
+            createWorkItem({
+                coordRoot,
+                id: workId,
+                title: spec.title,
+                objective: spec.objective,
+                acceptance: spec.acceptance,
+                dependencies,
+                workflowPath: template.workflow.path,
+                maxAttempts: template.max_attempts,
+                source: expected.source,
+                actor: input.actor,
+            });
+        }
+        ids.set(spec.key, workId);
+        created.push(workId);
+    }
+    const rootWorkId = ids.get(proposal.root);
+    if (!rootWorkId)
+        throw new Error(`plan root ${proposal.root} was not materialized`);
+    appendPlanEvent(coordRoot, input.record.intent.id, input.planId, {
+        event: "plan.applied",
+        actor: input.actor,
+        reason: input.reason ?? "supervisor plan explicitly approved",
+        root_work_id: rootWorkId,
+        work_ids: created,
+    });
+    return outcome(readSupervisorPlan(coordRoot, input.record.intent.id, input.planId));
+}
+export function rejectSupervisorPlanProposal(input) {
+    const plan = readSupervisorPlan(input.coordRoot, input.goalId, input.planId);
+    if (plan.status === "rejected")
+        return outcome(plan);
+    if (plan.status !== "proposed") {
+        throw new Error(`supervisor plan ${input.planId} cannot be rejected from ${plan.status}`);
+    }
+    appendPlanEvent(input.coordRoot, input.goalId, input.planId, {
+        event: "plan.rejected",
+        actor: input.actor,
+        reason: input.reason,
+    });
+    return outcome(readSupervisorPlan(input.coordRoot, input.goalId, input.planId));
+}
+function createPlanRequest(coordRoot, record, sequence, triggerFingerprint, trigger) {
+    const policy = record.intent.replanning;
+    if (!policy)
+        throw new Error(`supervisor ${record.intent.id} does not allow replanning`);
+    if (sequence > policy.max_replans) {
+        throw new Error(`supervisor ${record.intent.id} exhausted its ${policy.max_replans} replans`);
+    }
+    const planId = `plan-${String(sequence).padStart(4, "0")}-${randomBytes(4).toString("hex")}`;
+    const request = {
+        schema_version: SUPERVISOR_PLAN_SCHEMA_VERSION,
+        id: planId,
+        goal_id: record.intent.id,
+        sequence,
+        trigger,
+        trigger_fingerprint: triggerFingerprint,
+        prior_root_work_id: record.projection.root_work_id,
+        workflow_run_id: `${planId}-workflow`,
+        created_at: new Date().toISOString(),
+    };
+    const script = plannerScript(coordRoot, record, planId, trigger);
+    const dir = planDir(coordRoot, record.intent.id, planId);
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    chmodSync(dir, 0o700);
+    writeExclusiveJson(join(dir, "request.json"), request, "supervisor plan request");
+    writeExclusive(join(dir, "planner.mjs"), script, "supervisor planner script");
+    return request;
+}
+function plannerScript(coordRoot, record, planId, trigger) {
+    const policy = record.intent.replanning;
+    if (!policy)
+        throw new Error(`supervisor ${record.intent.id} does not allow replanning`);
+    const prompt = [
+        "You are producing one bounded replacement plan or milestone decision for a durable supervised goal.",
+        record.intent.mission
+            ? "Return decision=apply with the next immutable milestone graph, decision=complete only when mission acceptance is met, or decision=attention when human judgment is required."
+            : "Return decision=apply with a replacement immutable root graph, or decision=attention when human judgment is required.",
+        "Never claim mission completion unless the frozen mission acceptance is met. Never request a workflow outside the frozen template catalog.",
+        "Dependencies may name an active work ID or an earlier key in your proposed work array.",
+        "Every proposed item must be reachable from root. The root must be a proposed key using a root-capable template.",
+        `Plan id: ${planId}`,
+        `Planning trigger: ${trigger}`,
+        `Goal: ${record.intent.title}`,
+        `Mission: ${JSON.stringify(record.intent.mission ?? null)}`,
+        `Original root: ${record.intent.root_work_id}`,
+        `Active root: ${record.projection.root_work_id}`,
+        `Remaining work attempts: ${record.projection.attempts_remaining}`,
+        `Remaining replans: ${record.projection.replans_remaining}`,
+        `Completed milestones: ${record.projection.milestones_completed}`,
+        `Remaining milestones: ${record.projection.milestones_remaining}`,
+        `Latest planner outcome: ${JSON.stringify(record.plans.at(-1)
+            ? {
+                status: record.plans.at(-1)?.status,
+                reason: record.plans.at(-1)?.reason,
+            }
+            : null)}`,
+        `Templates: ${JSON.stringify(policy.templates)}`,
+        `Active work: ${JSON.stringify(record.work.map((work) => ({
+            id: work.intent.id,
+            title: work.intent.title,
+            objective: work.intent.objective,
+            acceptance: work.intent.acceptance,
+            dependencies: work.intent.dependencies,
+            state: work.projection.state,
+            reason: work.projection.reason,
+            proof: work.projection.proof_path
+                ? (() => {
+                    const proof = readWorkflowProof(coordRoot, work.projection.latest_run_id);
+                    return {
+                        run_id: proof.run.id,
+                        status: proof.run.status,
+                        acceptance: proof.acceptance.summary,
+                        repository: {
+                            head_changed: proof.repository.drift.head_changed,
+                            dirty_paths_added: proof.repository.drift.dirty_paths_added,
+                            incomplete: proof.repository.drift.incomplete,
+                        },
+                        unknowns: proof.unknowns.map((unknown) => unknown.code),
+                    };
+                })()
+                : null,
+        })))}`,
+    ].join("\n\n");
+    const schema = {
+        type: "object",
+        properties: {
+            decision: {
+                type: "string",
+                enum: record.intent.mission ? ["apply", "complete", "attention"] : ["apply", "attention"],
+            },
+            rationale: { type: "string" },
+            root: { type: "string" },
+            work: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        key: { type: "string" },
+                        title: { type: "string" },
+                        objective: { type: "string" },
+                        acceptance: { type: "array", items: { type: "string" } },
+                        dependencies: { type: "array", items: { type: "string" } },
+                        template: { type: "string" },
+                    },
+                    required: ["key", "title", "objective", "acceptance", "dependencies", "template"],
+                },
+            },
+            milestone: {
+                type: "object",
+                properties: {
+                    sequence: { type: "number" },
+                    title: { type: "string" },
+                    objective: { type: "string" },
+                    acceptance: { type: "array", items: { type: "string" } },
+                },
+                required: ["sequence", "title", "objective", "acceptance"],
+            },
+        },
+        required: ["decision", "rationale", "root", "work"],
+    };
+    return [
+        `export const meta = ${JSON.stringify({ name: `replan-${planId}` })};`,
+        "export default async ({ agent, stage }) => {",
+        `  stage(${JSON.stringify(trigger === "initial"
+            ? "Plan initial mission milestone"
+            : trigger === "milestone"
+                ? "Reassess completed milestone"
+                : "Replan blocked goal")});`,
+        `  return await agent(${JSON.stringify(prompt)}, ${JSON.stringify({
+            specialist: policy.planner_specialist,
+            schema,
+            label: "Produce bounded replacement plan",
+        })});`,
+        "};",
+        "",
+    ].join("\n");
+}
+function normalizeProposal(planId, raw, record, previouslyApplied, trigger) {
+    const policy = record.intent.replanning;
+    if (!policy)
+        throw new Error(`supervisor ${record.intent.id} does not allow replanning`);
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new Error("planner result must be an object");
+    }
+    const value = raw;
+    const decision = enumValue(value.decision, ["apply", "complete", "attention"], "plan decision");
+    const rationale = bounded(value.rationale, "plan rationale", MAX_REASON);
+    const root = typeof value.root === "string" ? value.root.trim() : "";
+    if (!Array.isArray(value.work))
+        throw new Error("plan work must be an array");
+    if (decision === "attention" || decision === "complete") {
+        if (root || value.work.length > 0 || value.milestone !== undefined) {
+            throw new Error(`${decision} plan must not contain work or milestone data`);
+        }
+        if (decision === "complete" && (!record.intent.mission || trigger !== "milestone")) {
+            throw new Error("mission completion may be proposed only at a milestone boundary");
+        }
+        return {
+            schema_version: SUPERVISOR_PLAN_SCHEMA_VERSION,
+            plan_id: planId,
+            decision,
+            rationale,
+            root: "",
+            work: [],
+            proposed_at: new Date().toISOString(),
+        };
+    }
+    const milestone = record.intent.mission
+        ? normalizeMilestone(value.milestone, record.projection.milestones_completed + 1)
+        : undefined;
+    if (!record.intent.mission && value.milestone !== undefined) {
+        throw new Error("non-mission replacement plan must not contain milestone data");
+    }
+    if (milestone && milestone.sequence > record.intent.mission.max_milestones) {
+        throw new Error(`milestone ${milestone.sequence} exceeds mission limit ${record.intent.mission.max_milestones}`);
+    }
+    if (value.work.length < 1 || value.work.length > policy.max_work_items_per_plan) {
+        throw new Error(`plan work must contain 1 to ${policy.max_work_items_per_plan} items`);
+    }
+    if (previouslyApplied + value.work.length > policy.max_total_work_items) {
+        throw new Error(`plan would exceed ${policy.max_total_work_items} total planned work items`);
+    }
+    const active = new Set(record.projection.work_ids);
+    const seen = new Set();
+    const work = value.work.map((candidate, index) => {
+        if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) {
+            throw new Error(`plan work[${index}] must be an object`);
+        }
+        const item = candidate;
+        const key = bounded(item.key, `plan work[${index}].key`, 32);
+        if (!PLAN_KEY.test(key) || seen.has(key))
+            throw new Error(`invalid or duplicate plan key ${key}`);
+        const template = bounded(item.template, `plan work[${index}].template`, 64);
+        if (!TEMPLATE_ID.test(template) || !policy.templates[template]) {
+            throw new Error(`plan work ${key} references unknown template ${template}`);
+        }
+        if (!Array.isArray(item.dependencies))
+            throw new Error(`plan work ${key} dependencies must be an array`);
+        const dependencies = [
+            ...new Set(item.dependencies.map((dependency, dependencyIndex) => bounded(dependency, `plan work ${key} dependency[${dependencyIndex}]`, 100))),
+        ];
+        if (dependencies.length > 50)
+            throw new Error(`plan work ${key} exceeds 50 dependencies`);
+        for (const dependency of dependencies) {
+            if (!active.has(dependency) && !seen.has(dependency)) {
+                throw new Error(`plan work ${key} dependency ${dependency} is not active or earlier in the plan`);
+            }
+        }
+        if (!Array.isArray(item.acceptance))
+            throw new Error(`plan work ${key} acceptance must be an array`);
+        const acceptance = item.acceptance.map((criterion, criterionIndex) => bounded(criterion, `plan work ${key} acceptance[${criterionIndex}]`, 500));
+        if (acceptance.length > 50)
+            throw new Error(`plan work ${key} exceeds 50 acceptance criteria`);
+        seen.add(key);
+        return {
+            key,
+            title: bounded(item.title, `plan work ${key} title`, 200),
+            objective: bounded(item.objective, `plan work ${key} objective`, 4_000),
+            acceptance,
+            dependencies,
+            template,
+        };
+    });
+    if (!seen.has(root))
+        throw new Error(`plan root ${root || "(empty)"} is not a proposed key`);
+    const rootSpec = work.find((item) => item.key === root);
+    if (!rootSpec || !policy.templates[rootSpec.template]?.root) {
+        throw new Error(`plan root ${root} must use a root-capable template`);
+    }
+    const reachable = new Set();
+    const byKey = new Map(work.map((item) => [item.key, item]));
+    const visit = (key) => {
+        if (reachable.has(key))
+            return;
+        reachable.add(key);
+        for (const dependency of byKey.get(key)?.dependencies ?? []) {
+            if (byKey.has(dependency))
+                visit(dependency);
+        }
+    };
+    visit(root);
+    const unused = work.filter((item) => !reachable.has(item.key));
+    if (unused.length)
+        throw new Error(`plan contains work not reachable from root: ${unused.map((item) => item.key).join(", ")}`);
+    return {
+        schema_version: SUPERVISOR_PLAN_SCHEMA_VERSION,
+        plan_id: planId,
+        decision,
+        rationale,
+        root,
+        work,
+        ...(milestone ? { milestone } : {}),
+        proposed_at: new Date().toISOString(),
+    };
+}
+function normalizeMilestone(raw, expectedSequence) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new Error("mission plan must contain a milestone object");
+    }
+    const value = raw;
+    if (value.sequence !== expectedSequence) {
+        throw new Error(`milestone sequence must be ${expectedSequence}`);
+    }
+    if (!Array.isArray(value.acceptance) || value.acceptance.length < 1) {
+        throw new Error("milestone acceptance must be a non-empty array");
+    }
+    if (value.acceptance.length > 50)
+        throw new Error("milestone acceptance exceeds 50 criteria");
+    return {
+        sequence: expectedSequence,
+        title: bounded(value.title, "milestone title", 200),
+        objective: bounded(value.objective, "milestone objective", 4_000),
+        acceptance: value.acceptance.map((criterion, index) => bounded(criterion, `milestone acceptance[${index}]`, 500)),
+    };
+}
+function planTrigger(record) {
+    if (record.intent.mission &&
+        record.projection.plan_generation === 0 &&
+        record.work.length === 0) {
+        return "initial";
+    }
+    const root = record.work.find((work) => work.intent.id === record.projection.root_work_id);
+    return record.intent.mission && root?.projection.state === "succeeded" ? "milestone" : "recovery";
+}
+function appendPlanEvent(coordRootRaw, goalId, planId, input) {
+    const coordRoot = resolve(coordRootRaw);
+    const path = join(planDir(coordRoot, goalId, planId), "events.jsonl");
+    const current = readSupervisorPlan(coordRoot, goalId, planId).events;
+    const event = {
+        schema_version: SUPERVISOR_PLAN_SCHEMA_VERSION,
+        plan_id: planId,
+        seq: current.length + 1,
+        ts: new Date().toISOString(),
+        ...input,
+        actor: bounded(input.actor, "plan actor", 200),
+        reason: bounded(input.reason, "plan reason", MAX_REASON),
+    };
+    const line = `${JSON.stringify(event)}\n`;
+    const existing = existsSync(path) ? statSync(path).size : 0;
+    if (existing + Buffer.byteLength(line) > MAX_EVENTS_BYTES) {
+        throw new Error("supervisor plan event log would exceed its byte limit");
+    }
+    appendFileSync(path, line, { encoding: "utf8", mode: 0o600 });
+    chmodSync(path, 0o600);
+}
+function outcome(plan) {
+    return {
+        plan_id: plan.request.id,
+        status: plan.status,
+        workflow_run_id: plan.request.workflow_run_id,
+        reason: plan.reason,
+        root_work_id: plan.root_work_id,
+        work_ids: plan.work_ids,
+    };
+}
+function writeExclusiveJson(path, value, label) {
+    writeExclusive(path, `${JSON.stringify(value, null, 2)}\n`, label);
+}
+function writeExclusive(path, body, label) {
+    if (Buffer.byteLength(body) > MAX_RECORD_BYTES) {
+        throw new Error(`${label} exceeds ${MAX_RECORD_BYTES} bytes`);
+    }
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const temporary = `${path}.tmp-${process.pid}-${randomUUID()}`;
+    try {
+        writeFileSync(temporary, body, { encoding: "utf8", flag: "wx", mode: 0o600 });
+        try {
+            linkSync(temporary, path);
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            const existing = readFileSync(path, "utf8");
+            if (existing !== body)
+                throw new Error(`${label} already exists with different content`);
+        }
+        chmodSync(path, 0o600);
+    }
+    finally {
+        try {
+            unlinkSync(temporary);
+        }
+        catch {
+            // The temporary may already be absent after a failed exclusive write.
+        }
+    }
+}
+function planDir(coordRoot, goalId, planId) {
+    return join(coordRoot, ".harnery", "supervisors", goalId, "plans", planId);
+}
+function planScriptPath(coordRoot, goalId, planId) {
+    return join(planDir(coordRoot, goalId, planId), "planner.mjs");
+}
+function planProposalPath(coordRoot, goalId, planId) {
+    return join(planDir(coordRoot, goalId, planId), "proposal.json");
+}
+function bounded(value, field, max) {
+    if (typeof value !== "string")
+        throw new Error(`${field} must be a string`);
+    const normalized = value.trim();
+    if (!normalized)
+        throw new Error(`${field} must not be empty`);
+    if (normalized.length > max)
+        throw new Error(`${field} exceeds ${max} characters`);
+    return normalized;
+}
+function enumValue(value, values, field) {
+    if (typeof value !== "string" || !values.includes(value)) {
+        throw new Error(`${field} must be one of ${values.join(", ")}`);
+    }
+    return value;
+}

package/dist/core/supervisor/read.d.ts

@@ -1,4 +1,6 @@
+export { readSupervisorPlan, readSupervisorPlans } from "./plan-read.js";
+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.js";
 export type { SupervisorServiceConfig, SupervisorServiceGoalRuntime, SupervisorServiceGoalState, SupervisorServiceProcessState, SupervisorServiceRuntime, SupervisorServiceStatus, SupervisorServiceStatusRecord, } from "./service.js";
 export { readSupervisorServiceConfig, readSupervisorServiceRuntime, readSupervisorServiceStatus, supervisorServiceLogPath, } from "./service-read.js";
-export { assertSupervisorId, collectSupervisorWork, listSupervisors, readSupervisor, SUPERVISOR_INTENT_SCHEMA_VERSION, type SupervisorAutomationPolicy, type SupervisorIntent, type SupervisorLimits, type SupervisorNextAction, type SupervisorProjection, type SupervisorRecord, type SupervisorState, } from "./state.js";
+export { assertSupervisorId, collectSupervisorWork, listSupervisors, readSupervisor, SUPERVISOR_INTENT_SCHEMA_VERSION, type SupervisorAutomationPolicy, type SupervisorIntent, type SupervisorLimits, type SupervisorMission, type SupervisorNextAction, type SupervisorProjection, type SupervisorRecord, type SupervisorState, } from "./state.js";
 //# sourceMappingURL=read.d.ts.map

package/dist/core/supervisor/read.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"read.d.ts","sourceRoot":"","sources":["../../../src/core/supervisor/read.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,uBAAuB,EACvB,4BAA4B,EAC5B,0BAA0B,EAC1B,6BAA6B,EAC7B,wBAAwB,EACxB,uBAAuB,EACvB,6BAA6B,GAC9B,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,2BAA2B,EAC3B,4BAA4B,EAC5B,2BAA2B,EAC3B,wBAAwB,GACzB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,kBAAkB,EAClB,qBAAqB,EACrB,eAAe,EACf,cAAc,EACd,gCAAgC,EAChC,KAAK,0BAA0B,EAC/B,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,EACrB,KAAK,eAAe,GACrB,MAAM,YAAY,CAAC"}
+{"version":3,"file":"read.d.ts","sourceRoot":"","sources":["../../../src/core/supervisor/read.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACzE,OAAO,EACL,8BAA8B,EAC9B,KAAK,mBAAmB,EACxB,KAAK,uBAAuB,EAC5B,KAAK,qBAAqB,EAC1B,KAAK,uBAAuB,EAC5B,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAC3B,KAAK,0BAA0B,GAChC,MAAM,iBAAiB,CAAC;AACzB,YAAY,EACV,uBAAuB,EACvB,4BAA4B,EAC5B,0BAA0B,EAC1B,6BAA6B,EAC7B,wBAAwB,EACxB,uBAAuB,EACvB,6BAA6B,GAC9B,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,2BAA2B,EAC3B,4BAA4B,EAC5B,2BAA2B,EAC3B,wBAAwB,GACzB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,kBAAkB,EAClB,qBAAqB,EACrB,eAAe,EACf,cAAc,EACd,gCAAgC,EAChC,KAAK,0BAA0B,EAC/B,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,EACrB,KAAK,eAAe,GACrB,MAAM,YAAY,CAAC"}

package/dist/core/supervisor/read.js

@@ -1,2 +1,4 @@
+export { readSupervisorPlan, readSupervisorPlans } from "./plan-read.js";
+export { SUPERVISOR_PLAN_SCHEMA_VERSION, } from "./plan-types.js";
 export { readSupervisorServiceConfig, readSupervisorServiceRuntime, readSupervisorServiceStatus, supervisorServiceLogPath, } from "./service-read.js";
 export { assertSupervisorId, collectSupervisorWork, listSupervisors, readSupervisor, SUPERVISOR_INTENT_SCHEMA_VERSION, } from "./state.js";

package/dist/core/supervisor/runner.d.ts

@@ -1,4 +1,5 @@
 import { type RunWorkItemInput } from "../work/index.js";
+import type { SupervisorPlanOutcome } from "./plan-types.js";
 import { type SupervisorProjection } from "./state.js";
 export type SupervisorStopReason = "succeeded" | "awaiting_attention" | "blocked" | "budget_exhausted" | "no_progress" | "tick_complete";
 export interface SupervisorDispatchOutcome {
@@ -19,7 +20,9 @@ export interface SupervisorRunReport {
     cycles: number;
     dispatches: number;
     acceptances: number;
+    replans: number;
     outcomes: SupervisorDispatchOutcome[];
+    plan_outcomes: SupervisorPlanOutcome[];
     projection: SupervisorProjection;
 }
 export interface RunSupervisorInput {

package/dist/core/supervisor/runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../../src/core/supervisor/runner.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,gBAAgB,EAItB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAGL,KAAK,oBAAoB,EAE1B,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,oBAAoB,GAC5B,WAAW,GACX,oBAAoB,GACpB,SAAS,GACT,kBAAkB,GAClB,aAAa,GACb,eAAe,CAAC;AAEpB,MAAM,WAAW,yBAAyB;IACxC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,KAAK,GAAG,QAAQ,GAAG,OAAO,CAAC;IACnC,MAAM,EAAE,WAAW,GAAG,QAAQ,GAAG,QAAQ,CAAC;IAC1C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,GAAG,KAAK,CAAC;IACrB,WAAW,EAAE,oBAAoB,CAAC;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,yBAAyB,EAAE,CAAC;IACtC,UAAU,EAAE,oBAAoB,CAAC;CAClC;AAED,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,EAAE,WAAW,GAAG,aAAa,GAAG,aAAa,CAAC,CAAC;IACtF,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAChC;AAQD,wBAAsB,aAAa,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAuJ3F"}
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../../src/core/supervisor/runner.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,gBAAgB,EAItB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAE7D,OAAO,EAGL,KAAK,oBAAoB,EAE1B,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,oBAAoB,GAC5B,WAAW,GACX,oBAAoB,GACpB,SAAS,GACT,kBAAkB,GAClB,aAAa,GACb,eAAe,CAAC;AAEpB,MAAM,WAAW,yBAAyB;IACxC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,KAAK,GAAG,QAAQ,GAAG,OAAO,CAAC;IACnC,MAAM,EAAE,WAAW,GAAG,QAAQ,GAAG,QAAQ,CAAC;IAC1C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,GAAG,KAAK,CAAC;IACrB,WAAW,EAAE,oBAAoB,CAAC;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,yBAAyB,EAAE,CAAC;IACtC,aAAa,EAAE,qBAAqB,EAAE,CAAC;IACvC,UAAU,EAAE,oBAAoB,CAAC;CAClC;AAED,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,EAAE,WAAW,GAAG,aAAa,GAAG,aAAa,CAAC,CAAC;IACtF,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAChC;AAQD,wBAAsB,aAAa,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CA4L3F"}