@goah/cli 0.13.0 → 0.13.1

package/dist/testkit.d.ts

@@ -1,2 +1,564 @@
-export * from "goah-testkit";
-//# sourceMappingURL=testkit.d.ts.map
+import { DatabaseSync } from 'node:sqlite';
+
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+/** One append request. Sequence numbers are assigned by the ledger. */
+interface EventInput {
+    streamId: string;
+    ts: string;
+    actor: string;
+    type: string;
+    data: JsonValue;
+    /** An unfamiliar reader may skip this event without changing replay semantics. */
+    ignorable?: true;
+}
+/** One immutable fact in the global ledger and in one logical stream. */
+interface EventRecord extends EventInput {
+    seq: number;
+    streamSeq: number;
+}
+interface EventStore {
+    appendEvent(input: EventInput): EventRecord;
+    appendEvents(inputs: EventInput[]): EventRecord[];
+    readStream(streamId: string, fromStreamSeq?: number): EventRecord[];
+    eventsSince(seq: number, types?: string[]): EventRecord[];
+    events(): EventRecord[];
+}
+interface Clock {
+    now(): Date;
+}
+
+type WakeStatus = "queued" | "claimed" | "consumed" | "cancelled";
+type WakeTriggerStatus = "pending" | "resolved";
+type ScheduleStatus = "pending" | "consumed" | "cancelled" | "superseded";
+type GoalPhase = "active" | "paused" | "blocked" | "complete";
+type TurnStatus = "in_progress" | "completed" | "failed" | "interrupted";
+type TurnTriggerKind = "user_message" | "wake";
+type SpecialistRole = "verifier" | "audit";
+type AgentRole = "child" | "ceo" | "verifier" | "audit";
+type AutomaticTarget = {
+    targetKind: "goal";
+    agent: string;
+    goalId: string;
+    specialistRole: null;
+} | {
+    targetKind: "specialist";
+    agent: string;
+    goalId: null;
+    specialistRole: SpecialistRole;
+};
+type MailRoute = {
+    routeKind: "goal";
+    goalId: string;
+    specialistRole: null;
+} | {
+    routeKind: "human_inbox";
+    goalId: null;
+    specialistRole: null;
+} | {
+    routeKind: "human_request";
+    goalId: null;
+    specialistRole: null;
+} | {
+    routeKind: "specialist_inbox";
+    goalId: null;
+    specialistRole: SpecialistRole;
+};
+type TurnItemType = "user_message" | "assistant_message" | "reasoning" | "tool_call" | "tool_result" | "plan" | "handoff";
+type TurnItemStatus = "in_progress" | "completed" | "failed";
+interface ThreadSnapshot {
+    id: string;
+    agent: string;
+    role: AgentRole;
+    parentThreadId: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface GoalCommitment {
+    goalId: string;
+    goalRevision: number;
+}
+type TurnSnapshot = {
+    id: string;
+    threadId: string;
+    triggerKind: TurnTriggerKind;
+    goalId: string | null;
+    goalRevision: number | null;
+    status: TurnStatus;
+    attempt: number;
+    error: JsonValue | null;
+    startedAt: string;
+    endedAt: string | null;
+    leaseUntil: string | null;
+    leaseToken: string | null;
+    runnerPid: number | null;
+    runnerProfileId?: string;
+};
+interface TurnItemSnapshot {
+    id: string;
+    turnId: string;
+    ordinal: number;
+    type: TurnItemType;
+    status: TurnItemStatus;
+    data: JsonValue;
+    createdAt: string;
+    completedAt: string | null;
+}
+interface GoalSnapshot {
+    id: string;
+    parentId: string | null;
+    objective: string;
+    observationMethod: string | null;
+    verificationMethod: string | null;
+    owner: string;
+    phase: GoalPhase;
+    revision: number;
+}
+type GoalChangeOperation = "create" | "revise" | "pause" | "resume" | "block" | "complete" | "reassign";
+type GoalChangeAuthority = {
+    kind: "human";
+} | {
+    kind: "parent_goal";
+    goalId: string;
+    goalRevision: number;
+} | {
+    kind: "system";
+    reason: string;
+};
+interface GoalChangeMetadata {
+    operation: GoalChangeOperation;
+    reason: string;
+    evidence: number[];
+    authority?: GoalChangeAuthority;
+    sourceTurnId?: string;
+    sourceWakeId?: string;
+    idempotencyKey?: string;
+}
+interface WorkRecordSnapshot {
+    goalId: string;
+    recordRevision: number;
+    goalRevision: number;
+    content: string;
+    updatedBy: string;
+    updatedInTurn: string;
+    sourceWakeId: string | null;
+    updatedAt: string;
+    reason: string;
+    evidence: number[];
+    lastEventSeq: number;
+}
+interface WorkRecordUpdateRequest {
+    goalId: string;
+    expectedRevision: number;
+    goalRevision: number;
+    content: string;
+    reason: string;
+    evidence: number[];
+    turnId: string;
+    sourceWakeId?: string;
+}
+interface WorkRecordDiff {
+    goalId: string;
+    fromRevision: number;
+    toRevision: number;
+    text: string;
+}
+type ScheduleSnapshot = AutomaticTarget & {
+    id: string;
+    nextWakeAt: string;
+    reason: string;
+    setBy: string;
+    status: ScheduleStatus;
+    resolvedAt: string | null;
+};
+type WakeSnapshot = AutomaticTarget & {
+    id: string;
+    /** Initial trigger retained for display and provenance. Runtime decisions use WakeTriggerSnapshot. */
+    triggerRef: string;
+    status: WakeStatus;
+    attempt: number;
+    enqueuedSeq: number;
+    claimedAt: string | null;
+    consumedAt: string | null;
+    turnId: string | null;
+};
+interface WakeTriggerSnapshot {
+    wakeId: string;
+    agent: string;
+    triggerRef: string;
+    source: "goal" | "system";
+    status: WakeTriggerStatus;
+    addedAt: string;
+    resolvedAt: string | null;
+}
+type MailLevel = "fyi" | "decision" | "emergency";
+type MailSnapshot = MailRoute & {
+    id: string;
+    to: string;
+    from: string;
+    level: MailLevel;
+    body: JsonValue;
+    readAt: string | null;
+};
+interface DelegationRequest {
+    id: string;
+    parentGoalId: string;
+    expectedParentRevision: number;
+    childGoal: {
+        id: string;
+        objective: string;
+        observationMethod: string;
+        verificationMethod: string;
+        owner: string;
+    };
+    brief: JsonValue;
+    reason: string;
+    evidence: number[];
+    sourceTurnId?: string;
+}
+interface DelegationResult {
+    delegationId: string;
+    goal: GoalSnapshot;
+    mail: MailSnapshot;
+    wake: WakeSnapshot;
+}
+interface ReassignmentRequest {
+    id: string;
+    goalId: string;
+    expectedGoalRevision: number;
+    newOwner: string;
+    brief: JsonValue;
+    reason: string;
+    evidence: number[];
+    sourceTurnId?: string;
+}
+interface ReassignmentResult {
+    reassignmentId: string;
+    goal: GoalSnapshot;
+    mail: MailSnapshot[];
+    wake: WakeSnapshot | null;
+}
+interface GoalCompletionRequest {
+    goalId: string;
+    revision: number;
+    reason: string;
+    evidence: number[];
+    sourceTurnId?: string;
+}
+type GoalOutcome = "progress" | "waiting" | "blocked" | "completion_proposed";
+interface AgentHandoff {
+    outcome: GoalOutcome;
+    evidence: number[];
+}
+interface GoalHandoff extends AgentHandoff {
+    goalId: string;
+    goalRevision: number;
+    recordRevision: number;
+}
+interface HandoffValidationIssue {
+    code: string;
+    message: string;
+    details?: JsonValue;
+}
+type HandoffValidationResult = {
+    accepted: true;
+    fatal: false;
+    attemptId: number;
+    token: string;
+    goalId: string;
+    goalRevision: number;
+} | {
+    accepted: false;
+    fatal: boolean;
+    attemptId: number;
+    issues: HandoffValidationIssue[];
+};
+interface CommittedTurnOutput {
+    handoff: GoalHandoff;
+}
+interface RunnerTraceEvent {
+    type: string;
+    data: JsonValue;
+}
+type AgentCapability = "ledger.search" | "mail.send" | "schedule.set" | "goal.put" | "team.list" | "goal.get" | "goal.create" | "goal.work" | "goal.delegate" | "goal.reassign" | "goal.revise" | "goal.pause" | "goal.resume" | "goal.complete" | "human.request" | "work_record.list" | "work_record.read" | "work_record.history" | "work_record.diff" | "work_record.search" | "work_record.update" | "memory.append";
+type RunnerControlMethod = "goal.handoff.validate";
+type RunnerRpcMethod = AgentCapability | RunnerControlMethod;
+type TurnTrigger = {
+    kind: "user_message";
+} | {
+    kind: "wake";
+    reasons: string[];
+};
+interface TurnContext {
+    trigger: TurnTrigger;
+    activeGoal: GoalSnapshot | null;
+    goalCommitment: GoalCommitment | null;
+}
+interface AssistantResponse {
+    content: string;
+}
+interface RunRequest {
+    agent: string;
+    execution: TurnSnapshot;
+    sourceWake?: WakeSnapshot;
+    sourceWakeTriggers?: WakeTriggerSnapshot[];
+    turn: TurnContext;
+    context: JsonValue;
+    now(): string;
+    emit(event: RunnerTraceEvent): void;
+    rpc?(method: RunnerRpcMethod, params: JsonValue): Promise<JsonValue>;
+}
+interface HandoffCommit {
+    agent: string;
+    turnId: string;
+    sourceWakeId: string | null;
+    mailIds: string[];
+    ts: string;
+    output: CommittedTurnOutput;
+    responseItemId: string;
+    item: TurnItemSnapshot;
+}
+interface HumanTurnAdmissionRequest {
+    thread: ThreadSnapshot;
+    turn: TurnSnapshot;
+    messageItem: TurnItemSnapshot;
+    replaceTurnId: string | null;
+    rootGoal?: GoalSnapshot;
+}
+interface HumanTurnAdmissionResult {
+    turn: TurnSnapshot;
+    replacedTurn: TurnSnapshot | null;
+    goal: GoalSnapshot | null;
+}
+/** Standard execution modules composed on top of the generic event store. */
+interface Ledger extends EventStore {
+    putThread(thread: ThreadSnapshot, actor: string): EventRecord;
+    putTurn(turn: TurnSnapshot, actor: string): EventRecord;
+    admitHumanTurn(request: HumanTurnAdmissionRequest): HumanTurnAdmissionResult;
+    commitTurnToGoal(turnId: string, goal: GoalCommitment, actor: string): TurnSnapshot;
+    putTurnItem(item: TurnItemSnapshot, actor: string): EventRecord;
+    thread(id: string): ThreadSnapshot | null;
+    threads(): ThreadSnapshot[];
+    turn(id: string): TurnSnapshot | null;
+    turns(threadId?: string): TurnSnapshot[];
+    turnItems(turnId: string): TurnItemSnapshot[];
+    activeTurn(threadId: string): TurnSnapshot | null;
+    putGoal(goal: GoalSnapshot, actor: string, wakeId?: string, change?: GoalChangeMetadata): EventRecord;
+    updateWorkRecord(request: WorkRecordUpdateRequest, actor: string): WorkRecordSnapshot;
+    commitDelegation(request: DelegationRequest, actor: string, wakeId?: string): DelegationResult;
+    commitReassignment(request: ReassignmentRequest, actor: string, wakeId?: string): ReassignmentResult;
+    completeGoal(request: GoalCompletionRequest, actor: string, wakeId?: string): GoalSnapshot;
+    putSchedule(schedule: ScheduleSnapshot, actor: string, wakeId?: string): EventRecord;
+    consumeSchedule(id: string, wake: WakeSnapshot, now: string): {
+        schedule: ScheduleSnapshot;
+        wake: WakeSnapshot;
+    };
+    cancelSchedule(id: string, now: string): ScheduleSnapshot;
+    supersedeSchedule(id: string, now: string): ScheduleSnapshot;
+    enqueueWake(wake: WakeSnapshot, actor: string): {
+        event: EventRecord;
+        created: boolean;
+    };
+    addWakeTrigger(wakeId: string, triggerRef: string, actor: string): WakeTriggerSnapshot;
+    claimNextWake(now: string): WakeSnapshot | null;
+    startTurnFromWake(id: string, turn: TurnSnapshot, now: string): WakeSnapshot;
+    releaseWake(id: string, now: string): WakeSnapshot;
+    cancelWake(id: string, now: string): WakeSnapshot;
+    attachTurnProcess(id: string, leaseToken: string, pid: number): TurnSnapshot;
+    renewTurnLease(id: string, leaseToken: string, leaseUntil: string, now: string): TurnSnapshot;
+    appendTurnEvent(input: EventInput, leaseToken: string): EventRecord;
+    repairTurnAttempt(id: string, reason: string, now: string, actor: string): TurnItemSnapshot[];
+    finishTurn(id: string, status: "completed" | "failed" | "interrupted", error: JsonValue | null, now: string, actor: string, mailIds?: string[]): TurnSnapshot;
+    releaseTurnProcess(id: string, actor: string): TurnSnapshot;
+    putMail(mail: MailSnapshot, actor: string, wakeId?: string): EventRecord;
+    putMails(mail: MailSnapshot[], actor: string, wakeId?: string): EventRecord[];
+    commitHandoff(commit: HandoffCommit): EventRecord;
+    dueSchedules(now: string): ScheduleSnapshot[];
+    unreadMail(agent: string): MailSnapshot[];
+    lastEvent(actor: string, type: string): EventRecord | null;
+    lastGoalHandoff(goalId: string): EventRecord | null;
+    latestEvent(): EventRecord | null;
+    eventsForWake(wakeId: string): EventRecord[];
+    wake(id: string): WakeSnapshot | null;
+    wakeByTrigger(agent: string, triggerRef: string): WakeSnapshot | null;
+    wakeTriggers(wakeId: string): WakeTriggerSnapshot[];
+    wakeTriggersForAgent(agent: string): WakeTriggerSnapshot[];
+    queuedWakeForAgent(agent: string): WakeSnapshot | null;
+    goalsForOwner(owner: string): GoalSnapshot[];
+    goal(id: string): GoalSnapshot | null;
+    workRecord(goalId: string): WorkRecordSnapshot | null;
+    workRecordHistory(goalId: string): WorkRecordSnapshot[];
+    workRecordDiff(goalId: string, fromRevision: number, toRevision: number): WorkRecordDiff;
+    searchWorkRecords(query: string, limit?: number): WorkRecordSnapshot[];
+    triggeringMail(): MailSnapshot[];
+    searchEvents(query: string, limit?: number): EventRecord[];
+    goals(): GoalSnapshot[];
+    workRecords(): WorkRecordSnapshot[];
+    schedules(): ScheduleSnapshot[];
+    wakes(): WakeSnapshot[];
+    mailbox(): MailSnapshot[];
+    rebuildProjections(): void;
+    close(): void;
+}
+
+type FaultPoint = "after_event_before_projection" | "after_delegation_event" | "after_reassignment_event" | "after_human_goal_before_turn" | "after_human_replacement_before_turn";
+type FaultInjector = (point: FaultPoint) => void;
+interface SqliteLedgerOptions {
+    faultInjector?: FaultInjector;
+    clock?: Clock;
+    busyTimeoutMs?: number;
+}
+declare class SqliteLedger implements Ledger {
+    #private;
+    readonly db: DatabaseSync;
+    constructor(path?: string, options?: SqliteLedgerOptions);
+    close(): void;
+    appendEvent(input: EventInput): EventRecord;
+    appendEvents(inputs: EventInput[]): EventRecord[];
+    readStream(streamId: string, fromStreamSeq?: number): EventRecord[];
+    putThread(thread: ThreadSnapshot, actor: string): EventRecord;
+    putTurn(turn: TurnSnapshot, actor: string): EventRecord;
+    admitHumanTurn(request: HumanTurnAdmissionRequest): HumanTurnAdmissionResult;
+    commitTurnToGoal(turnId: string, binding: {
+        goalId: string;
+        goalRevision: number;
+    }, actor: string): TurnSnapshot;
+    putTurnItem(item: TurnItemSnapshot, actor: string): EventRecord;
+    thread(id: string): ThreadSnapshot | null;
+    threads(): ThreadSnapshot[];
+    turn(id: string): TurnSnapshot | null;
+    turns(threadId?: string): TurnSnapshot[];
+    turnItems(turnId: string): TurnItemSnapshot[];
+    activeTurn(threadId: string): TurnSnapshot | null;
+    putGoal(goal: GoalSnapshot, actor: string, wakeId?: string, change?: GoalChangeMetadata): EventRecord;
+    updateWorkRecord(request: WorkRecordUpdateRequest, actor: string): WorkRecordSnapshot;
+    commitDelegation(request: DelegationRequest, actor: string, wakeId?: string): DelegationResult;
+    commitReassignment(request: ReassignmentRequest, actor: string, wakeId?: string): ReassignmentResult;
+    completeGoal(request: GoalCompletionRequest, actor: string, wakeId?: string): GoalSnapshot;
+    putSchedule(value: ScheduleSnapshot, actor: string, wakeId?: string): EventRecord;
+    consumeSchedule(id: string, wake: WakeSnapshot, now: string): {
+        schedule: ScheduleSnapshot;
+        wake: WakeSnapshot;
+    };
+    cancelSchedule(id: string, now: string): ScheduleSnapshot;
+    supersedeSchedule(id: string, now: string): ScheduleSnapshot;
+    enqueueWake(input: WakeSnapshot, actor: string): {
+        event: EventRecord;
+        created: boolean;
+    };
+    addWakeTrigger(wakeId: string, triggerRef: string, actor: string): WakeTriggerSnapshot;
+    claimNextWake(now: string): WakeSnapshot | null;
+    startTurnFromWake(id: string, turn: TurnSnapshot, now: string): WakeSnapshot;
+    releaseWake(id: string, now: string): WakeSnapshot;
+    cancelWake(id: string, now: string): WakeSnapshot;
+    attachTurnProcess(id: string, leaseToken: string, pid: number): TurnSnapshot;
+    renewTurnLease(id: string, leaseToken: string, leaseUntil: string, now: string): TurnSnapshot;
+    appendTurnEvent(input: EventInput, leaseToken: string): EventRecord;
+    repairTurnAttempt(id: string, reason: string, now: string, actor: string): TurnItemSnapshot[];
+    finishTurn(id: string, status: "completed" | "failed" | "interrupted", error: JsonValue | null, now: string, actor: string, mailIds?: string[]): TurnSnapshot;
+    releaseTurnProcess(id: string, actor: string): TurnSnapshot;
+    putMail(mail: MailSnapshot, actor: string, wakeId?: string): EventRecord;
+    putMails(mails: MailSnapshot[], actor: string, wakeId?: string): EventRecord[];
+    commitHandoff(commit: HandoffCommit): EventRecord;
+    dueSchedules(now: string): ScheduleSnapshot[];
+    unreadMail(agent: string): MailSnapshot[];
+    lastEvent(actor: string, type: string): EventRecord | null;
+    lastGoalHandoff(goalId: string): EventRecord | null;
+    latestEvent(): EventRecord | null;
+    eventsForWake(wakeId: string): EventRecord[];
+    wake(id: string): WakeSnapshot | null;
+    wakeByTrigger(agent: string, triggerRef: string): WakeSnapshot | null;
+    wakeTriggers(wakeId: string): WakeTriggerSnapshot[];
+    wakeTriggersForAgent(agent: string): WakeTriggerSnapshot[];
+    queuedWakeForAgent(agent: string): WakeSnapshot | null;
+    goalsForOwner(owner: string): GoalSnapshot[];
+    goal(id: string): GoalSnapshot | null;
+    workRecord(goalId: string): WorkRecordSnapshot | null;
+    workRecordHistory(goalId: string): WorkRecordSnapshot[];
+    workRecordDiff(goalId: string, fromRevision: number, toRevision: number): WorkRecordDiff;
+    searchWorkRecords(query: string, limit?: number): WorkRecordSnapshot[];
+    triggeringMail(): MailSnapshot[];
+    eventsSince(seq: number, types?: string[]): EventRecord[];
+    searchEvents(query: string, limit?: number): EventRecord[];
+    events(): EventRecord[];
+    goals(): GoalSnapshot[];
+    workRecords(): WorkRecordSnapshot[];
+    schedules(): ScheduleSnapshot[];
+    wakes(): WakeSnapshot[];
+    mailbox(): MailSnapshot[];
+    rebuildProjections(): void;
+}
+
+interface PiStep {
+    trace?: Array<{
+        type: string;
+        data: JsonValue;
+    }>;
+    response?: AssistantResponse;
+    handoff?: {
+        response: AssistantResponse;
+        handoff: AgentHandoff;
+    };
+    stopped?: boolean;
+}
+interface PiRunnerSession {
+    step(): Promise<PiStep>;
+    feedback(validation: Exclude<HandoffValidationResult, {
+        accepted: true;
+    }>): Promise<void>;
+    close(): Promise<void>;
+}
+interface PiDriver {
+    createRunnerSession(request: RunRequest): Promise<PiRunnerSession>;
+}
+
+declare class SimulatedClock implements Clock {
+    #private;
+    constructor(value?: string);
+    now(): Date;
+    advance(ms: number): void;
+    set(value: string): void;
+}
+declare function createMemoryLedger(options?: SqliteLedgerOptions): SqliteLedger;
+interface FauxStep {
+    advanceMs?: number;
+    trace?: Array<{
+        type: string;
+        data: JsonValue;
+    }>;
+    response?: string;
+    write?: {
+        path: string;
+        content: string;
+    };
+    handoff?: {
+        response: {
+            content: string;
+        };
+        handoff: AgentHandoff;
+    };
+    stop?: boolean;
+    crash?: string;
+    effect?: (request: RunRequest, feedback: Exclude<HandoffValidationResult, {
+        accepted: true;
+    }> | null) => void;
+}
+declare class FauxPiDriver implements PiDriver {
+    #private;
+    readonly clock: SimulatedClock;
+    readonly directory: string;
+    readonly requests: RunRequest[];
+    constructor(clock: SimulatedClock, runnerSessions: FauxStep[][], directory?: string);
+    createRunnerSession(request: RunRequest): Promise<PiRunnerSession>;
+}
+declare function fauxRunnerWorkerPath(): string;
+interface LedgerConformanceFactory {
+    (clock: Clock): Ledger;
+}
+/** Public, storage-independent contract checks for third-party Ledger implementations. */
+declare function assertLedgerConformance(create: LedgerConformanceFactory): void;
+
+export { FauxPiDriver, SimulatedClock, assertLedgerConformance, createMemoryLedger, fauxRunnerWorkerPath };
+export type { FauxStep, LedgerConformanceFactory };

package/dist/testkit.js

@@ -1,2 +1,127 @@
-export * from "goah-testkit";
-//# sourceMappingURL=testkit.js.map
+import { createRequire as __goahCreateRequire } from "node:module";
+const require = __goahCreateRequire(import.meta.url);
+import {
+  SqliteLedger
+} from "./chunk-YH6YJ2IB.js";
+import "./chunk-4KA63VNZ.js";
+import "./chunk-KAO7WIXG.js";
+import "./chunk-R6I3VKME.js";
+import {
+  specialistAutomaticTarget
+} from "./chunk-TJON22J4.js";
+import "./chunk-XPQKM3L7.js";
+
+// node_modules/goah-testkit/dist/index.js
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+var SimulatedClock = class {
+  #value;
+  constructor(value = "2026-08-18T00:00:00.000Z") {
+    this.#value = new Date(value);
+  }
+  now() {
+    return new Date(this.#value);
+  }
+  advance(ms) {
+    this.#value = new Date(this.#value.getTime() + ms);
+  }
+  set(value) {
+    this.#value = new Date(value);
+  }
+};
+function createMemoryLedger(options = {}) {
+  return new SqliteLedger(":memory:", options);
+}
+var FauxPiDriver = class {
+  clock;
+  directory;
+  requests = [];
+  #runnerSessions;
+  constructor(clock, runnerSessions, directory = process.cwd()) {
+    this.clock = clock;
+    this.directory = directory;
+    this.#runnerSessions = runnerSessions.map((steps) => [...steps]);
+  }
+  async createRunnerSession(request) {
+    this.requests.push(request);
+    const steps = this.#runnerSessions.shift() ?? [];
+    let validationFeedback = null;
+    return {
+      step: async () => {
+        const step = steps.shift();
+        if (!step)
+          return { stopped: true };
+        if (step.advanceMs)
+          this.clock.advance(step.advanceMs);
+        if (step.write) {
+          const path = join(this.directory, step.write.path);
+          mkdirSync(dirname(path), { recursive: true });
+          writeFileSync(path, step.write.content);
+        }
+        const feedback = validationFeedback;
+        validationFeedback = null;
+        step.effect?.(request, feedback);
+        if (step.crash)
+          throw new Error(step.crash);
+        return { ...step.trace ? { trace: step.trace } : {}, ...step.response !== void 0 ? { response: { content: step.response } } : {}, ...step.handoff ? { handoff: step.handoff } : {}, ...step.stop ? { stopped: true } : {} };
+      },
+      feedback: async (value) => {
+        validationFeedback = value;
+      },
+      close: async () => void 0
+    };
+  }
+};
+function fauxRunnerWorkerPath() {
+  return fileURLToPath(new URL("./faux-runner-worker.js", import.meta.url));
+}
+function assertLedgerConformance(create) {
+  const clock = new SimulatedClock("2030-01-01T00:00:00.000Z");
+  const ledger = create(clock);
+  const observationMethod = "Use the conformance evidence event as the completion observation.";
+  ledger.putGoal({ id: "root", parentId: null, objective: "test", observationMethod, verificationMethod: observationMethod, owner: "a", phase: "active", revision: 0 }, "human");
+  ledger.putGoal({ id: "root", parentId: null, objective: "test", observationMethod, verificationMethod: observationMethod, owner: "a", phase: "paused", revision: 1 }, "human");
+  ledger.putGoal({ id: "root", parentId: null, objective: "test", observationMethod, verificationMethod: observationMethod, owner: "a", phase: "active", revision: 2 }, "human");
+  const completionEvidence = ledger.appendEvent({ streamId: "conformance:goal", ts: clock.now().toISOString(), actor: "a", type: "observation.completed", data: { ok: true } });
+  ledger.completeGoal({ goalId: "root", revision: 2, reason: "conformance observation passed", evidence: [completionEvidence.seq] }, "human");
+  let reopened = false;
+  try {
+    ledger.putGoal({ id: "root", parentId: null, objective: "test", observationMethod, verificationMethod: observationMethod, owner: "a", phase: "active", revision: 4 }, "human");
+  } catch {
+    reopened = true;
+  }
+  if (!reopened)
+    throw new Error("ledger conformance: completed goal was reopened");
+  const first = ledger.enqueueWake({ id: "z", ...specialistAutomaticTarget("a", "verifier"), triggerRef: "first", status: "queued", attempt: 0, enqueuedSeq: 0, claimedAt: null, consumedAt: null, turnId: null }, "supervisor");
+  if (ledger.wakeTriggers("z").length !== 1 || ledger.wakeTriggers("z")[0]?.status !== "pending")
+    throw new Error("ledger conformance: initial Wake trigger is missing");
+  ledger.enqueueWake({ id: "a", ...specialistAutomaticTarget("b", "audit"), triggerRef: "second", status: "queued", attempt: 0, enqueuedSeq: 0, claimedAt: null, consumedAt: null, turnId: null }, "supervisor");
+  const claimed = ledger.claimNextWake(clock.now().toISOString());
+  if (claimed?.id !== "z")
+    throw new Error("ledger conformance: wakes are not FIFO");
+  ledger.putThread({ id: "thread:a", agent: "a", role: "verifier", parentThreadId: null, createdAt: clock.now().toISOString(), updatedAt: clock.now().toISOString() }, "supervisor");
+  const turn = { id: "turn:a", threadId: "thread:a", triggerKind: "wake", goalId: null, goalRevision: null, status: "in_progress", attempt: 1, error: null, startedAt: clock.now().toISOString(), endedAt: null, leaseUntil: "2030-01-01T00:10:00.000Z", leaseToken: "lease", runnerPid: null };
+  ledger.startTurnFromWake("z", turn, clock.now().toISOString());
+  if (ledger.wake("z")?.turnId !== turn.id)
+    throw new Error("ledger conformance: consumed Wake did not link its Turn");
+  if (ledger.wakeTriggers("z").some((trigger) => trigger.status !== "resolved"))
+    throw new Error("ledger conformance: consumed Wake retained pending triggers");
+  if (first.event.ts !== clock.now().toISOString())
+    throw new Error("ledger conformance: injected clock was ignored");
+  const informational = ledger.appendEvent({ streamId: "conformance:events", ts: clock.now().toISOString(), actor: "a", type: "transcript.conformance_info", data: {}, ignorable: true });
+  if (ledger.latestEvent()?.seq !== informational.seq)
+    throw new Error("ledger conformance: latest event was not the globally last append");
+  const before = JSON.stringify({ goals: ledger.goals(), wakes: ledger.wakes(), triggers: ledger.wakeTriggers("z") });
+  ledger.rebuildProjections();
+  if (JSON.stringify({ goals: ledger.goals(), wakes: ledger.wakes(), triggers: ledger.wakeTriggers("z") }) !== before)
+    throw new Error("ledger conformance: projection replay changed state");
+  ledger.close();
+}
+export {
+  FauxPiDriver,
+  SimulatedClock,
+  assertLedgerConformance,
+  createMemoryLedger,
+  fauxRunnerWorkerPath
+};