harnery 0.13.0 → 0.15.0

package/src/commands/supervisor.ts

@@ -0,0 +1,315 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import type { Command } from "commander";
+import type { EmitContext } from "../commander.ts";
+import { workflowSubscriptionOnly } from "../core/config.ts";
+import { createBuiltinHarnessRegistry } from "../core/harnesses/index.ts";
+import { findCoordRoot } from "../core/hooks/resolve/coord-root.ts";
+import type { PolicyIsolation } from "../core/policy/index.ts";
+import { loadPolicyFile } from "../core/policy/index.ts";
+import {
+  createSupervisor,
+  listSupervisors,
+  readSupervisor,
+  runSupervisor,
+  type SupervisorRecord,
+  type SupervisorRunReport,
+} from "../core/supervisor/index.ts";
+import type { WorkflowSpecialistProfile } from "../core/workflow/index.ts";
+
+interface CreateOpts {
+  team: string;
+  id?: string;
+  title?: string;
+  maxCycles?: string;
+  maxRuntimeMs?: string;
+  maxParallelWork?: string;
+  maxTotalAttempts?: string;
+  maxAgentsPerWork?: string;
+  agentConcurrency?: string;
+  acceptPassingProof?: boolean;
+  resumeApproved?: boolean;
+  retryBlocked?: boolean;
+  json?: boolean;
+}
+
+interface RunOpts {
+  harness?: string;
+  cwd?: string;
+  subscriptionOnly?: boolean;
+  allowApiBilling?: boolean;
+  policy?: string;
+  isolation?: PolicyIsolation;
+  approvalTo?: string;
+  actor?: string;
+  json?: boolean;
+}
+
+export function registerSupervisorCommand(program: Command, emit: EmitContext): void {
+  const registry = createBuiltinHarnessRegistry();
+  const supervisor = program
+    .command("supervisor")
+    .description("Run a bounded specialist team over a durable-work dependency graph.");
+
+  supervisor
+    .command("create <root-work-id>")
+    .description("Freeze a goal, specialist team, automation policy, and execution limits.")
+    .requiredOption("--team <file>", "JSON object mapping specialist ids to profiles")
+    .option("--id <goal-id>", "Stable goal id (generated by default)")
+    .option("--title <text>", "Goal title (defaults to root work title)")
+    .option("--max-cycles <n>", "Foreground cycle ceiling (default 50)")
+    .option("--max-runtime-ms <n>", "Foreground wall-time ceiling (default 14400000)")
+    .option("--max-parallel-work <n>", "Concurrent work-item ceiling (default 1)")
+    .option("--max-total-attempts <n>", "Graph-wide attempt ceiling (default 100)")
+    .option("--max-agents-per-work <n>", "Child-agent ceiling per work item (default 20)")
+    .option("--agent-concurrency <n>", "Child concurrency per work item (default 4)")
+    .option("--accept-passing-proof", "Allow the supervisor to explicitly accept passing proof")
+    .option("--no-resume-approved", "Stop after an approval instead of resuming its parked run")
+    .option("--retry-blocked", "Allow bounded retry of blocked work")
+    .option("--json", "Emit the complete supervisor record as JSON")
+    .action((rootWorkId: string, opts: CreateOpts) => {
+      withSupervisorRoot(emit, (coordRoot) => {
+        const specialists = readTeamFile(opts.team);
+        for (const [id, profile] of Object.entries(specialists)) {
+          if (profile.harness && !registry.get(profile.harness)) {
+            throw new Error(
+              `specialist ${id} names unknown harness ${JSON.stringify(profile.harness)}`,
+            );
+          }
+        }
+        emitSupervisor(
+          createSupervisor({
+            coordRoot,
+            rootWorkId,
+            specialists,
+            id: opts.id,
+            title: opts.title,
+            limits: {
+              max_cycles: integer(opts.maxCycles),
+              max_runtime_ms: integer(opts.maxRuntimeMs),
+              max_parallel_work: integer(opts.maxParallelWork),
+              max_total_attempts: integer(opts.maxTotalAttempts),
+              max_agents_per_work: integer(opts.maxAgentsPerWork),
+              agent_concurrency: integer(opts.agentConcurrency),
+            },
+            automation: {
+              accept_passing_proof: opts.acceptPassingProof,
+              resume_approved: opts.resumeApproved,
+              retry_blocked: opts.retryBlocked,
+            },
+          }),
+          opts.json,
+          emit,
+          true,
+        );
+      });
+    });
+
+  supervisor
+    .command("list")
+    .description("List durable goals and their derived next action.")
+    .option("--json", "Emit complete supervisor records as JSON")
+    .action((opts: { json?: boolean }) => {
+      withSupervisorRoot(emit, (coordRoot) => {
+        const records = listSupervisors(coordRoot);
+        if (opts.json) {
+          emit.config({ format: "json" });
+          emit.data(records);
+        } else if (records.length === 0) {
+          emit.text("no durable supervisors\n");
+        } else {
+          emit.text(`${records.map(renderSupervisorRow).join("\n")}\n`);
+        }
+      });
+    });
+
+  supervisor
+    .command("show <goal-id>")
+    .description("Show one goal, frozen team, bounds, graph state, and next action.")
+    .option("--json", "Emit the complete supervisor record as JSON")
+    .action((goalId: string, opts: { json?: boolean }) => {
+      withSupervisorRoot(emit, (coordRoot) => {
+        emitSupervisor(readSupervisor(coordRoot, goalId), opts.json, emit, true);
+      });
+    });
+
+  registerRunCommand(supervisor, "tick", registry, emit);
+  registerRunCommand(supervisor, "run", registry, emit);
+}
+
+function registerRunCommand(
+  supervisor: Command,
+  mode: "tick" | "run",
+  registry: ReturnType<typeof createBuiltinHarnessRegistry>,
+  emit: EmitContext,
+): void {
+  supervisor
+    .command(`${mode} <goal-id>`)
+    .description(
+      mode === "tick"
+        ? "Perform at most one bounded scheduling cycle."
+        : "Run bounded cycles until success, attention, no progress, or budget exhaustion.",
+    )
+    .option("--harness <name>", "Fallback harness for agent calls without a specialist")
+    .option("--cwd <dir>", "Working directory for child agents")
+    .option("--subscription-only", "Require stored harness-login billing")
+    .option("--allow-api-billing", "Permit API-key override billing")
+    .option("--policy <file>", "Host policy JSON/JSONC")
+    .option("--isolation <mode>", "shared | worktree | sandbox | remote")
+    .option("--approval-to <address>", "Address durable ASK requests")
+    .option("--actor <name>", "Actor recorded on supervisor work decisions")
+    .option("--json", "Emit the complete run report as JSON")
+    .action(async (goalId: string, opts: RunOpts) => {
+      await withSupervisorRootAsync(emit, async (coordRoot) => {
+        if (opts.harness && !registry.get(opts.harness)) {
+          throw new Error(`unknown harness ${JSON.stringify(opts.harness)}`);
+        }
+        const report = await runSupervisor({
+          coordRoot,
+          goalId,
+          mode,
+          actor: opts.actor,
+          onLog: opts.json ? undefined : (line) => emit.text(`${line}\n`),
+          engine: {
+            spawners: registry.spawners(),
+            defaultHarness: opts.harness,
+            cwd: opts.cwd,
+            subscriptionOnly:
+              opts.subscriptionOnly === true ? true : workflowSubscriptionOnly(coordRoot),
+            allowApiBilling: opts.allowApiBilling,
+            harnessEvidence: Object.fromEntries(
+              registry
+                .list()
+                .map((adapter) => [
+                  adapter.profile.id,
+                  { toolEvidence: adapter.profile.capabilities.toolEvidence },
+                ]),
+            ),
+            policy: opts.policy ? loadPolicyFile(opts.policy) : undefined,
+            approvalMode: "park",
+            approvalAddressee: opts.approvalTo,
+            isolation: opts.isolation,
+            networkAccess: "enabled",
+          },
+        });
+        emitSupervisorReport(report, opts.json, emit);
+      });
+    });
+}
+
+function readTeamFile(path: string): Record<string, WorkflowSpecialistProfile> {
+  const absolute = resolve(path);
+  let value: unknown;
+  try {
+    value = JSON.parse(readFileSync(absolute, "utf8"));
+  } catch (error) {
+    throw new Error(`cannot read supervisor team at ${absolute}: ${(error as Error).message}`);
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("supervisor team must be a JSON object keyed by specialist id");
+  }
+  return value as Record<string, WorkflowSpecialistProfile>;
+}
+
+function emitSupervisor(
+  record: SupervisorRecord,
+  json: boolean | undefined,
+  emit: EmitContext,
+  detail = false,
+): void {
+  if (json) {
+    emit.config({ format: "json" });
+    emit.data(record);
+    return;
+  }
+  if (!detail) {
+    emit.text(`${renderSupervisorRow(record)}\n`);
+    return;
+  }
+  const projection = record.projection;
+  const lines = [
+    `${record.intent.id}: ${record.intent.title}`,
+    `state: ${projection.state}`,
+    `root: ${record.intent.root_work_id}`,
+    `reason: ${projection.reason}`,
+    `next: ${projection.next_action}`,
+    `work: ${projection.work_ids.length}`,
+    `attempts: ${projection.attempts_used}/${record.intent.limits.max_total_attempts}`,
+    `specialists: ${projection.specialists.join(", ") || "none"}`,
+    `automation: accept=${record.intent.automation.accept_passing_proof}, ` +
+      `resume=${record.intent.automation.resume_approved}, retry=${record.intent.automation.retry_blocked}`,
+  ];
+  if (projection.attention_work.length) {
+    lines.push(`attention: ${projection.attention_work.join(", ")}`);
+  }
+  emit.text(`${lines.join("\n")}\n`);
+}
+
+function emitSupervisorReport(
+  report: SupervisorRunReport,
+  json: boolean | undefined,
+  emit: EmitContext,
+): void {
+  if (json) {
+    emit.config({ format: "json" });
+    emit.data(report);
+    return;
+  }
+  emit.text(
+    `supervisor ${report.goal_id}: ${report.stop_reason}\n` +
+      `reason: ${report.reason}\n` +
+      `cycles: ${report.cycles}; dispatches: ${report.dispatches}; acceptances: ${report.acceptances}\n` +
+      `state: ${report.projection.state}; next: ${report.projection.next_action}\n`,
+  );
+}
+
+function renderSupervisorRow(record: SupervisorRecord): string {
+  const projection = record.projection;
+  return `${record.intent.id}  ${projection.state.padEnd(20)}  ${projection.attempts_used}/${record.intent.limits.max_total_attempts}  ${projection.next_action.padEnd(18)}  ${record.intent.title}`;
+}
+
+function integer(value: string | undefined): number | undefined {
+  if (value === undefined) return undefined;
+  if (!/^\d+$/.test(value))
+    throw new Error(`expected a positive integer, got ${JSON.stringify(value)}`);
+  return Number.parseInt(value, 10);
+}
+
+function withSupervisorRoot(emit: EmitContext, fn: (coordRoot: string) => void): void {
+  const coordRoot = findCoordRoot();
+  if (!coordRoot) {
+    emit.error({
+      code: "no_coord_root",
+      message: "no .harnery/ coordination root found; run `init` first",
+    });
+    emit.setExitCode(1);
+    return;
+  }
+  try {
+    fn(coordRoot);
+  } catch (error) {
+    emit.error({ code: "supervisor_failed", message: (error as Error).message });
+    emit.setExitCode(1);
+  }
+}
+
+async function withSupervisorRootAsync(
+  emit: EmitContext,
+  fn: (coordRoot: string) => Promise<void>,
+): Promise<void> {
+  const coordRoot = findCoordRoot();
+  if (!coordRoot) {
+    emit.error({
+      code: "no_coord_root",
+      message: "no .harnery/ coordination root found; run `init` first",
+    });
+    emit.setExitCode(1);
+    return;
+  }
+  try {
+    await fn(coordRoot);
+  } catch (error) {
+    emit.error({ code: "supervisor_failed", message: (error as Error).message });
+    emit.setExitCode(1);
+  }
+}

