@smithers-orchestrator/cli 0.17.0 → 0.18.0

package/dist/CliExitCode-dlFKbqup.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Uniform CLI exit codes for the devtools live-run commands.
+ *
+ * - 0   ok
+ * - 1   user error (bad flags, missing id, declined confirmation)
+ * - 2   server error (transport, backend, unexpected condition)
+ * - 3   declined (user aborted at an interactive prompt)
+ * - 130 sigint (ctrl-c during a watch/stream)
+ */
+type CliExitCode = 0 | 1 | 2 | 3 | 130;
+
+export type { CliExitCode as C };

package/dist/HijackCandidate-FxLeKpcZ.d.ts

@@ -0,0 +1,13 @@
+type HijackCandidate = {
+    runId: string;
+    nodeId: string;
+    iteration: number;
+    attempt: number;
+    engine: string;
+    mode: "native-cli" | "conversation";
+    resume?: string;
+    messages?: unknown[];
+    cwd: string;
+};
+
+export type { HijackCandidate as H };

package/dist/SemanticToolDefinition-C1UT6pZk.d.ts

@@ -0,0 +1,71 @@
+import { z } from 'zod';
+import { findAndOpenDb } from './find-db.js';
+
+/**
+ * @param {Partial<SemanticToolContext>} [options]
+ * @returns {SemanticToolDefinition[]}
+ */
+declare function createSemanticToolDefinitions(options?: Partial<SemanticToolContext>): SemanticToolDefinition$1[];
+/**
+ * @typedef {{ content: Array<{ type: "text"; text: string; }>; structuredContent: { ok: boolean; data?: unknown; error?: z.infer<typeof toolErrorSchema>; }; isError?: boolean; }} SemanticToolCallResult
+ */
+/**
+ * @typedef {{ cwd: () => string; openDb: typeof findAndOpenDb; }} SemanticToolContext
+ */
+/** @typedef {import("./SemanticToolDefinition.ts").SemanticToolDefinition} SemanticToolDefinition */
+declare const SEMANTIC_TOOL_NAMES: string[];
+type SemanticToolCallResult$1 = {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    structuredContent: {
+        ok: boolean;
+        data?: unknown;
+        error?: z.infer<typeof toolErrorSchema>;
+    };
+    isError?: boolean;
+};
+type SemanticToolContext = {
+    cwd: () => string;
+    openDb: typeof findAndOpenDb;
+};
+type SemanticToolDefinition$1 = SemanticToolDefinition;
+
+declare const toolErrorSchema: z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodString;
+    details: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    docsUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+
+type SemanticToolError = {
+    code: string;
+    message: string;
+    details?: Record<string, unknown> | null;
+    docsUrl?: string | null;
+};
+
+type SemanticToolCallResult = {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    structuredContent: {
+        ok: boolean;
+        data?: unknown;
+        error?: SemanticToolError;
+    };
+    isError?: boolean;
+};
+
+type SemanticToolDefinition = {
+    name: (typeof SEMANTIC_TOOL_NAMES)[number];
+    description: string;
+    inputSchema: z.ZodTypeAny;
+    outputSchema: z.ZodTypeAny;
+    annotations: Record<string, boolean>;
+    handler: (input: any) => Promise<SemanticToolCallResult>;
+};
+
+export { type SemanticToolDefinition as S, SEMANTIC_TOOL_NAMES as a, type SemanticToolCallResult$1 as b, type SemanticToolContext as c, type SemanticToolDefinition$1 as d, createSemanticToolDefinitions as e };

package/dist/SupervisorOptions-DtiPbGFx.d.ts

