@goah/cli 0.13.0 → 0.13.2

package/dist/dist-KNR2XL6J.js

@@ -0,0 +1,39 @@
+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
+};

package/dist/execution.d.ts

@@ -1,2 +1,557 @@
-export * from "goah-ledger-contract/execution";
-//# sourceMappingURL=execution.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[];
+}
+
+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;
+};
+declare function goalAutomaticTarget(agent: string, goalId: string): Extract<AutomaticTarget, {
+    targetKind: "goal";
+}>;
+declare function specialistAutomaticTarget(agent: string, role: SpecialistRole): Extract<AutomaticTarget, {
+    targetKind: "specialist";
+}>;
+declare function goalRoute(goalId: string): Extract<MailRoute, {
+    routeKind: "goal";
+}>;
+declare function humanInboxRoute(): Extract<MailRoute, {
+    routeKind: "human_inbox";
+}>;
+declare function humanRequestRoute(): Extract<MailRoute, {
+    routeKind: "human_request";
+}>;
+declare function specialistInboxRoute(role: SpecialistRole): Extract<MailRoute, {
+    routeKind: "specialist_inbox";
+}>;
+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;
+}
+declare function noGoalCommitment(): {
+    goalId: null;
+    goalRevision: null;
+};
+declare function goalCommitment(goalId: string, goalRevision: number): GoalCommitment;
+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 GoalChangedData extends GoalChangeMetadata {
+    version: 1;
+    previousRevision: number | null;
+    snapshot: GoalSnapshot;
+    authority: GoalChangeAuthority;
+}
+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;
+}
+type Handoff = GoalHandoff;
+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 HandoffValidationRequest {
+    handoff: AgentHandoff;
+    candidateMessage: string;
+}
+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;
+}
+interface RunnerChoice {
+    value: string;
+    label: string;
+    description?: string;
+}
+interface RunnerSetupProgress {
+    current: number;
+    total: number;
+}
+interface RunnerSetupInteraction {
+    select(input: {
+        title: string;
+        description?: string;
+        choices: RunnerChoice[];
+        progress?: RunnerSetupProgress;
+    }): Promise<string | null>;
+    input(input: {
+        title: string;
+        description?: string;
+        prompt: string;
+        initial?: string;
+        secret?: boolean;
+        progress?: RunnerSetupProgress;
+    }): Promise<string | null>;
+    notify(message: string): void;
+    openUrl?(url: string): void;
+}
+interface RunnerManifest {
+    id: string;
+    name: string;
+    description: string;
+    commands?: Array<{
+        name: string;
+        description: string;
+    }>;
+}
+interface RunnerDiagnostic {
+    ok: boolean;
+    name: string;
+    detail: string;
+    severity?: "warning" | "error";
+}
+interface RunnerCommandResult {
+    config?: JsonValue;
+    output: string[];
+    rollback?(): Promise<void>;
+}
+interface RunnerSetupTransaction {
+    config: JsonValue | null;
+    commit(): Promise<JsonValue | null>;
+    rollback(): Promise<void>;
+}
+interface RunnerConfigurator {
+    describe(): RunnerManifest;
+    setup(current: JsonValue | null, interaction: RunnerSetupInteraction): Promise<JsonValue | null>;
+    beginSetup?(current: JsonValue | null, interaction: RunnerSetupInteraction): Promise<RunnerSetupTransaction>;
+    doctor(config: JsonValue, context?: {
+        root: string;
+    }): Promise<RunnerDiagnostic[]>;
+    summarize?(config: JsonValue): Array<{
+        label: string;
+        value: string;
+    }>;
+    runCommand?(command: string, args: string[], config: JsonValue, interaction: RunnerSetupInteraction): Promise<RunnerCommandResult>;
+}
+type TurnTrigger = {
+    kind: "user_message";
+} | {
+    kind: "wake";
+    reasons: string[];
+};
+interface TurnContext {
+    trigger: TurnTrigger;
+    activeGoal: GoalSnapshot | null;
+    goalCommitment: GoalCommitment | null;
+}
+interface AssistantResponse {
+    content: string;
+}
+/** Canonical user-visible assistant prose. Raw provider events remain unchanged. */
+declare function normalizeAssistantText(text: string): 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;
+}
+declare function assertWakeTransition(from: WakeStatus, to: WakeStatus): void;
+declare function assertGoalTransition(from: GoalPhase, to: GoalPhase): void;
+declare function assertHandoff(value: Handoff): void;
+declare function assertAgentHandoff(value: AgentHandoff): void;
+declare function assertTurnOutput(value: TurnOutput): void;
+declare function assertGoalSnapshot(value: GoalSnapshot): void;
+
+export { assertAgentHandoff, assertGoalSnapshot, assertGoalTransition, assertHandoff, assertTurnOutput, assertWakeTransition, goalAutomaticTarget, goalCommitment, goalRoute, humanInboxRoute, humanRequestRoute, noGoalCommitment, normalizeAssistantText, specialistAutomaticTarget, specialistInboxRoute };
+export type { AgentCapability, AgentHandoff, AgentProfile, AgentRole, AssistantResponse, AutomaticTarget, CommittedTurnOutput, DelegationRequest, DelegationResult, GoalChangeAuthority, GoalChangeMetadata, GoalChangeOperation, GoalChangedData, GoalCommitment, GoalCompletionRequest, GoalHandoff, GoalOutcome, GoalPhase, GoalSnapshot, Handoff, HandoffCommit, HandoffValidationIssue, HandoffValidationRequest, HandoffValidationResult, HumanTurnAdmissionRequest, HumanTurnAdmissionResult, Ledger, MailLevel, MailRoute, MailSnapshot, ReassignmentRequest, ReassignmentResult, RunRequest, Runner, RunnerCandidateResult, RunnerChoice, RunnerCommandResult, RunnerConfigurator, RunnerControlMethod, RunnerDiagnostic, RunnerHandle, RunnerManifest, RunnerProfile, RunnerRpcMethod, RunnerSetupInteraction, RunnerSetupProgress, RunnerSetupTransaction, RunnerTraceEvent, ScheduleSnapshot, ScheduleStatus, SpecialistRole, TeamMemberMotion, TeamMemberView, ThreadSnapshot, TurnContext, TurnItemSnapshot, TurnItemStatus, TurnItemType, TurnOutput, TurnSnapshot, TurnStatus, TurnTrigger, TurnTriggerKind, WakeSnapshot, WakeStatus, WakeTriggerSnapshot, WakeTriggerStatus, WorkRecordDiff, WorkRecordSnapshot, WorkRecordUpdateRequest };

