Architecture

┌─────────────────────────────────────────────────────┐
│  Control Plane                                       │
│  defineWorkflow()  runWorkflow()                     │
│  WorkflowDefinition  WorkflowDefinitionHash          │
└────────────────────┬────────────────────────────────┘
                     │
┌────────────────────▼────────────────────────────────┐
│  Harness Layer                                       │
│  Harness contract  workflowHarness (default)             │
│  Roles: Planner · Orchestrator · Worker · Fixer      │
│  harness.session.* / harness.model.* / harness.tool_call.* │
└────────────────────┬────────────────────────────────┘
                     │ spawns
┌────────────────────▼────────────────────────────────┐
│  Sub-Run Layer                                       │
│  Orchestrator → plan_workflow / run_workflow          │
│  Sub-workflows: own WorkflowVersion + event log      │
│  Per-step LWIR scheduler (unchanged)       │
└────────────────────┬────────────────────────────────┘
                     │
┌────────────────────▼────────────────────────────────┐
│  Storage Layer                                       │
│  LocalWorld (events/ artifacts/ locks/)              │
│  Memory Stores (/mnt/memory/workflow|pipeline|org/)  │
│  Run Scratch (/mnt/scratch/own|from-*/peer-steps/)   │
└─────────────────────────────────────────────────────┘

type Harness = {
  run(task: HarnessTask, ctx: HarnessContext): Promise<HarnessResult>;
};

type HarnessTask =
  | { kind: "plan";         workflowSnapshot; input }
  | { kind: "orchestrate";  available; input }
  | { kind: "execute_step"; step; stepInput }
  | { kind: "fix_step";     step; error; attempts };

packages/little-workflow/src/
  authoring.ts          defineWorkflow(), runWorkflow(), runOrchestration(), model(), skill(), types
  fixed-plan.ts         defineWorkflow({ plan }) — the fixed-plan planner harness
  tool-registry.ts      createToolRegistry() — AI SDK tool({...}) as the primitive
  schema.ts             schema + output-mode normalization (JSON Schema / Zod)
  canonical.ts          canonical JSON + sha256 digest
  lwir.ts               LWIR types, Ajv validator, structural + expression checks
  expressions.ts        deterministic {{ ... }} expression language
  compiler.ts           compile pipeline (WorkflowDefinitionSnapshot → LWIR → WorkflowVersion)
  compiler-lock.ts      WorkflowVersion + validation hashes
  harness/
    types.ts            re-exports Harness, HarnessTask, HarnessContext, HarnessResult, event types (defined in little-harness)
    event-recorder.ts   HarnessEventRecorder — writes harness.session.*, harness.model.*, harness.tool_call.* events
  memory.ts             Memory Store mount construction + path enforcement
  scratch.ts            Run Scratch mount construction + hierarchy
  skills.ts             Skill loading + system-prompt injection
  orchestrator.ts       plan_workflow / run_workflow / start_workflow tool implementations
  run-state.ts          materializeRunStateFromEvents — folds event stream into MaterializedRunState
  world.ts              Local World: events, artifacts, manifests, locks
  outer-loop.ts         outer-loop scheduler + manifest read/write (Layer B)
  runtime.ts            LWIR step scheduler + worker harness dispatch
  replay.ts             replayRun() helper
  model-registry.ts     bundled model registry (pricing, capabilities, context window)
  pricing.ts            the single tokens -> USD site (priceModelCall, UsageTotals)
  run-report.ts         per-step tokens / cache-hit share / dollars from run state
  cli-core.ts           little validate | run | events | replay | report
  cli.ts                process.argv entry
  index.ts              the root entry: an explicit export list (src/index.test.ts pins it)
  entries/              the /lwir, /eval and /internals entry points