@@ -0,0 +1,27 @@
+import { SmithersDb } from '@smithers-orchestrator/db/adapter';
+
+type SupervisorSpawnClaim = {
+    claimOwnerId: string;
+    claimHeartbeatAtMs: number;
+    restoreRuntimeOwnerId?: string | null;
+    restoreHeartbeatAtMs?: number | null;
+};
+type SupervisorDeps = {
+    now: () => number;
+    workflowExists: (workflowPath: string) => boolean;
+    parseRuntimeOwnerPid: (runtimeOwnerId: string | null | undefined) => number | null;
+    isPidAlive: (pid: number) => boolean;
+    spawnResumeDetached: (workflowPath: string, runId: string, claim?: SupervisorSpawnClaim) => number | null;
+};
+type SupervisorOptions = {
+    adapter: SmithersDb;
+    pollIntervalMs?: number;
+    staleThresholdMs?: number;
+    maxConcurrent?: number;
+    dryRun?: boolean;
+    supervisorId?: string;
+    supervisorRunId?: string;
+    deps?: Partial<SupervisorDeps>;
+};
+
+export type { SupervisorSpawnClaim as S, SupervisorOptions as a };

package/dist/agent-commands/agentAddWizard.d.ts

@@ -0,0 +1,18 @@
+import * as _smithers_orchestrator_accounts from '@smithers-orchestrator/accounts';
+
+/**
+ * Interactive `smithers agents add` wizard. Loops until the user is done
+ * adding accounts. Returns the list of labels that were added in this session.
+ *
+ * @param {{ env?: NodeJS.ProcessEnv; cwd?: string; loop?: boolean; skipIntro?: boolean }} [opts]
+ * @returns {Promise<string[]>}
+ */
+declare function agentAddWizard(opts?: {
+    env?: NodeJS.ProcessEnv;
+    cwd?: string;
+    loop?: boolean;
+    skipIntro?: boolean;
+}): Promise<string[]>;
+type AccountProvider = _smithers_orchestrator_accounts.AccountProvider;
+
+export { type AccountProvider, agentAddWizard };

package/dist/agent-commands/regenerateAgentsTsIfPresent.d.ts

@@ -0,0 +1,15 @@
+/**
+ * If the current working directory contains a `.smithers/agents.ts` that was
+ * previously generated by smithers (sentinel comment present), regenerate it
+ * to reflect the current accounts registry. User-edited files are left alone.
+ *
+ * @param {string} [cwd]
+ * @returns {{ rewritten: boolean; path: string | null; reason?: string }}
+ */
+declare function regenerateAgentsTsIfPresent(cwd?: string): {
+    rewritten: boolean;
+    path: string | null;
+    reason?: string;
+};
+
+export { regenerateAgentsTsIfPresent };

package/dist/agent-commands/runAgentAdd.d.ts

@@ -0,0 +1,83 @@
+import * as _smithers_orchestrator_accounts from '@smithers-orchestrator/accounts';
+
+/**
+ * @typedef {{
+ *   provider: AccountProvider;
+ *   label: string;
+ *   configDir?: string;
+ *   apiKey?: string;
+ *   model?: string;
+ *   skipLogin?: boolean;
+ *   force?: boolean;
+ *   replace?: boolean;
+ *   env?: NodeJS.ProcessEnv;
+ *   cwd?: string;
+ *   loginInstructions?: (cmd: string) => void;
+ * }} RunAgentAddInput
+ */
+/**
+ * Non-interactive entry point: register an account from already-resolved
+ * inputs. Used by both the flag-driven CLI and the clack wizard. Returns the
+ * persisted account plus a summary of the register/regen operation.
+ *
+ * @param {RunAgentAddInput} input
+ */
+declare function runAgentAdd(input: RunAgentAddInput): {
+    ok: boolean;
+    reason: string;
+    detail: string;
+    configDir: string;
+    account?: undefined;
+    regen?: undefined;
+} | {
+    ok: boolean;
+    account: _smithers_orchestrator_accounts.Account;
+    regen: {
+        rewritten: boolean;
+        path: string | null;
+        reason?: string;
+    };
+    reason?: undefined;
+    detail?: undefined;
+    configDir?: undefined;
+} | {
+    ok: boolean;
+    reason: string;
+    detail: string;
+    configDir?: undefined;
+    account?: undefined;
+    regen?: undefined;
+};
+/**
+ * Quick health check: spawn `<bin> --version` (or equivalent) under the
+ * account's env vars and report whether the CLI starts cleanly. Best-effort —
+ * a non-zero exit is reported but does not throw.
+ *
+ * @param {{ provider: AccountProvider; configDir?: string; apiKey?: string }} account
+ * @returns {{ ran: boolean; exitCode: number | null; cmd: string }}
+ */
+declare function pingAccount(account: {
+    provider: AccountProvider;
+    configDir?: string;
+    apiKey?: string;
+}): {
+    ran: boolean;
+    exitCode: number | null;
+    cmd: string;
+};
+type RunAgentAddInput = {
+    provider: AccountProvider;
+    label: string;
+    configDir?: string;
+    apiKey?: string;
+    model?: string;
+    skipLogin?: boolean;
+    force?: boolean;
+    replace?: boolean;
+    env?: NodeJS.ProcessEnv;
+    cwd?: string;
+    loginInstructions?: (cmd: string) => void;
+};
+type AccountProvider = _smithers_orchestrator_accounts.AccountProvider;
+
+export { type AccountProvider, type RunAgentAddInput, pingAccount, runAgentAdd };