package/src/commands/work.ts

@@ -0,0 +1,367 @@
+import type { Command } from "commander";
+import type { EmitContext } from "../commander.ts";
+import { workflowSubscriptionOnly } from "../core/config.ts";
+import { createBuiltinHarnessRegistry } from "../core/harnesses/index.ts";
+import { findCoordRoot } from "../core/hooks/resolve/coord-root.ts";
+import type { PolicyIsolation } from "../core/policy/index.ts";
+import { loadPolicyFile } from "../core/policy/index.ts";
+import {
+  acceptWorkItem,
+  cancelWorkItem,
+  createWorkItem,
+  listWorkItems,
+  readWorkItem,
+  reconcileAllWorkItems,
+  reconcileWorkItem,
+  reopenWorkItem,
+  runWorkItem,
+  type WorkRecord,
+} from "../core/work/index.ts";
+import { WorkflowParkedError } from "../core/workflow/index.ts";
+
+interface WorkCreateOpts {
+  id?: string;
+  accept?: string[];
+  dependsOn?: string;
+  maxAttempts?: string;
+  sourceKind?: "human" | "workflow" | "external";
+  sourceRef?: string;
+  actor?: string;
+  json?: boolean;
+}
+
+interface WorkRunOpts {
+  harness?: string;
+  maxAgents?: string;
+  concurrency?: string;
+  cwd?: string;
+  subscriptionOnly?: boolean;
+  allowApiBilling?: boolean;
+  policy?: string;
+  isolation?: PolicyIsolation;
+  approvalTo?: string;
+  actor?: string;
+  json?: boolean;
+}
+
+interface GovernanceOpts {
+  actor?: string;
+  reason?: string;
+  json?: boolean;
+}
+
+export function registerWorkCommand(program: Command, emit: EmitContext): void {
+  const registry = createBuiltinHarnessRegistry();
+  const harnesses = registry.ids();
+  const work = program
+    .command("work")
+    .description("Track durable objectives across bounded workflow attempts.");
+
+  work
+    .command("create <title> <workflow>")
+    .description("Create an immutable durable-work intent linked to a workflow script.")
+    .requiredOption("--objective <text>", "Objective that must survive execution attempts")
+    .option("--id <work-id>", "Stable work id (generated by default)")
+    .option("--accept <text>", "Acceptance statement; repeat for more than one", collect, [])
+    .option("--depends-on <ids>", "Comma-separated prerequisite work ids")
+    .option("--max-attempts <n>", "Attempt ceiling (default 3)")
+    .option("--source-kind <kind>", "human | workflow | external", "human")
+    .option("--source-ref <ref>", "Bounded source reference")
+    .option("--actor <name>", "Actor recorded in the creation receipt")
+    .option("--json", "Emit the complete work record as JSON")
+    .action((title: string, workflowPath: string, opts: WorkCreateOpts & { objective: string }) => {
+      withWorkRoot(emit, (coordRoot) => {
+        const record = createWorkItem({
+          coordRoot,
+          id: opts.id,
+          title,
+          objective: opts.objective,
+          workflowPath,
+          acceptance: opts.accept,
+          dependencies: splitIds(opts.dependsOn),
+          maxAttempts: opts.maxAttempts ? Number.parseInt(opts.maxAttempts, 10) : undefined,
+          source: opts.sourceKind ? { kind: opts.sourceKind, ref: opts.sourceRef } : undefined,
+          actor: opts.actor,
+        });
+        emitWork(record, opts.json, emit);
+      });
+    });
+
+  work
+    .command("list")
+    .description("List durable work with its currently derived state.")
+    .option("--state <state>", "Filter by derived state")
+    .option("--json", "Emit complete work records as JSON")
+    .action((opts: { state?: string; json?: boolean }) => {
+      withWorkRoot(emit, (coordRoot) => {
+        const records = listWorkItems(coordRoot).filter(
+          (record) => !opts.state || record.projection.state === opts.state,
+        );
+        if (opts.json) {
+          emit.config({ format: "json" });
+          emit.data(records);
+        } else if (records.length === 0) {
+          emit.text("no durable work\n");
+        } else {
+          emit.text(`${records.map(renderWorkRow).join("\n")}\n`);
+        }
+      });
+    });
+
+  work
+    .command("show <work-id>")
+    .description("Show one work item, its attempts, and the next explicit action.")
+    .option("--json", "Emit the complete work record as JSON")
+    .action((workId: string, opts: { json?: boolean }) => {
+      withWorkRoot(emit, (coordRoot) => {
+        emitWork(readWorkItem(coordRoot, workId), opts.json, emit, true);
+      });
+    });
+
+  work
+    .command("reconcile [work-id]")
+    .description("Derive state from durable evidence without starting or retrying work.")
+    .option("--actor <name>", "Actor recorded on changed reconciliation receipts")
+    .option("--json", "Emit reconciled work records as JSON")
+    .action((workId: string | undefined, opts: { actor?: string; json?: boolean }) => {
+      withWorkRoot(emit, (coordRoot) => {
+        const records = workId
+          ? [reconcileWorkItem(coordRoot, workId, opts.actor)]
+          : reconcileAllWorkItems(coordRoot, opts.actor);
+        if (opts.json) {
+          emit.config({ format: "json" });
+          emit.data(workId ? records[0] : records);
+        } else if (records.length === 0) {
+          emit.text("no durable work\n");
+        } else {
+          emit.text(`${records.map(renderWorkRow).join("\n")}\n`);
+        }
+      });
+    });
+
+  registerRunCommand(work, "run", false, registry, harnesses, emit);
+  registerRunCommand(work, "retry", true, registry, harnesses, emit);
+  registerGovernanceCommand(work, "accept", emit);
+  registerGovernanceCommand(work, "cancel", emit);
+  registerGovernanceCommand(work, "reopen", emit);
+}
+
+function registerRunCommand(
+  work: Command,
+  name: "run" | "retry",
+  retry: boolean,
+  registry: ReturnType<typeof createBuiltinHarnessRegistry>,
+  harnesses: string[],
+  emit: EmitContext,
+): void {
+  work
+    .command(`${name} <work-id>`)
+    .description(
+      retry
+        ? "Start a new bounded attempt after a blocked run."
+        : "Start ready work or resume its resolved parked attempt.",
+    )
+    .option("--max-agents <n>", "Total-agent ceiling for the workflow")
+    .option("--concurrency <n>", "Concurrent-subagent cap")
+    .option("--cwd <dir>", "Working directory children spawn in")
+    .option("--harness <name>", `Default harness: ${harnesses.join(" | ")}`)
+    .option("--subscription-only", "Require stored harness-login billing")
+    .option("--allow-api-billing", "Permit API-key override billing")
+    .option("--policy <file>", "Host policy JSON/JSONC")
+    .option("--isolation <mode>", "shared | worktree | sandbox | remote")
+    .option("--approval-to <address>", "Address durable ASK requests")
+    .option("--actor <name>", "Actor recorded in attempt receipts")
+    .option("--json", "Emit the workflow report or parked result as JSON")
+    .action(async (workId: string, opts: WorkRunOpts) => {
+      await withWorkRootAsync(emit, async (coordRoot) => {
+        if (opts.harness && !registry.get(opts.harness)) {
+          throw new Error(`unknown harness ${JSON.stringify(opts.harness)}`);
+        }
+        try {
+          const report = await runWorkItem({
+            coordRoot,
+            workId,
+            retry,
+            actor: opts.actor,
+            engine: {
+              spawners: registry.spawners(),
+              defaultHarness: opts.harness,
+              maxAgents: opts.maxAgents ? Number.parseInt(opts.maxAgents, 10) : undefined,
+              concurrency: opts.concurrency ? Number.parseInt(opts.concurrency, 10) : undefined,
+              cwd: opts.cwd,
+              subscriptionOnly:
+                opts.subscriptionOnly === true ? true : workflowSubscriptionOnly(coordRoot),
+              allowApiBilling: opts.allowApiBilling,
+              harnessEvidence: Object.fromEntries(
+                registry
+                  .list()
+                  .map((adapter) => [
+                    adapter.profile.id,
+                    { toolEvidence: adapter.profile.capabilities.toolEvidence },
+                  ]),
+              ),
+              policy: opts.policy ? loadPolicyFile(opts.policy) : undefined,
+              approvalMode: "park",
+              approvalAddressee: opts.approvalTo,
+              isolation: opts.isolation,
+              networkAccess: "enabled",
+            },
+          });
+          if (opts.json) {
+            emit.config({ format: "json" });
+            emit.data(report);
+          } else {
+            emit.text(
+              `work ${workId}: run ${report.runId} finished\nproof: ${report.proofPath}\n` +
+                `next: harn work reconcile ${workId}\n`,
+            );
+          }
+        } catch (error) {
+          if (error instanceof WorkflowParkedError) {
+            if (opts.json) {
+              emit.config({ format: "json" });
+              emit.data({
+                status: "parked",
+                workId,
+                runId: error.runId,
+                approvalId: error.approvalId,
+                journalPath: error.journalPath,
+              });
+            } else {
+              emit.text(
+                `work ${workId}: run ${error.runId} parked\napproval: ${error.approvalId}\n` +
+                  `next: resolve the approval, then harn work run ${workId}\n`,
+              );
+            }
+            return;
+          }
+          throw error;
+        }
+      });
+    });
+}
+
+function registerGovernanceCommand(
+  work: Command,
+  name: "accept" | "cancel" | "reopen",
+  emit: EmitContext,
+): void {
+  work
+    .command(`${name} <work-id>`)
+    .description(
+      name === "accept"
+        ? "Explicitly accept reviewed proof and complete the objective."
+        : name === "cancel"
+          ? "Explicitly cancel unfinished durable work."
+          : "Explicitly reopen terminal or blocked work for a future attempt.",
+    )
+    .option("--actor <name>", "Actor recorded in the governance receipt")
+    .option("--reason <text>", "Bounded decision reason")
+    .option("--json", "Emit the complete work record as JSON")
+    .action((workId: string, opts: GovernanceOpts) => {
+      withWorkRoot(emit, (coordRoot) => {
+        const fn =
+          name === "accept" ? acceptWorkItem : name === "cancel" ? cancelWorkItem : reopenWorkItem;
+        emitWork(fn(coordRoot, workId, opts), opts.json, emit, true);
+      });
+    });
+}
+
+function emitWork(
+  record: WorkRecord,
+  json: boolean | undefined,
+  emit: EmitContext,
+  detail = false,
+) {
+  if (json) {
+    emit.config({ format: "json" });
+    emit.data(record);
+    return;
+  }
+  if (!detail) {
+    emit.text(`${renderWorkRow(record)}\n`);
+    return;
+  }
+  const projection = record.projection;
+  const lines = [
+    `${record.intent.id}: ${record.intent.title}`,
+    `state: ${projection.state}`,
+    `objective: ${record.intent.objective}`,
+    `reason: ${projection.reason}`,
+    `next: ${projection.next_action}`,
+    `attempts: ${projection.attempts_used}/${record.intent.max_attempts}`,
+  ];
+  if (record.intent.dependencies.length)
+    lines.push(`depends on: ${record.intent.dependencies.join(", ")}`);
+  if (record.intent.acceptance.length) {
+    lines.push("acceptance:", ...record.intent.acceptance.map((item) => `  - ${item}`));
+  }
+  if (projection.attempts.length) {
+    lines.push(
+      "attempts:",
+      ...projection.attempts.map(
+        (attempt) => `  ${attempt.number}. ${attempt.run_id}  ${attempt.status}`,
+      ),
+    );
+  }
+  if (projection.approval_id) lines.push(`approval: ${projection.approval_id}`);
+  if (projection.proof_path) lines.push(`proof: ${projection.proof_path}`);
+  emit.text(`${lines.join("\n")}\n`);
+}
+
+function renderWorkRow(record: WorkRecord): string {
+  const projection = record.projection;
+  return `${record.intent.id}  ${projection.state.padEnd(17)}  ${projection.attempts_used}/${record.intent.max_attempts}  ${projection.next_action.padEnd(21)}  ${record.intent.title}`;
+}
+
+function withWorkRoot(emit: EmitContext, fn: (coordRoot: string) => void): void {
+  const coordRoot = findCoordRoot();
+  if (!coordRoot) {
+    emit.error({
+      code: "no_coord_root",
+      message: "no .harnery/ coordination root found; run `init` first",
+    });
+    emit.setExitCode(1);
+    return;
+  }
+  try {
+    fn(coordRoot);
+  } catch (error) {
+    emit.error({ code: "work_failed", message: (error as Error).message });
+    emit.setExitCode(1);
+  }
+}
+
+async function withWorkRootAsync(
+  emit: EmitContext,
+  fn: (coordRoot: string) => Promise<void>,
+): Promise<void> {
+  const coordRoot = findCoordRoot();
+  if (!coordRoot) {
+    emit.error({
+      code: "no_coord_root",
+      message: "no .harnery/ coordination root found; run `init` first",
+    });
+    emit.setExitCode(1);
+    return;
+  }
+  try {
+    await fn(coordRoot);
+  } catch (error) {
+    emit.error({ code: "work_failed", message: (error as Error).message });
+    emit.setExitCode(1);
+  }
+}
+
+function splitIds(value?: string): string[] {
+  return value
+    ? value
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean)
+    : [];
+}
+
+function collect(value: string, previous: string[]): string[] {
+  return [...previous, value];
+}

package/src/core/supervisor/index.ts

@@ -0,0 +1,24 @@
+export {
+  type RunSupervisorInput,
+  runSupervisor,
+  type SupervisorDispatchOutcome,
+  type SupervisorRunReport,
+  type SupervisorStopReason,
+} from "./runner.ts";
+export {
+  assertSupervisorId,
+  type CreateSupervisorInput,
+  collectSupervisorWork,
+  createSupervisor,
+  listSupervisors,
+  newSupervisorId,
+  readSupervisor,
+  SUPERVISOR_INTENT_SCHEMA_VERSION,
+  type SupervisorAutomationPolicy,
+  type SupervisorIntent,
+  type SupervisorLimits,
+  type SupervisorNextAction,
+  type SupervisorProjection,
+  type SupervisorRecord,
+  type SupervisorState,
+} from "./state.ts";