@goah/cli 0.13.0 → 0.13.2

package/dist/runner-pi.d.ts

@@ -1,2 +1,342 @@
-export * from "goah-runner-pi";
-//# sourceMappingURL=runner-pi.d.ts.map
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+
+type WakeStatus = "queued" | "claimed" | "consumed" | "cancelled";
+type WakeTriggerStatus = "pending" | "resolved";
+type GoalPhase = "active" | "paused" | "blocked" | "complete";
+type TurnStatus = "in_progress" | "completed" | "failed" | "interrupted";
+type TurnTriggerKind = "user_message" | "wake";
+type SpecialistRole = "verifier" | "audit";
+type AutomaticTarget = {
+    targetKind: "goal";
+    agent: string;
+    goalId: string;
+    specialistRole: null;
+} | {
+    targetKind: "specialist";
+    agent: string;
+    goalId: null;
+    specialistRole: SpecialistRole;
+};
+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 GoalSnapshot {
+    id: string;
+    parentId: string | null;
+    objective: string;
+    observationMethod: string | null;
+    verificationMethod: string | null;
+    owner: string;
+    phase: GoalPhase;
+    revision: number;
+}
+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 GoalOutcome = "progress" | "waiting" | "blocked" | "completion_proposed";
+interface AgentHandoff {
+    outcome: GoalOutcome;
+    evidence: 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 TurnOutput {
+    validationAttemptId: number;
+    validationToken: string;
+    handoff: AgentHandoff;
+}
+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 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;
+}
+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>;
+}
+
+declare const LOCAL_PROVIDERS: readonly ["ollama", "lm-studio", "llama.cpp"];
+interface ProviderSummary {
+    id: string;
+    name: string;
+    modelCount: number;
+    oauth: boolean;
+    apiKey: boolean;
+    local: boolean;
+}
+interface ModelSummary {
+    provider: string;
+    id: string;
+    name: string;
+    contextWindow: number;
+    maxTokens: number;
+    reasoning: boolean;
+}
+declare function defaultAuthFile(): string;
+declare function providerCatalog(): ProviderSummary[];
+declare function modelCatalog(provider?: string): ModelSummary[];
+
+interface PiRunnerConfig {
+    provider: string;
+    model: string;
+    thinking?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+    apiKeyEnv?: string;
+    baseUrl?: string;
+    contextWindowTokens?: number;
+    maxOutputTokens?: number;
+    authFile?: string;
+    fauxHandoff?: JsonValue;
+    api?: "openai-completions" | "openai-responses" | "anthropic-messages";
+    authMode?: "oauth" | "stored-key" | "environment" | "local" | "unconfigured";
+}
+declare function piRunnerConfigurator(): RunnerConfigurator;
+declare function createPiProcessRunner(configValue: JsonValue, root: string): ProcessRunner;
+declare function piConfig(value: JsonValue): PiRunnerConfig;
+declare function piEnvironment(config: PiRunnerConfig): Record<string, string>;
+
+interface EnvSpecSource {
+    /** Absolute path of the workspace root whose `.env` is consulted. */
+    root: string;
+}
+/**
+ * Resolve an env spec for one spawn. Literal values pass through; `env:NAME`
+ * references consult the chain above. An unresolvable reference throws with the
+ * variable name so the wake fails honestly instead of spawning a child that
+ * would fail opaquely at its first model call.
+ */
+declare function resolveEnvSpec(spec: Record<string, string> | undefined, source: EnvSpecSource | undefined): Record<string, string>;
+
+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>;
+}
+/** In-process adapter for tests and for use inside a ProcessRunner worker. */
+declare class PiRunnerAdapter {
+    #private;
+    private readonly driver;
+    constructor(driver: PiDriver);
+    prepare(request: RunRequest): RunnerHandle;
+    terminateProcess(pid: number): Promise<void>;
+}
+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>;
+}
+declare function piWorkerPath(): string;
+declare function verificationWorkerPath(): string;
+type WorkerRequest = Omit<RunRequest, "now" | "emit" | "rpc" | "turn"> & {
+    turn?: TurnContext;
+    runtime?: JsonValue;
+};
+/** 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 WorkerRpc = (method: RunnerRpcMethod, params: JsonValue) => Promise<JsonValue>;
+interface WorkerControls {
+    onSteer(listener: (message: string) => boolean): void;
+}
+type WorkerRun = (request: WorkerRequest, emit: (event: {
+    type: string;
+    data: JsonValue;
+}) => void, rpc: WorkerRpc, controls: WorkerControls) => Promise<RunnerCandidateResult>;
+/** Entry helper for runner executables. It exits when its parent disappears. */
+declare function runProcessWorker(run: WorkerRun): Promise<void>;
+
+export { LOCAL_PROVIDERS, PiRunnerAdapter, ProcessRunner, createPiProcessRunner, defaultAuthFile, modelCatalog, piConfig, piEnvironment, piRunnerConfigurator, piWorkerPath, providerCatalog, resolveEnvSpec, runProcessWorker, verificationWorkerPath };
+export type { ModelSummary, PiDriver, PiRunnerConfig, PiRunnerSession, PiStep, ProcessRunnerOptions, ProviderSummary, WorkerControls, WorkerRpc, WorkerRun };