package/dist/agent-detection.d.ts

@@ -0,0 +1,27 @@
+type AgentAvailabilityStatus$1 = "likely-subscription" | "api-key" | "binary-only" | "unavailable";
+
+type AgentAvailability$1 = {
+    id: "claude" | "codex" | "gemini" | "pi" | "kimi" | "amp";
+    binary: string;
+    hasBinary: boolean;
+    hasAuthSignal: boolean;
+    hasApiKeySignal: boolean;
+    status: AgentAvailabilityStatus$1;
+    score: number;
+    usable: boolean;
+    checks: string[];
+};
+
+/**
+ * @param {NodeJS.ProcessEnv} [env]
+ * @returns {AgentAvailability[]}
+ */
+declare function detectAvailableAgents(env?: NodeJS.ProcessEnv): AgentAvailability[];
+/**
+ * @param {NodeJS.ProcessEnv} [env]
+ */
+declare function generateAgentsTs(env?: NodeJS.ProcessEnv): string;
+type AgentAvailability = AgentAvailability$1;
+type AgentAvailabilityStatus = AgentAvailabilityStatus$1;
+
+export { type AgentAvailability, type AgentAvailabilityStatus, detectAvailableAgents, generateAgentsTs };

package/dist/ask.d.ts

@@ -0,0 +1,29 @@
+import * as _smithers_orchestrator_agents_agent_contract from '@smithers-orchestrator/agents/agent-contract';
+
+/**
+ * @param {string | undefined} question
+ * @param {string} cwd
+ * @param {AskOptions} [options]
+ * @returns {Promise<void>}
+ */
+declare function ask(question: string | undefined, cwd: string, options?: AskOptions): Promise<void>;
+type AskAgentId = (typeof ASK_AGENT_IDS)[number];
+type AskOptions = {
+    agent?: AskAgentId;
+    listAgents?: boolean;
+    dumpPrompt?: boolean;
+    toolSurface?: SmithersToolSurface;
+    noMcp?: boolean;
+    printBootstrap?: boolean;
+};
+type SmithersToolSurface = _smithers_orchestrator_agents_agent_contract.SmithersToolSurface;
+/**
+ * @typedef {typeof ASK_AGENT_IDS[number]} AskAgentId
+ */
+/**
+ * @typedef {{ agent?: AskAgentId; listAgents?: boolean; dumpPrompt?: boolean; toolSurface?: SmithersToolSurface; noMcp?: boolean; printBootstrap?: boolean; }} AskOptions
+ */
+/** @typedef {import("@smithers-orchestrator/agents/agent-contract").SmithersToolSurface} SmithersToolSurface */
+declare const ASK_AGENT_IDS: string[];
+
+export { type AskAgentId, type AskOptions, type SmithersToolSurface, ask };

