harnery 0.16.0 → 0.17.0

package/dist/core/supervisor/plan-types.d.ts

@@ -0,0 +1,113 @@
+export declare const SUPERVISOR_PLAN_SCHEMA_VERSION: 1;
+export interface SupervisorPlanTemplate {
+    workflow: {
+        path: string;
+        sha256: string;
+    };
+    max_attempts: number;
+    root: boolean;
+}
+export interface SupervisorReplanningPolicy {
+    planner_specialist: string;
+    auto_apply: boolean;
+    max_replans: number;
+    max_work_items_per_plan: number;
+    max_total_work_items: number;
+    templates: Record<string, SupervisorPlanTemplate>;
+}
+export interface CreateSupervisorPlanTemplateInput {
+    workflowPath: string;
+    maxAttempts?: number;
+    root?: boolean;
+}
+export interface CreateSupervisorReplanningInput {
+    plannerSpecialist: string;
+    autoApply?: boolean;
+    maxReplans?: number;
+    maxWorkItemsPerPlan?: number;
+    maxTotalWorkItems?: number;
+    templates: Readonly<Record<string, CreateSupervisorPlanTemplateInput>>;
+}
+export interface SupervisorPlanRequest {
+    schema_version: typeof SUPERVISOR_PLAN_SCHEMA_VERSION;
+    id: string;
+    goal_id: string;
+    sequence: number;
+    trigger_fingerprint: string;
+    prior_root_work_id: string;
+    workflow_run_id: string;
+    created_at: string;
+}
+export interface SupervisorPlanWorkSpec {
+    key: string;
+    title: string;
+    objective: string;
+    acceptance: string[];
+    dependencies: string[];
+    template: string;
+}
+export interface SupervisorPlanProposal {
+    schema_version: typeof SUPERVISOR_PLAN_SCHEMA_VERSION;
+    plan_id: string;
+    decision: "apply" | "attention";
+    rationale: string;
+    root: string;
+    work: SupervisorPlanWorkSpec[];
+    proposed_at: string;
+}
+export type SupervisorPlanEventType = "plan.awaiting_approval" | "plan.resumed" | "plan.proposed" | "plan.applied" | "plan.rejected" | "plan.attention" | "plan.failed";
+export interface SupervisorPlanEvent {
+    schema_version: typeof SUPERVISOR_PLAN_SCHEMA_VERSION;
+    plan_id: string;
+    seq: number;
+    ts: string;
+    event: SupervisorPlanEventType;
+    actor: string;
+    reason: string;
+    approval_id?: string;
+    root_work_id?: string;
+    work_ids?: string[];
+}
+export type SupervisorPlanStatus = "interrupted" | "awaiting_approval" | "resumable" | "proposed" | "applied" | "rejected" | "attention" | "failed";
+export interface SupervisorPlanRecord {
+    request: SupervisorPlanRequest;
+    proposal?: SupervisorPlanProposal;
+    events: SupervisorPlanEvent[];
+    status: SupervisorPlanStatus;
+    approval_id?: string;
+    root_work_id?: string;
+    work_ids: string[];
+    reason?: string;
+}
+export interface SupervisorPlanHistory {
+    plans: SupervisorPlanRecord[];
+    active_root_work_id: string;
+    generation: number;
+    applied_work_ids: string[];
+    materialized_work_ids: string[];
+    latest?: SupervisorPlanRecord;
+}
+export interface SupervisorPlanOutcome {
+    plan_id: string;
+    status: SupervisorPlanStatus;
+    workflow_run_id: string;
+    reason?: string;
+    root_work_id?: string;
+    work_ids: string[];
+}
+export declare function supervisorGraphFingerprint(input: {
+    rootWorkId: string;
+    generation: number;
+    work: ReadonlyArray<{
+        intent: {
+            id: string;
+        };
+        projection: {
+            state: string;
+            next_action: string;
+            attempts_used: number;
+        };
+        events: readonly unknown[];
+    }>;
+}): string;
+//# sourceMappingURL=plan-types.d.ts.map

package/dist/core/supervisor/plan-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-types.d.ts","sourceRoot":"","sources":["../../../src/core/supervisor/plan-types.ts"],"names":[],"mappings":"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"}

package/dist/core/supervisor/plan-types.js

@@ -0,0 +1,14 @@
+export const SUPERVISOR_PLAN_SCHEMA_VERSION = 1;
+export function supervisorGraphFingerprint(input) {
+    return JSON.stringify([
+        input.rootWorkId,
+        input.generation,
+        input.work.map((work) => [
+            work.intent.id,
+            work.projection.state,
+            work.projection.next_action,
+            work.projection.attempts_used,
+            work.events.length,
+        ]),
+    ]);
+}

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

