@goah/cli 0.13.0 → 0.13.2

package/dist/supervisor.d.ts

@@ -1,2 +1,625 @@
-export * from "goah-supervisor";
-//# sourceMappingURL=supervisor.d.ts.map
+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 TeamMemberMotion = "running" | "queued" | "scheduled" | "idle" | "retired";
+interface TeamMemberView {
+    agent: string;
+    goalIds: string[];
+    motion: TeamMemberMotion;
+    lastOutcome: GoalOutcome | null;
+    lastHandoffSeq: number | null;
+    lastWakeStatus: WakeStatus | null;
+    nextWakeAt: string | null;
+}
+type GoalOutcome = "progress" | "waiting" | "blocked" | "completion_proposed";
+interface AgentHandoff {
+    outcome: GoalOutcome;
+    evidence: number[];
+}
+interface GoalHandoff extends AgentHandoff {
+    goalId: string;
+    goalRevision: number;
+    recordRevision: number;
+}
+interface TurnOutput {
+    validationAttemptId: number;
+    validationToken: string;
+    handoff: AgentHandoff;
+}
+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;
+interface RunnerProfile {
+    id: string;
+    runner: string;
+    config: JsonValue;
+    credentialRefs?: string[];
+}
+interface AgentProfile {
+    agent: string;
+    role: AgentRole;
+    capabilities?: AgentCapability[];
+    systemPrompt?: string;
+    runnerProfile?: string;
+}
+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>;
+}
+type RunnerCandidateResult = {
+    outcome: "completed";
+    response: AssistantResponse;
+    handoff?: TurnOutput;
+} | {
+    outcome: "abnormal";
+    reason: string;
+};
+interface RunnerHandle {
+    pid: number | null;
+    begin(): void;
+    result: Promise<RunnerCandidateResult>;
+    steer?(message: string): Promise<void>;
+    terminate(): Promise<void>;
+}
+interface Runner {
+    readonly isolation: "process";
+    prepare(request: RunRequest): RunnerHandle;
+    terminateProcess(pid: number, runnerProfileId?: string): Promise<void>;
+}
+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;
+}
+
+interface ActiveContextView {
+    role: AgentRole;
+    capabilities: AgentCapability[];
+    systemPrompt: string;
+    text: string;
+    sourceSeqs: number[];
+}
+interface ActiveContextInput {
+    role: AgentRole;
+    capabilities: AgentCapability[];
+    systemPrompt: string;
+    wake: Pick<WakeSnapshot, "attempt"> & Partial<WakeSnapshot>;
+    wakeTriggers: WakeTriggerSnapshot[];
+    goals: GoalSnapshot[];
+    mail: MailSnapshot[];
+    lastHandoff: EventRecord | null;
+    teamHandoffs: EventRecord[];
+    team: TeamMemberView[];
+    recoveryEvents: EventRecord[];
+    /** Durable agent-owned working-memory facts; injected as a bounded advisory tail. */
+    workingMemory?: readonly EventRecord[];
+}
+/** Keep recovery actionable and bounded; raw Turn transcript remains queryable in the ledger. */
+declare function selectRecoveryEvents(events: EventRecord[]): EventRecord[];
+/** Deterministically render structured projections into the model's short working set. */
+declare function composeActiveContext(input: ActiveContextInput): ActiveContextView;
+
+interface VerificationFinding {
+    id: string;
+    body: JsonValue;
+    evidence: number[];
+    riskWeight: number;
+}
+interface VerificationResult {
+    findings: VerificationFinding[];
+    tokensUsed: number;
+}
+interface VerifierModel {
+    verifyTurn(input: {
+        turnId: string;
+        handoff: JsonValue | null;
+        trace: EventRecord[];
+    }): Promise<VerificationResult>;
+    blindAudit(facts: EventRecord[]): Promise<VerificationResult>;
+}
+interface VerifierProcessSpec {
+    command: string;
+    args: string[];
+    env?: Record<string, string>;
+    timeoutMs?: number;
+}
+declare class ProcessVerifierModel implements VerifierModel {
+    #private;
+    readonly spec: VerifierProcessSpec;
+    constructor(spec: VerifierProcessSpec);
+    verifyTurn(input: {
+        turnId: string;
+        handoff: JsonValue | null;
+        trace: EventRecord[];
+    }): Promise<VerificationResult>;
+    blindAudit(facts: EventRecord[]): Promise<VerificationResult>;
+}
+declare class VerificationPlane {
+    #private;
+    readonly ledger: Ledger;
+    readonly supervisor: Supervisor;
+    readonly model: VerifierModel;
+    constructor(ledger: Ledger, supervisor: Supervisor, model: VerifierModel);
+    verifyTurn(turnId: string): Promise<VerificationResult>;
+    auditGlobal(sinceSeq?: number): Promise<VerificationResult>;
+}
+interface VerificationLabel {
+    id: string;
+    shouldFlag: boolean;
+    riskWeight: number;
+}
+interface ScoredPrediction {
+    id: string;
+    score: number;
+}
+declare function evaluateVerification(labels: VerificationLabel[], predictedIds: string[]): {
+    precision: number;
+    riskWeightedRecall: number;
+};
+declare function calibrateVerificationThreshold(labels: VerificationLabel[], predictions: ScoredPrediction[], minimumPrecision: number): number;
+
+declare function defaultRolePrompt(role: AgentRole): string;
+declare function defaultTurnPrompt(role: AgentRole, agent: string, turn: TurnContext): string;
+
+/** Dispatches each wake to the runner selected by its opaque Runner Profile. */
+declare class RunnerRouter implements Runner {
+    #private;
+    readonly runners: ReadonlyMap<string, Runner>;
+    readonly fallback: string;
+    readonly isolation: "process";
+    constructor(runners: ReadonlyMap<string, Runner>, fallback?: string);
+    prepare(request: Parameters<Runner["prepare"]>[0]): RunnerHandle;
+    terminateProcess(pid: number, runnerProfileId?: string): Promise<void>;
+}
+interface SupervisorOptions {
+    leaseMs?: number;
+    memoryTailChars?: number;
+    retryPolicy?: {
+        maxAttempts: number;
+        baseDelayMs: number;
+    };
+    turnRetryPolicy?: {
+        maxAttempts: number;
+        baseDelayMs: number;
+    };
+    profiles?: AgentProfile[];
+    runnerProfiles?: RunnerProfile[];
+}
+declare class Supervisor {
+    #private;
+    readonly ledger: Ledger;
+    readonly clock: Clock;
+    constructor(ledger: Ledger, runner: Runner, clock: Clock, options?: SupervisorOptions);
+    /**
+     * Hot-swap the runner after a config reload. Refused while a Turn is active:
+     * a live child must never observe its runner vanish mid-flight.
+     * The next Turn uses the new runner, and spawn-time env
+     * resolution applies the new credentials to the next spawn.
+     */
+    swapRunner(runner: Runner, profiles?: RunnerProfile[]): void;
+    get runner(): Runner;
+    createGoal(goal: GoalSnapshot, actor?: string): void;
+    createRootGoal(objective: string, id?: string, sourceTurnId?: string): GoalSnapshot;
+    startGoal(objective: string, id?: string): {
+        goal: GoalSnapshot;
+        wake: WakeSnapshot;
+    };
+    threadFor(agent?: string): ThreadSnapshot;
+    startHumanTurn(message: string): Promise<{
+        threadId: string;
+        turnId: string;
+        steered: boolean;
+    }>;
+    startHumanGoalTurn(objective: string, id?: string): Promise<{
+        threadId: string;
+        turnId: string;
+        steered: false;
+        goal: GoalSnapshot;
+    }>;
+    interruptTurn(turnId: string): Promise<TurnSnapshot>;
+    sendToCeo(body: JsonValue): Promise<{
+        threadId: string;
+        turnId: string;
+        steered: boolean;
+    }>;
+    waitForTurn(turnId: string): Promise<void>;
+    delegate(request: DelegationRequest, actor?: string, wakeId?: string): DelegationResult;
+    reassignGoal(request: ReassignmentRequest, actor?: string, wakeId?: string): Promise<ReassignmentResult>;
+    teamList(now?: string): TeamMemberView[];
+    currentRoot(): GoalSnapshot | null;
+    agentRole(agent: string): AgentRole;
+    updateGoal(id: string, patch: Partial<Pick<GoalSnapshot, "objective" | "observationMethod" | "verificationMethod">>, actor?: string, change?: {
+        reason: string;
+        evidence: number[];
+        sourceTurnId?: string;
+        sourceWakeId?: string;
+    }): GoalSnapshot;
+    confirmObservationMethod(id: string, observationMethod: string): GoalSnapshot;
+    reviseChildGoal(id: string, objective: string, observationMethod: string, verificationMethod: string, actor: string, reason: string, evidence: number[], wakeId?: string, sourceTurnId?: string): GoalSnapshot;
+    completeGoal(request: GoalCompletionRequest, actor?: string, wakeId?: string): GoalSnapshot;
+    transitionGoal(id: string, phase: GoalPhase, actor?: string, scheduleMotion?: boolean, sourceTurnId?: string): GoalSnapshot;
+    planWake(agent: string, at: string, reason: string, setBy?: string, target?: {
+        goalId: string;
+    }): WakeSnapshot | null;
+    stopAgentWake(agent: string, goalId?: string): Promise<WakeSnapshot | null>;
+    recover(): Promise<void>;
+    tick(): Promise<WakeSnapshot | null>;
+    runAvailable(concurrency?: number, maxWakes?: number): Promise<WakeSnapshot[]>;
+}
+declare function runSupervisorDaemon(supervisor: Supervisor, options?: {
+    pollMs?: number;
+    concurrency?: number;
+    signal?: AbortSignal;
+    onError?: (error: unknown) => void;
+}): Promise<void>;
+declare function deriveTeam(ledger: Ledger, now?: string): TeamMemberView[];
+interface RecoveryView {
+    turnId: string;
+    agent: string;
+    state: "scheduled" | "queued" | "running" | "recovered" | "escalated" | "superseded" | "needed";
+    actionable: boolean;
+}
+declare function deriveRecoveryViews(ledger: Ledger): RecoveryView[];
+declare function renderDashboard(ledger: Ledger): string;
+
+export { ProcessVerifierModel, RunnerRouter, Supervisor, VerificationPlane, calibrateVerificationThreshold, composeActiveContext, defaultRolePrompt, defaultTurnPrompt, deriveRecoveryViews, deriveTeam, evaluateVerification, renderDashboard, runSupervisorDaemon, selectRecoveryEvents };
+export type { ActiveContextInput, ActiveContextView, RecoveryView, ScoredPrediction, SupervisorOptions, VerificationFinding, VerificationLabel, VerificationResult, VerifierModel, VerifierProcessSpec };