package/dist/chat.d.ts

@@ -0,0 +1,96 @@
+type ParsedNodeOutputEvent$1 = {
+    seq: number;
+    timestampMs: number;
+    nodeId: string;
+    iteration: number;
+    attempt: number;
+    stream: "stdout" | "stderr";
+    text: string;
+};
+
+type ChatOutputEvent$1 = {
+    seq: number;
+    timestampMs: number;
+    type: string;
+    payloadJson: string;
+};
+
+type ChatAttemptRow$1 = {
+    runId: string;
+    nodeId: string;
+    iteration: number;
+    attempt: number;
+    state: string;
+    startedAtMs: number;
+    finishedAtMs?: number | null;
+    cached?: boolean | null;
+    metaJson?: string | null;
+    responseText?: string | null;
+};
+
+type ChatAttemptMeta$1 = {
+    kind?: string | null;
+    prompt?: string | null;
+    label?: string | null;
+    agentId?: string | null;
+    agentModel?: string | null;
+};
+
+/** @typedef {import("./ChatAttemptMeta.ts").ChatAttemptMeta} ChatAttemptMeta */
+/** @typedef {import("./ChatAttemptRow.ts").ChatAttemptRow} ChatAttemptRow */
+/** @typedef {import("./ChatOutputEvent.ts").ChatOutputEvent} ChatOutputEvent */
+/** @typedef {import("./ParsedNodeOutputEvent.ts").ParsedNodeOutputEvent} ParsedNodeOutputEvent */
+/**
+ * @param {string | null} [metaJson]
+ * @returns {ChatAttemptMeta}
+ */
+declare function parseChatAttemptMeta(metaJson?: string | null): ChatAttemptMeta;
+/**
+ * @param {Pick<ChatAttemptRow, "nodeId" | "iteration" | "attempt">} attempt
+ */
+declare function chatAttemptKey(attempt: Pick<ChatAttemptRow, "nodeId" | "iteration" | "attempt">): string;
+/**
+ * @param {ChatOutputEvent} event
+ * @returns {ParsedNodeOutputEvent | null}
+ */
+declare function parseNodeOutputEvent(event: ChatOutputEvent): ParsedNodeOutputEvent | null;
+/**
+ * @param {ChatOutputEvent} event
+ * @returns {ParsedNodeOutputEvent | null}
+ */
+declare function parseAgentEvent(event: ChatOutputEvent): ParsedNodeOutputEvent | null;
+/**
+ * @param {ChatAttemptRow} attempt
+ * @param {ReadonlySet<string>} outputAttemptKeys
+ * @returns {boolean}
+ */
+declare function isAgentAttempt(attempt: ChatAttemptRow, outputAttemptKeys: ReadonlySet<string>): boolean;
+/**
+ * @param {ChatAttemptRow[]} attempts
+ * @param {ReadonlySet<string>} outputAttemptKeys
+ * @param {boolean} includeAll
+ * @returns {ChatAttemptRow[]}
+ */
+declare function selectChatAttempts(attempts: ChatAttemptRow[], outputAttemptKeys: ReadonlySet<string>, includeAll: boolean): ChatAttemptRow[];
+/**
+ * @param {ChatAttemptRow} attempt
+ * @returns {string}
+ */
+declare function formatChatAttemptHeader(attempt: ChatAttemptRow): string;
+/**
+ * @param {{ baseMs: number; timestampMs: number; role: "user" | "assistant" | "stderr"; attempt: Pick<ChatAttemptRow, "nodeId" | "iteration" | "attempt">; text: string; }} options
+ * @returns {string}
+ */
+declare function formatChatBlock(options: {
+    baseMs: number;
+    timestampMs: number;
+    role: "user" | "assistant" | "stderr";
+    attempt: Pick<ChatAttemptRow, "nodeId" | "iteration" | "attempt">;
+    text: string;
+}): string;
+type ChatAttemptMeta = ChatAttemptMeta$1;
+type ChatAttemptRow = ChatAttemptRow$1;
+type ChatOutputEvent = ChatOutputEvent$1;
+type ParsedNodeOutputEvent = ParsedNodeOutputEvent$1;
+
+export { type ChatAttemptMeta, type ChatAttemptRow, type ChatOutputEvent, type ParsedNodeOutputEvent, chatAttemptKey, formatChatAttemptHeader, formatChatBlock, isAgentAttempt, parseAgentEvent, parseChatAttemptMeta, parseNodeOutputEvent, selectChatAttempts };

