@goah/cli 0.13.0 → 0.13.2

package/dist/index.d.ts

@@ -1,7 +1,838 @@
-import { CONTRACT_VERSION, type AgentProfile, type RunnerProfile } from "goah-ledger-contract";
-import { SqliteLedger } from "goah-ledger-sqlite";
-import { Supervisor } from "goah-supervisor";
-export interface GoahConfig {
+import { DatabaseSync } from 'node:sqlite';
+
+declare const CONTRACT_VERSION: "0.13.0";
+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;
+}
+
+interface TranscriptMessage {
+    id: string;
+    role: "user" | "assistant" | "tool";
+    content: JsonValue;
+    toolCallId?: string;
+    usage?: JsonValue;
+    stopReason?: string;
+    errorMessage?: string;
+}
+interface RequestSnapshot {
+    provider: string;
+    model: string;
+    systemPrompt: string;
+    activeContext: string;
+    messages: JsonValue[];
+    tools: JsonValue[];
+    modelConfig: JsonValue;
+    sourceSeqs: number[];
+}
+interface ReplayedTranscript {
+    messages: TranscriptMessage[];
+    status: "running" | "completed" | "interrupted";
+    openToolCalls: Array<{
+        callId: string;
+        name: string;
+        arguments: JsonValue;
+    }>;
+    lastRequest: RequestSnapshot | null;
+}
+
+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;
+}
+
+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 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[]>;
+}
+
+interface ThreadListItem {
+    threadId: string;
+    agent: string;
+    status: "idle" | "in_progress";
+    turnCount: number;
+    itemCount: number;
+    toolCalls: number;
+    updatedAt: string;
+}
+interface ThreadDetail {
+    thread: ThreadListItem;
+    turns: Array<TurnSnapshot & {
+        items: TurnItemSnapshot[];
+        transcript: ReplayedTranscript | null;
+    }>;
+}
+interface TurnContextSnapshot {
+    eventSeq: number;
+    provider: string;
+    model: string;
+    systemPrompt: string;
+    text: string;
+    sourceSeqs: number[];
+    toolCount: number;
+    messageCount: number;
+    modelConfig: JsonValue;
+}
+interface ThreadExport {
+    format: "goah.thread-export.v1";
+    exportedAt: string;
+    redacted: boolean;
+    thread: ThreadListItem;
+    events: EventRecord[];
+}
+declare function listThreads(ledger: SqliteLedger): ThreadListItem[];
+declare function showThread(ledger: SqliteLedger, threadId: string): ThreadDetail;
+declare function replayThread(ledger: SqliteLedger, threadId: string): ThreadDetail;
+declare function showTurnContext(ledger: SqliteLedger, turnId: string): TurnContextSnapshot | null;
+declare function streamEvents(ledger: SqliteLedger, streamId: string, fromStreamSeq?: number): EventRecord[];
+declare function exportThread(ledger: SqliteLedger, threadId: string, options?: {
+    raw?: boolean;
+    now?: string;
+}): ThreadExport;
+declare function redactValue(value: unknown, key?: string): unknown;
+
+interface ProcessRunnerOptions {
+    command: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    /** Unresolved env spec (may contain `env:NAME` references); resolved at every spawn. */
+    envSpec?: Record<string, string> | undefined;
+    inheritEnv?: string[];
+    /** Worker implements the live steering control message. */
+    steering?: boolean;
+    steerAckTimeoutMs?: number;
+    killGraceMs?: number;
+    timeoutMs?: number;
+    /** Resolve private per-wake runtime material (for example scoped model auth) before the worker starts. Never enters RunRequest context or Ledger events. */
+    prepareRuntime?: (request: RunRequest) => Promise<JsonValue | undefined>;
+}
+/** Real process boundary. The child stays idle until begin() sends its request. */
+declare class ProcessRunner implements Runner {
+    readonly options: ProcessRunnerOptions;
+    readonly isolation: "process";
+    constructor(options: ProcessRunnerOptions);
+    prepare(request: RunRequest): RunnerHandle;
+    terminateProcess(pid: number): Promise<void>;
+}
+
+type ControlRequest = {
+    op: "ping";
+} | {
+    op: "status";
+} | {
+    op: "interact";
+    message: string;
+} | {
+    op: "turn.attach";
+    turnId: string;
+} | {
+    op: "turn.steer";
+    message: string;
+} | {
+    op: "turn.interrupt";
+    turnId: string;
+} | {
+    op: "goal.start";
+    objective: string;
+    id?: string;
+} | {
+    op: "goal.interact";
+    objective: string;
+    id?: string;
+} | {
+    op: "goal.update";
+    id: string;
+    objective?: string;
+    observationMethod?: string | null;
+    verificationMethod?: string | null;
+} | {
+    op: "goal.observe";
+    id: string;
+    observationMethod: string;
+} | {
+    op: "goal.transition";
+    id: string;
+    phase: "paused" | "active";
+} | {
+    op: "goal.complete";
+    id: string;
+    reason: string;
+    evidence: number[];
+} | {
+    op: "ceo.send";
+    message: string;
+} | {
+    op: "ceo.status";
+} | {
+    op: "ceo.inbox";
+} | {
+    op: "work.records";
+} | {
+    op: "work.record";
+    goalId: string;
+} | {
+    op: "work.history";
+    goalId: string;
+} | {
+    op: "work.diff";
+    goalId: string;
+    fromRevision: number;
+    toRevision: number;
+} | {
+    op: "wake.stop";
+    agent: string;
+    goalId?: string;
+} | {
+    op: "daemon.stop";
+} | {
+    op: "daemon.version";
+} | {
+    op: "config.reload";
+    configPath: string;
+};
+type ControlFrame = {
+    type: "result";
+    value: JsonValue;
+} | {
+    type: "accepted";
+    turnId: string;
+    value: JsonValue;
+} | {
+    type: "event";
+    event: JsonValue;
+} | {
+    type: "error";
+    error: string;
+};
+declare function controlEndpoint(stateDir: string): string;
+declare function runControlServer(supervisor: Supervisor, ledger: Ledger, stateDir: string, signal: AbortSignal, options?: {
+    reloadRuntime?: (configPath: string) => Promise<RuntimeSwap | undefined>;
+    stop?: () => void;
+}): Promise<void>;
+declare function requestControl(stateDir: string, request: ControlRequest): Promise<JsonValue>;
+declare function streamControl(stateDir: string, request: ControlRequest, onFrame: (frame: ControlFrame) => void, signal?: AbortSignal): Promise<void>;
+declare function controlAvailable(stateDir: string): Promise<boolean>;
+interface RuntimeSwap {
+    runner: ProcessRunner | Runner;
+    ledger?: SqliteLedger;
+    profiles?: RunnerProfile[];
+}
+
+interface ConsoleMetadata {
+    url: string;
+    host: string;
+    port: number;
+    pid: number;
+    token: string;
+}
+interface TrajectoryItem {
+    event: JsonValue;
+    agent: string;
+    wakeId: string | null;
+}
+interface TrajectoryPage {
+    items: TrajectoryItem[];
+    nextBeforeSeq: number | null;
+}
+declare function consoleMetadataPath(stateDir: string): string;
+declare function readConsoleMetadata(stateDir: string): ConsoleMetadata | null;
+declare function consoleSnapshot(ledger: Ledger, supervisor: Supervisor, now?: string): JsonValue;
+declare function organizationTrajectory(ledger: Ledger, options?: {
+    beforeSeq?: number;
+    limit?: number;
+    agent?: string;
+    type?: string;
+}): TrajectoryPage;
+declare function runWebConsole(supervisor: Supervisor, ledger: Ledger, stateDir: string, signal: AbortSignal, options?: {
+    host?: string;
+    port?: number;
+    onListening?: (metadata: ConsoleMetadata) => void;
+}): Promise<void>;
+
+interface GoahConfig {
     version: 1 | 2;
     stateDir: string;
     runner?: {
@@ -17,7 +848,7 @@ export interface GoahConfig {
         baseDelayMs: number;
     };
 }
-export interface InitOptions {
+interface InitOptions {
     provider?: string;
     model?: string;
     apiKeyEnv?: string;
@@ -26,41 +857,38 @@ export interface InitOptions {
     maxOutputTokensPerTurn?: number;
     baseUrl?: string;
 }
-export interface DoctorCheck {
+interface DoctorCheck {
     name: string;
     ok: boolean;
     detail: string;
     severity?: "warning" | "error";
 }
-export declare function loadConfig(path?: string): GoahConfig;
-export declare function createRuntime(config: GoahConfig): {
+declare function loadConfig(path?: string): GoahConfig;
+declare function createRuntime(config: GoahConfig): {
     ledger: SqliteLedger;
     supervisor: Supervisor;
 };
-export declare function defaultConfig(directory: string, options?: InitOptions): GoahConfig;
-export declare class SupervisorLock {
+declare function defaultConfig(directory: string, options?: InitOptions): GoahConfig;
+declare class SupervisorLock {
     #private;
     readonly path: string;
     constructor(stateDir: string);
     acquire(): void;
     release(): void;
 }
-export declare function writeDefaultConfig(path?: string, options?: InitOptions, overwrite?: boolean): void;
-export declare function profilePath(): string;
-export declare function readDefaultRunnerProfile(): RunnerProfile | null;
-export declare function writeDefaultRunnerProfile(profile: RunnerProfile): void;
-export declare function updateWorkspaceRunnerProfile(path: string, profile: RunnerProfile): void;
+declare function writeDefaultConfig(path?: string, options?: InitOptions, overwrite?: boolean): void;
+declare function profilePath(): string;
+declare function readDefaultRunnerProfile(): RunnerProfile | null;
+declare function writeDefaultRunnerProfile(profile: RunnerProfile): void;
+declare function updateWorkspaceRunnerProfile(path: string, profile: RunnerProfile): void;
 /** Persist default + workspace profile with a crash-recoverable rollback journal. */
-export declare function persistRunnerProfile(profile: RunnerProfile, workspacePath: string | null): void;
-export declare function diagnoseConfig(config: GoahConfig): {
+declare function persistRunnerProfile(profile: RunnerProfile, workspacePath: string | null): void;
+declare function diagnoseConfig(config: GoahConfig): {
     ok: boolean;
     checks: DoctorCheck[];
 };
-export declare function statusSnapshot(ledger: SqliteLedger): object;
-export declare function configRoot(config: GoahConfig): string;
-export { exportThread, listThreads, redactValue, replayThread, showThread, showTurnContext, streamEvents } from "./thread-inspect.js";
-export { controlAvailable, controlEndpoint, requestControl, runControlServer, streamControl, type ControlFrame, type ControlRequest } from "./control.js";
-export { consoleMetadataPath, consoleSnapshot, organizationTrajectory, readConsoleMetadata, runWebConsole, type ConsoleMetadata, type TrajectoryItem, type TrajectoryPage } from "./web-console.js";
-export type { TurnContextSnapshot, ThreadDetail, ThreadExport, ThreadListItem } from "./thread-inspect.js";
-export { CONTRACT_VERSION };
-//# sourceMappingURL=index.d.ts.map
+declare function statusSnapshot(ledger: SqliteLedger): object;
+declare function configRoot(config: GoahConfig): string;
+
+export { CONTRACT_VERSION, SupervisorLock, configRoot, consoleMetadataPath, consoleSnapshot, controlAvailable, controlEndpoint, createRuntime, defaultConfig, diagnoseConfig, exportThread, listThreads, loadConfig, organizationTrajectory, persistRunnerProfile, profilePath, readConsoleMetadata, readDefaultRunnerProfile, redactValue, replayThread, requestControl, runControlServer, runWebConsole, showThread, showTurnContext, statusSnapshot, streamControl, streamEvents, updateWorkspaceRunnerProfile, writeDefaultConfig, writeDefaultRunnerProfile };
+export type { ConsoleMetadata, ControlFrame, ControlRequest, DoctorCheck, GoahConfig, InitOptions, ThreadDetail, ThreadExport, ThreadListItem, TrajectoryItem, TrajectoryPage, TurnContextSnapshot };