harnery 0.12.2 → 0.14.0

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/commands/workflow.ts

@@ -5,6 +5,8 @@ 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 type { WorkflowApprovalStatus } from "../core/workflow/approvals.ts";
+import { WorkflowParkedError } from "../core/workflow/engine.ts";
 
 /**
  * `workflow run <script>`: execute a workflow script — bounded, schema-gated,
@@ -26,6 +28,7 @@ interface WorkflowRunOpts {
   allowApiBilling?: boolean;
   policy?: string;
   isolation?: PolicyIsolation;
+  approvalTo?: string;
   json?: boolean;
 }
 
@@ -33,6 +36,17 @@ interface WorkflowProofOpts {
   json?: boolean;
 }
 
+interface WorkflowApprovalListOpts {
+  status?: WorkflowApprovalStatus;
+  json?: boolean;
+}
+
+interface WorkflowApprovalDecisionOpts {
+  actor?: string;
+  reason?: string;
+  json?: boolean;
+}
+
 export function registerWorkflowCommand(program: Command, emit: EmitContext): void {
   const registry = createBuiltinHarnessRegistry();
   const harnesses = registry.ids();
@@ -75,6 +89,7 @@ export function registerWorkflowCommand(program: Command, emit: EmitContext): vo
       "--isolation <mode>",
       "Host-created execution boundary: shared | worktree | sandbox | remote (default shared)",
     )
+    .option("--approval-to <address>", "Address durable ASK requests (default: operator)")
     .option("--json", "Emit the full RunReport as JSON")
     .action(async (script: string, opts: WorkflowRunOpts) => {
       const coordRoot = findCoordRoot();
@@ -134,6 +149,8 @@ export function registerWorkflowCommand(program: Command, emit: EmitContext): vo
               ]),
           ),
           policy: opts.policy ? loadPolicyFile(opts.policy) : undefined,
+          approvalMode: "park",
+          approvalAddressee: opts.approvalTo,
           isolation: opts.isolation,
           // CLI harness subprocesses inherit the host network. A policy that
           // forbids network must therefore deny dispatch unless a future host
@@ -159,6 +176,24 @@ export function registerWorkflowCommand(program: Command, emit: EmitContext): vo
             `result: ${typeof report.result === "string" ? report.result : JSON.stringify(report.result, null, 2)}\n`,
         );
       } catch (err) {
+        if (err instanceof WorkflowParkedError) {
+          if (opts.json) {
+            emit.config({ format: "json" });
+            emit.data({
+              status: "parked",
+              runId: err.runId,
+              approvalId: err.approvalId,
+              journalPath: err.journalPath,
+            });
+          } else {
+            emit.text(
+              `run ${err.runId} parked\napproval: ${err.approvalId}\n` +
+                `journal: ${err.journalPath}\n` +
+                `resume after resolution: harn workflow resume ${err.runId}\n`,
+            );
+          }
+          return;
+        }
         const proofPath =
           typeof err === "object" && err !== null && "proofPath" in err
             ? String(err.proofPath)
@@ -171,6 +206,197 @@ export function registerWorkflowCommand(program: Command, emit: EmitContext): vo
       }
     });
 
+  workflow
+    .command("resume <run-id>")
+    .description("Resume a parked workflow after its durable approval has been resolved.")
+    .option("--json", "Emit the full RunReport or parked result as JSON")
+    .action(async (runId: string, opts: { json?: boolean }) => {
+      const coordRoot = findCoordRoot();
+      if (!coordRoot) {
+        emit.error({
+          code: "no_coord_root",
+          message: "no .harnery/ coordination root found; run `init` first",
+        });
+        process.exit(1);
+      }
+      try {
+        const { assertWorkflowRunResumable, runWorkflow } = await import(
+          "../core/workflow/index.ts"
+        );
+        const { manifest } = assertWorkflowRunResumable(coordRoot, runId);
+        const report = await runWorkflow(manifest.script.path, {
+          coordRoot,
+          spawners: registry.spawners(),
+          resumeRunId: runId,
+          harnessEvidence: Object.fromEntries(
+            registry
+              .list()
+              .map((adapter) => [
+                adapter.profile.id,
+                { toolEvidence: adapter.profile.capabilities.toolEvidence },
+              ]),
+          ),
+        });
+        if (opts.json) {
+          emit.config({ format: "json" });
+          emit.data(report);
+          return;
+        }
+        const cachedPart = report.agentsCached > 0 ? ` (+${report.agentsCached} cached)` : "";
+        emit.text(
+          `run ${report.runId} (${report.name}) finished: ${report.agentsSpawned} agent(s)${cachedPart}, ` +
+            `$${report.costUsd.toFixed(4)}, ${Math.round(report.durationMs / 1000)}s\n` +
+            `acceptance: ${report.acceptance.satisfied} satisfied, ${report.acceptance.unsatisfied} unsatisfied, ` +
+            `${report.acceptance.unknown} unknown\n` +
+            `journal: ${report.journalPath}\nproof: ${report.proofPath}\n` +
+            `result: ${typeof report.result === "string" ? report.result : JSON.stringify(report.result, null, 2)}\n`,
+        );
+      } catch (err) {
+        if (err instanceof WorkflowParkedError) {
+          if (opts.json) {
+            emit.config({ format: "json" });
+            emit.data({
+              status: "parked",
+              runId: err.runId,
+              approvalId: err.approvalId,
+              journalPath: err.journalPath,
+            });
+          } else {
+            emit.text(
+              `run ${err.runId} parked again\napproval: ${err.approvalId}\n` +
+                `journal: ${err.journalPath}\n`,
+            );
+          }
+          return;
+        }
+        const proofPath =
+          typeof err === "object" && err !== null && "proofPath" in err
+            ? String(err.proofPath)
+            : undefined;
+        emit.error({
+          code: "workflow_resume_failed",
+          message: `${(err as Error).message}${proofPath ? `\nproof: ${proofPath}` : ""}`,
+        });
+        process.exit(1);
+      }
+    });
+
+  const approvals = workflow
+    .command("approvals")
+    .description("Inspect and resolve durable workflow policy approvals.");
+
+  approvals
+    .command("list")
+    .description("List durable workflow approvals.")
+    .option("--status <status>", "Filter: pending | approved | denied")
+    .option("--json", "Emit approval records as JSON")
+    .action(async (opts: WorkflowApprovalListOpts) => {
+      const coordRoot = findCoordRoot();
+      if (!coordRoot) {
+        emit.error({ code: "no_coord_root", message: "no .harnery/ coordination root found" });
+        process.exit(1);
+      }
+      if (opts.status && !(["pending", "approved", "denied"] as const).includes(opts.status)) {
+        emit.error({
+          code: "bad_approval_status",
+          message: `unknown approval status ${JSON.stringify(opts.status)}`,
+        });
+        process.exit(1);
+      }
+      const { listWorkflowApprovals } = await import("../core/workflow/approvals.ts");
+      const records = listWorkflowApprovals(coordRoot, { status: opts.status });
+      if (opts.json) {
+        emit.config({ format: "json" });
+        emit.data(records);
+        return;
+      }
+      if (records.length === 0) {
+        emit.text("no workflow approvals\n");
+        return;
+      }
+      emit.text(
+        `${records
+          .map(
+            ({ request, status }) =>
+              `${request.id}  ${status.padEnd(8)}  ${request.run_id}  ${request.request.phase}  ${request.request.action}  -> ${request.addressed_to}`,
+          )
+          .join("\n")}\n`,
+      );
+    });
+
+  approvals
+    .command("show <approval-id>")
+    .description("Show one durable workflow approval.")
+    .option("--json", "Emit the approval record as JSON")
+    .action(async (approvalId: string, opts: { json?: boolean }) => {
+      const coordRoot = findCoordRoot();
+      if (!coordRoot) {
+        emit.error({ code: "no_coord_root", message: "no .harnery/ coordination root found" });
+        process.exit(1);
+      }
+      try {
+        const { readWorkflowApproval, renderWorkflowApproval } = await import(
+          "../core/workflow/approvals.ts"
+        );
+        const approval = readWorkflowApproval(coordRoot, approvalId);
+        if (opts.json) {
+          emit.config({ format: "json" });
+          emit.data(approval);
+        } else {
+          emit.text(renderWorkflowApproval(approval));
+        }
+      } catch (err) {
+        emit.error({ code: "workflow_approval_read_failed", message: (err as Error).message });
+        process.exit(1);
+      }
+    });
+
+  const registerApprovalDecision = (command: "approve" | "deny", verdict: "allow" | "deny") => {
+    approvals
+      .command(`${command} <approval-id>`)
+      .description(`${command === "approve" ? "Approve" : "Deny"} a pending workflow approval.`)
+      .option("--actor <name>", "Decision actor recorded in the receipt")
+      .option("--reason <text>", "Bounded decision reason")
+      .option("--json", "Emit the resolved approval as JSON")
+      .action(async (approvalId: string, opts: WorkflowApprovalDecisionOpts) => {
+        const coordRoot = findCoordRoot();
+        if (!coordRoot) {
+          emit.error({ code: "no_coord_root", message: "no .harnery/ coordination root found" });
+          process.exit(1);
+        }
+        try {
+          const { resolveWorkflowApproval, renderWorkflowApproval } = await import(
+            "../core/workflow/approvals.ts"
+          );
+          const resolved = resolveWorkflowApproval({
+            coordRoot,
+            approvalId,
+            verdict,
+            actor: opts.actor ?? process.env.USER ?? process.env.USERNAME ?? "operator",
+            reason: opts.reason,
+          });
+          if (opts.json) {
+            emit.config({ format: "json" });
+            emit.data(resolved);
+          } else {
+            emit.text(
+              `${renderWorkflowApproval(resolved.approval)}` +
+                `${resolved.applied ? "decision recorded" : "decision already recorded"}\n` +
+                `resume: harn workflow resume ${resolved.approval.request.run_id}\n`,
+            );
+          }
+        } catch (err) {
+          emit.error({
+            code: "workflow_approval_resolution_failed",
+            message: (err as Error).message,
+          });
+          process.exit(1);
+        }
+      });
+  };
+  registerApprovalDecision("approve", "allow");
+  registerApprovalDecision("deny", "deny");
+
   workflow
     .command("proof <run-id>")
     .description("Show the bounded proof packet for a completed workflow run.")

package/src/core/policy/types.ts

@@ -86,7 +86,7 @@ export interface PolicyDecision {
   phase: PolicyPhase;
   initial_verdict: PolicyVerdict;
   verdict: "allow" | "deny";
-  resolved_by: "policy" | "host" | "fail_closed";
+  resolved_by: "policy" | "host" | "approval" | "fail_closed";
   reason: string;
   rule_codes: string[];
   request: PolicyRequestSummary;

package/src/core/work/index.ts

@@ -0,0 +1,24 @@
+export { type RunWorkItemInput, runWorkItem } from "./runner.ts";
+export {
+  acceptWorkItem,
+  assertWorkId,
+  type CreateWorkItemInput,
+  cancelWorkItem,
+  createWorkItem,
+  listWorkItems,
+  newWorkId,
+  readWorkItem,
+  reconcileAllWorkItems,
+  reconcileWorkItem,
+  reopenWorkItem,
+  WORK_EVENT_SCHEMA_VERSION,
+  WORK_INTENT_SCHEMA_VERSION,
+  type WorkAttempt,
+  type WorkEvent,
+  type WorkEventType,
+  type WorkIntent,
+  type WorkNextAction,
+  type WorkProjection,
+  type WorkRecord,
+  type WorkState,
+} from "./state.ts";

package/src/core/work/read.ts

@@ -0,0 +1,15 @@
+export {
+  assertWorkId,
+  listWorkItems,
+  readWorkItem,
+  WORK_EVENT_SCHEMA_VERSION,
+  WORK_INTENT_SCHEMA_VERSION,
+  type WorkAttempt,
+  type WorkEvent,
+  type WorkEventType,
+  type WorkIntent,
+  type WorkNextAction,
+  type WorkProjection,
+  type WorkRecord,
+  type WorkState,
+} from "./state.ts";