package/dist/diff.d.ts

@@ -0,0 +1,64 @@
+import { SmithersDb } from '@smithers-orchestrator/db/adapter';
+
+type RunDiffCommandResult$1 = {
+    exitCode: number;
+};
+
+type RunDiffCommandInput$1 = {
+    adapter: SmithersDb;
+    runId: string;
+    nodeId: string;
+    iteration?: number;
+    stat?: boolean;
+    json?: boolean;
+    color?: boolean;
+    stdout: NodeJS.WritableStream;
+    stderr: NodeJS.WritableStream;
+};
+
+type DiffBundleLike$1 = {
+    patches: Array<{
+        path?: string;
+        diff?: string;
+    }>;
+};
+
+/**
+ * @param {DiffBundleLike} bundle
+ * @param {{ color?: boolean }} [options]
+ * @returns {string}
+ */
+declare function renderUnifiedDiff(bundle: DiffBundleLike, options?: {
+    color?: boolean;
+}): string;
+/**
+ * Render a stat summary. Accepts either:
+ * - a server-side `summary` response ({ filesChanged, added, removed, files })
+ * - or a legacy `DiffBundle` (computes summary on the fly, streaming
+ *   through patches so no intermediate array of full patch text is held).
+ *
+ * @param {DiffBundleLike | { summary: { filesChanged: number; added: number; removed: number; files: Array<{ path: string; added: number; removed: number }> } }} input
+ * @returns {string}
+ */
+declare function renderDiffStat(input: DiffBundleLike | {
+    summary: {
+        filesChanged: number;
+        added: number;
+        removed: number;
+        files: Array<{
+            path: string;
+            added: number;
+            removed: number;
+        }>;
+    };
+}): string;
+/**
+ * @param {RunDiffCommandInput} input
+ * @returns {Promise<RunDiffCommandResult>}
+ */
+declare function runDiffOnce(input: RunDiffCommandInput): Promise<RunDiffCommandResult>;
+type DiffBundleLike = DiffBundleLike$1;
+type RunDiffCommandInput = RunDiffCommandInput$1;
+type RunDiffCommandResult = RunDiffCommandResult$1;
+
+export { type DiffBundleLike, type RunDiffCommandInput, type RunDiffCommandResult, renderDiffStat, renderUnifiedDiff, runDiffOnce };

package/dist/event-categories.d.ts

@@ -0,0 +1,26 @@
+import { SmithersEvent } from '@smithers-orchestrator/observability/SmithersEvent';
+
+type SmithersEventType$1 = SmithersEvent["type"];
+
+type EventCategory$1 = "agent" | "approval" | "frame" | "memory" | "node" | "openapi" | "output" | "revert" | "run" | "sandbox" | "scorer" | "snapshot" | "supervisor" | "timer" | "token" | "tool-call" | "workflow";
+
+/**
+ * @param {string} raw
+ * @returns {EventCategory | null}
+ */
+declare function normalizeEventCategory(raw: string): EventCategory | null;
+/**
+ * @param {string} type
+ * @returns {EventCategory | null}
+ */
+declare function eventCategoryForType(type: string): EventCategory | null;
+/**
+ * @param {EventCategory} category
+ * @returns {readonly SmithersEventType[]}
+ */
+declare function eventTypesForCategory(category: EventCategory): readonly SmithersEventType[];
+declare const EVENT_CATEGORY_VALUES: string[];
+type EventCategory = EventCategory$1;
+type SmithersEventType = SmithersEventType$1;
+
+export { EVENT_CATEGORY_VALUES, type EventCategory, type SmithersEventType, eventCategoryForType, eventTypesForCategory, normalizeEventCategory };