@@ -0,0 +1,26 @@
+import { type EngineOpts } from "../workflow/index.js";
+import { type SupervisorPlanOutcome } from "./plan-types.js";
+import type { SupervisorRecord } from "./state.js";
+export interface RunSupervisorPlannerInput {
+    coordRoot: string;
+    record: SupervisorRecord;
+    engine: Omit<EngineOpts, "coordRoot" | "runId" | "resumeRunId" | "specialists">;
+    actor: string;
+    onLog?: (line: string) => void;
+}
+export declare function runSupervisorPlanner(input: RunSupervisorPlannerInput): Promise<SupervisorPlanOutcome>;
+export declare function applySupervisorPlanProposal(input: {
+    coordRoot: string;
+    record: SupervisorRecord;
+    planId: string;
+    actor: string;
+    reason?: string;
+}): SupervisorPlanOutcome;
+export declare function rejectSupervisorPlanProposal(input: {
+    coordRoot: string;
+    goalId: string;
+    planId: string;
+    actor: string;
+    reason: string;
+}): SupervisorPlanOutcome;
+//# sourceMappingURL=planning.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"planning.d.ts","sourceRoot":"","sources":["../../../src/core/supervisor/planning.ts"],"names":[],"mappings":"AAcA,OAAO,EACL,KAAK,UAAU,EAIhB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAGL,KAAK,qBAAqB,EAK3B,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAQnD,MAAM,WAAW,yBAAyB;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,gBAAgB,CAAC;IACzB,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,WAAW,GAAG,OAAO,GAAG,aAAa,GAAG,aAAa,CAAC,CAAC;IAChF,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAChC;AAED,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,yBAAyB,GAC/B,OAAO,CAAC,qBAAqB,CAAC,CAkGhC;AAED,wBAAgB,2BAA2B,CAAC,KAAK,EAAE;IACjD,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,gBAAgB,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,GAAG,qBAAqB,CAyFxB;AAED,wBAAgB,4BAA4B,CAAC,KAAK,EAAE;IAClD,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,qBAAqB,CAYxB"}

package/dist/core/supervisor/planning.js

@@ -0,0 +1,486 @@
+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 { 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 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);
+    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);
+        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")
+        return outcome(plan);
+    if (plan.status !== "proposed" || !plan.proposal || plan.proposal.decision !== "apply") {
+        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);
+    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) {
+    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_fingerprint: triggerFingerprint,
+        prior_root_work_id: record.projection.root_work_id,
+        workflow_run_id: `${planId}-workflow`,
+        created_at: new Date().toISOString(),
+    };
+    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");
+    const script = plannerScript(record, planId);
+    writeExclusive(join(dir, "planner.mjs"), script, "supervisor planner script");
+    return request;
+}
+function plannerScript(record, planId) {
+    const policy = record.intent.replanning;
+    if (!policy)
+        throw new Error(`supervisor ${record.intent.id} does not allow replanning`);
+    const prompt = [
+        "You are producing a bounded replacement plan for a durable supervised goal.",
+        "The current graph is blocked and cannot make a legal scheduling step.",
+        "Return decision=apply with a new immutable root graph, or decision=attention when human judgment is required.",
+        "Never claim work is complete. 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}`,
+        `Goal: ${record.intent.title}`,
+        `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}`,
+        `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,
+        })))}`,
+    ].join("\n\n");
+    const schema = {
+        type: "object",
+        properties: {
+            decision: { type: "string", enum: ["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"],
+                },
+            },
+        },
+        required: ["decision", "rationale", "root", "work"],
+    };
+    return [
+        `export const meta = ${JSON.stringify({ name: `replan-${planId}` })};`,
+        "export default async ({ agent, stage }) => {",
+        '  stage("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) {
+    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", "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") {
+        if (root || value.work.length > 0)
+            throw new Error("attention plan must not contain work");
+        return {
+            schema_version: SUPERVISOR_PLAN_SCHEMA_VERSION,
+            plan_id: planId,
+            decision,
+            rationale,
+            root: "",
+            work: [],
+            proposed_at: new Date().toISOString(),
+        };
+    }
+    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,
+        proposed_at: new Date().toISOString(),
+    };
+}
+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,3 +1,5 @@
+export { readSupervisorPlan, readSupervisorPlans } from "./plan-read.js";
+export { SUPERVISOR_PLAN_SCHEMA_VERSION, type SupervisorPlanEvent, type SupervisorPlanEventType, type SupervisorPlanHistory, 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";

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,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,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";