package/dist/supervisor.js

@@ -1,2 +1,39 @@
-export * from "goah-supervisor";
-//# sourceMappingURL=supervisor.js.map
+import { createRequire as __goahCreateRequire } from "node:module";
+const require = __goahCreateRequire(import.meta.url);
+import {
+  ProcessVerifierModel,
+  RunnerRouter,
+  Supervisor,
+  VerificationPlane,
+  calibrateVerificationThreshold,
+  composeActiveContext,
+  defaultRolePrompt,
+  defaultTurnPrompt,
+  deriveRecoveryViews,
+  deriveTeam,
+  evaluateVerification,
+  renderDashboard,
+  runSupervisorDaemon,
+  selectRecoveryEvents
+} from "./chunk-QBD6EJ2Z.js";
+import "./chunk-4KA63VNZ.js";
+import "./chunk-KAO7WIXG.js";
+import "./chunk-R6I3VKME.js";
+import "./chunk-TJON22J4.js";
+import "./chunk-XPQKM3L7.js";
+export {
+  ProcessVerifierModel,
+  RunnerRouter,
+  Supervisor,
+  VerificationPlane,
+  calibrateVerificationThreshold,
+  composeActiveContext,
+  defaultRolePrompt,
+  defaultTurnPrompt,
+  deriveRecoveryViews,
+  deriveTeam,
+  evaluateVerification,
+  renderDashboard,
+  runSupervisorDaemon,
+  selectRecoveryEvents
+};