package/dist/find-db.d.ts

@@ -0,0 +1,47 @@
+import { SmithersDb } from '@smithers-orchestrator/db/adapter';
+
+type FindDbWaitOptions$1 = {
+    timeoutMs?: number;
+    intervalMs?: number;
+};
+
+/** @typedef {import("./FindDbWaitOptions.ts").FindDbWaitOptions} FindDbWaitOptions */
+/**
+ * Walk from `from` (default: cwd) upward looking for smithers.db.
+ * Returns the absolute path to the database file.
+ *
+ * @param {string} [from]
+ * @returns {string}
+ */
+declare function findSmithersDb(from?: string): string;
+/**
+ * @param {string} [from]
+ * @param {FindDbWaitOptions} [opts]
+ * @returns {Promise<string>}
+ */
+declare function waitForSmithersDb(from?: string, opts?: FindDbWaitOptions): Promise<string>;
+/**
+ * Open a smithers.db file and return a SmithersDb adapter with cleanup function.
+ *
+ * @param {string} dbPath
+ * @returns {Promise<{ adapter: SmithersDb; cleanup: () => void }>}
+ */
+declare function openSmithersDb(dbPath: string): Promise<{
+    adapter: SmithersDb;
+    cleanup: () => void;
+}>;
+/**
+ * Find and open the nearest smithers.db.
+ *
+ * @param {string} [from]
+ * @param {FindDbWaitOptions} [opts]
+ * @returns {Promise<{ adapter: SmithersDb; dbPath: string; cleanup: () => void }>}
+ */
+declare function findAndOpenDb(from?: string, opts?: FindDbWaitOptions): Promise<{
+    adapter: SmithersDb;
+    dbPath: string;
+    cleanup: () => void;
+}>;
+type FindDbWaitOptions = FindDbWaitOptions$1;
+
+export { type FindDbWaitOptions, findAndOpenDb, findSmithersDb, openSmithersDb, waitForSmithersDb };

package/dist/format.d.ts

@@ -0,0 +1,35 @@
+type FormatEventLineOptions$1 = {
+    includeTimestamp?: boolean;
+    truncatePayloadAt?: number;
+};
+
+/**
+ * Format a timestamp as relative age: "2m ago", "1h ago", "3d ago"
+ */
+declare function formatAge(ms: any): string;
+/**
+ * Format elapsed time compactly: "5m 23s", "1h 2m", "45s"
+ */
+declare function formatElapsedCompact(startMs: any, endMs: any): string;
+/**
+ * Format an elapsed time as HH:MM:SS from a base timestamp.
+ */
+declare function formatTimestamp(baseMs: any, eventMs: any): string;
+/**
+ * Format an elapsed time as a signed relative offset:
+ * +MM:SS.mmm (or +HH:MM:SS.mmm when hours > 0).
+ */
+declare function formatRelativeOffset(baseMs: any, eventMs: any): string;
+/**
+ * @param {string} type
+ * @param {string} text
+ * @returns {string}
+ */
+declare function colorizeEventText(type: string, text: string): string;
+/**
+ * Format a single event from _smithers_events into a log line.
+ */
+declare function formatEventLine(event: any, baseMs: any, options: any): string;
+type FormatEventLineOptions = FormatEventLineOptions$1;
+
+export { type FormatEventLineOptions, colorizeEventText, formatAge, formatElapsedCompact, formatEventLine, formatRelativeOffset, formatTimestamp };