package/dist/runner-pi.js

@@ -1,2 +1,46 @@
-export * from "goah-runner-pi";
-//# sourceMappingURL=runner-pi.js.map
+import { createRequire as __goahCreateRequire } from "node:module";
+const require = __goahCreateRequire(import.meta.url);
+import {
+  PiRunnerAdapter,
+  ProcessRunner,
+  createPiProcessRunner,
+  piConfig,
+  piEnvironment,
+  piRunnerConfigurator,
+  piWorkerPath,
+  resolveEnvSpec,
+  runProcessWorker,
+  verificationWorkerPath
+} from "./chunk-7E7V6OIU.js";
+import {
+  LOCAL_PROVIDERS,
+  defaultAuthFile,
+  modelCatalog,
+  providerCatalog
+} from "./chunk-6M3OOCKO.js";
+import "./chunk-K26BVR6O.js";
+import "./chunk-IIJQ3DW4.js";
+import "./chunk-2ZP2NBW3.js";
+import "./chunk-MPXK7QBL.js";
+import "./chunk-2QBQZGXF.js";
+import "./chunk-4KA63VNZ.js";
+import "./chunk-KAO7WIXG.js";
+import "./chunk-R6I3VKME.js";
+import "./chunk-TJON22J4.js";
+import "./chunk-XPQKM3L7.js";
+export {
+  LOCAL_PROVIDERS,
+  PiRunnerAdapter,
+  ProcessRunner,
+  createPiProcessRunner,
+  defaultAuthFile,
+  modelCatalog,
+  piConfig,
+  piEnvironment,
+  piRunnerConfigurator,
+  piWorkerPath,
+  providerCatalog,
+  resolveEnvSpec,
+  runProcessWorker,
+  verificationWorkerPath
+};

package/dist/runner-registry-GD4BYCQC.js

@@ -0,0 +1,22 @@
+import { createRequire as __goahCreateRequire } from "node:module";
+const require = __goahCreateRequire(import.meta.url);
+import {
+  runnerManifests,
+  runnerPlugin
+} from "./chunk-D2DVAH37.js";
+import "./chunk-7E7V6OIU.js";
+import "./chunk-6M3OOCKO.js";
+import "./chunk-K26BVR6O.js";
+import "./chunk-IIJQ3DW4.js";
+import "./chunk-2ZP2NBW3.js";
+import "./chunk-MPXK7QBL.js";
+import "./chunk-2QBQZGXF.js";
+import "./chunk-4KA63VNZ.js";
+import "./chunk-KAO7WIXG.js";
+import "./chunk-R6I3VKME.js";
+import "./chunk-TJON22J4.js";
+import "./chunk-XPQKM3L7.js";
+export {
+  runnerManifests,
+  runnerPlugin
+};