package/dist/execution.js

@@ -1,2 +1,37 @@
-export * from "goah-ledger-contract/execution";
-//# sourceMappingURL=execution.js.map
+import { createRequire as __goahCreateRequire } from "node:module";
+const require = __goahCreateRequire(import.meta.url);
+import {
+  assertAgentHandoff,
+  assertGoalSnapshot,
+  assertGoalTransition,
+  assertHandoff,
+  assertTurnOutput,
+  assertWakeTransition,
+  goalAutomaticTarget,
+  goalCommitment,
+  goalRoute,
+  humanInboxRoute,
+  humanRequestRoute,
+  noGoalCommitment,
+  normalizeAssistantText,
+  specialistAutomaticTarget,
+  specialistInboxRoute
+} from "./chunk-TJON22J4.js";
+import "./chunk-XPQKM3L7.js";
+export {
+  assertAgentHandoff,
+  assertGoalSnapshot,
+  assertGoalTransition,
+  assertHandoff,
+  assertTurnOutput,
+  assertWakeTransition,
+  goalAutomaticTarget,
+  goalCommitment,
+  goalRoute,
+  humanInboxRoute,
+  humanRequestRoute,
+  noGoalCommitment,
+  normalizeAssistantText,
+  specialistAutomaticTarget,
+  specialistInboxRoute
+};