package/dist/hijack-session.d.ts

@@ -0,0 +1,25 @@
+import * as _smithers_orchestrator_db_adapter from '@smithers-orchestrator/db/adapter';
+import { H as HijackCandidate$1 } from './HijackCandidate-FxLeKpcZ.js';
+
+/**
+ * @param {SmithersDb} adapter
+ * @param {HijackCandidate} candidate
+ * @param {unknown[]} messages
+ */
+declare function persistConversationHijackHandoff(adapter: SmithersDb, candidate: HijackCandidate, messages: unknown[]): Promise<void>;
+/**
+ * @param {SmithersDb} adapter
+ * @param {HijackCandidate & { mode: "conversation"; messages: unknown[] }} candidate
+ * @returns {Promise<{ code: number; messages: unknown[] }>}
+ */
+declare function launchConversationHijackSession(adapter: SmithersDb, candidate: HijackCandidate & {
+    mode: "conversation";
+    messages: unknown[];
+}): Promise<{
+    code: number;
+    messages: unknown[];
+}>;
+type HijackCandidate = HijackCandidate$1;
+type SmithersDb = _smithers_orchestrator_db_adapter.SmithersDb;
+
+export { type HijackCandidate, type SmithersDb, launchConversationHijackSession, persistConversationHijackHandoff };

package/dist/hijack.d.ts

@@ -0,0 +1,54 @@
+import * as _smithers_orchestrator_db_adapter from '@smithers-orchestrator/db/adapter';
+import { H as HijackCandidate$1 } from './HijackCandidate-FxLeKpcZ.js';
+
+type NativeHijackEngine$1 = "claude-code" | "codex" | "gemini" | "pi" | "kimi" | "forge" | "amp";
+
+type HijackLaunchSpec$1 = {
+    command: string;
+    args: string[];
+    cwd: string;
+    env: Record<string, string>;
+};
+
+/**
+ * @param {SmithersDb} adapter
+ * @param {string} runId
+ * @param {string} [target]
+ * @returns {Promise<HijackCandidate | null>}
+ */
+declare function resolveHijackCandidate(adapter: SmithersDb, runId: string, target?: string): Promise<HijackCandidate | null>;
+/**
+ * @param {SmithersDb} adapter
+ * @param {string} runId
+ * @param {{ target?: string; timeoutMs?: number }} [options]
+ * @returns {Promise<HijackCandidate>}
+ */
+declare function waitForHijackCandidate(adapter: SmithersDb, runId: string, options?: {
+    target?: string;
+    timeoutMs?: number;
+}): Promise<HijackCandidate>;
+/**
+ * @param {HijackCandidate} candidate
+ * @returns {HijackLaunchSpec}
+ */
+declare function buildHijackLaunchSpec(candidate: HijackCandidate): HijackLaunchSpec;
+/**
+ * @param {HijackCandidate} candidate
+ * @returns {candidate is HijackCandidate & { mode: "native-cli"; engine: NativeHijackEngine; resume: string }}
+ */
+declare function isNativeHijackCandidate(candidate: HijackCandidate): candidate is HijackCandidate & {
+    mode: "native-cli";
+    engine: NativeHijackEngine;
+    resume: string;
+};
+/**
+ * @param {HijackLaunchSpec} spec
+ * @returns {Promise<number>}
+ */
+declare function launchHijackSession(spec: HijackLaunchSpec): Promise<number>;
+type HijackCandidate = HijackCandidate$1;
+type HijackLaunchSpec = HijackLaunchSpec$1;
+type NativeHijackEngine = NativeHijackEngine$1;
+type SmithersDb = _smithers_orchestrator_db_adapter.SmithersDb;
+
+export { type HijackCandidate, type HijackLaunchSpec, type NativeHijackEngine, type SmithersDb, buildHijackLaunchSpec, isNativeHijackCandidate, launchHijackSession, resolveHijackCandidate, waitForHijackCandidate };

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env bun