@smithers-orchestrator/cli 0.16.9 → 0.18.0

package/dist/mcp/semantic-server.d.ts

@@ -0,0 +1,30 @@
+import { S as SemanticToolDefinition$1 } from '../SemanticToolDefinition-C1UT6pZk.js';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import 'zod';
+import '../find-db.js';
+import '@smithers-orchestrator/db/adapter';
+
+type SemanticMcpServerOptions$1 = {
+    name?: string;
+    version?: string;
+};
+
+/** @typedef {import("./SemanticMcpServerOptions.ts").SemanticMcpServerOptions} SemanticMcpServerOptions */
+/** @typedef {import("./SemanticToolDefinition.ts").SemanticToolDefinition} SemanticToolDefinition */
+/**
+ * @param {McpServer} server
+ * @param {SemanticToolDefinition[]} [toolDefinitions]
+ */
+declare function registerSemanticTools(server: McpServer, toolDefinitions?: SemanticToolDefinition[]): McpServer;
+/**
+ * @param {SemanticMcpServerOptions} [options]
+ */
+declare function createSemanticMcpServer(options?: SemanticMcpServerOptions): McpServer;
+/**
+ * @param {SemanticMcpServerOptions} [options]
+ */
+declare function serveSemanticMcpServer(options?: SemanticMcpServerOptions): Promise<McpServer>;
+type SemanticMcpServerOptions = SemanticMcpServerOptions$1;
+type SemanticToolDefinition = SemanticToolDefinition$1;
+
+export { type SemanticMcpServerOptions, type SemanticToolDefinition, createSemanticMcpServer, registerSemanticTools, serveSemanticMcpServer };

package/dist/mcp/semantic-tools.d.ts

@@ -0,0 +1,4 @@
+export { a as SEMANTIC_TOOL_NAMES, b as SemanticToolCallResult, c as SemanticToolContext, d as SemanticToolDefinition, e as createSemanticToolDefinitions } from '../SemanticToolDefinition-C1UT6pZk.js';
+import 'zod';
+import '../find-db.js';
+import '@smithers-orchestrator/db/adapter';

package/dist/mdx-plugin.d.ts

@@ -0,0 +1,3 @@
+declare function mdxPlugin(): void;
+
+export { mdxPlugin };

package/dist/node-detail.d.ts

@@ -0,0 +1,143 @@
+import * as _smithers_orchestrator_db_adapter from '@smithers-orchestrator/db/adapter';
+import { Effect } from 'effect';
+import { SmithersError } from '@smithers-orchestrator/errors';
+
+type RenderNodeDetailOptions$1 = {
+    expandAttempts: boolean;
+    expandTools: boolean;
+};
+
+type NodeDetailToolCall$1 = {
+    attempt: number;
+    seq: number;
+    name: string;
+    status: string;
+    startedAtMs: number;
+    finishedAtMs: number | null;
+    durationMs: number | null;
+    input: unknown | null;
+    output: unknown | null;
+    error: string | null;
+};
+
+type NodeDetailTokenUsage$1 = {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+    reasoningTokens: number;
+    costUsd: number | null;
+    eventCount: number;
+    models: string[];
+    agents: string[];
+};
+
+type NodeDetailAttempt$1 = {
+    runId: string;
+    nodeId: string;
+    iteration: number;
+    attempt: number;
+    state: string;
+    startedAtMs: number;
+    finishedAtMs: number | null;
+    durationMs: number | null;
+    error: string | null;
+    errorDetail: unknown | null;
+    tokenUsage: NodeDetailTokenUsage$1;
+    toolCalls: NodeDetailToolCall$1[];
+    meta: unknown | null;
+    responseText: string | null;
+    cached: boolean;
+    jjPointer: string | null;
+    jjCwd: string | null;
+};
+
+type AttemptSummary$1 = {
+    total: number;
+    failed: number;
+    cancelled: number;
+    succeeded: number;
+    waiting: number;
+};
+type EnrichedNodeDetail$1 = {
+    node: {
+        runId: string;
+        nodeId: string;
+        iteration: number;
+        state: string;
+        lastAttempt: number | null;
+        updatedAtMs: number | null;
+        outputTable: string | null;
+        label: string | null;
+    };
+    status: string;
+    durationMs: number | null;
+    attemptsSummary: AttemptSummary$1;
+    attempts: NodeDetailAttempt$1[];
+    toolCalls: NodeDetailToolCall$1[];
+    tokenUsage: NodeDetailTokenUsage$1 & {
+        byAttempt: Array<{
+            attempt: number;
+            usage: NodeDetailTokenUsage$1;
+        }>;
+    };
+    scorers: Array<{
+        id: string;
+        attempt: number;
+        scorerId: string;
+        scorerName: string;
+        source: string;
+        score: number;
+        reason: string | null;
+        latencyMs: number | null;
+        durationMs: number | null;
+        scoredAtMs: number;
+        meta: unknown | null;
+        input: unknown | null;
+        output: unknown | null;
+    }>;
+    output: {
+        validated: unknown | null;
+        raw: unknown | null;
+        source: "cache" | "output-table" | "none";
+        cacheKey: string | null;
+    };
+    limits: {
+        toolPayloadBytesHuman: number;
+        validatedOutputBytesHuman: number;
+    };
+};
+
+type AggregateNodeDetailParams$1 = {
+    runId: string;
+    nodeId: string;
+    iteration?: number;
+};
+
+/**
+ * @param {SmithersDb} adapter
+ * @param {AggregateNodeDetailParams} params
+ * @returns {Effect.Effect<EnrichedNodeDetail, SmithersError>}
+ */
+declare function aggregateNodeDetailEffect(adapter: SmithersDb, params: AggregateNodeDetailParams): Effect.Effect<EnrichedNodeDetail, SmithersError>;
+/**
+ * @param {EnrichedNodeDetail} detail
+ * @param {RenderNodeDetailOptions} options
+ */
+declare function renderNodeDetailHuman(detail: EnrichedNodeDetail, options: RenderNodeDetailOptions): string;
+type AggregateNodeDetailParams = AggregateNodeDetailParams$1;
+type AttemptSummary = {
+    total: number;
+    failed: number;
+    cancelled: number;
+    succeeded: number;
+    waiting: number;
+};
+type EnrichedNodeDetail = EnrichedNodeDetail$1;
+type NodeDetailAttempt = NodeDetailAttempt$1;
+type NodeDetailTokenUsage = NodeDetailTokenUsage$1;
+type NodeDetailToolCall = NodeDetailToolCall$1;
+type RenderNodeDetailOptions = RenderNodeDetailOptions$1;
+type SmithersDb = _smithers_orchestrator_db_adapter.SmithersDb;
+
+export { type AggregateNodeDetailParams, type AttemptSummary, type EnrichedNodeDetail, type NodeDetailAttempt, type NodeDetailTokenUsage, type NodeDetailToolCall, type RenderNodeDetailOptions, type SmithersDb, aggregateNodeDetailEffect, renderNodeDetailHuman };

package/dist/output.d.ts

@@ -0,0 +1,31 @@
+import { SmithersDb } from '@smithers-orchestrator/db/adapter';
+
+type RunOutputCommandResult$1 = {
+    exitCode: number;
+};
+
+type RunOutputCommandInput$1 = {
+    adapter: SmithersDb;
+    runId: string;
+    nodeId: string;
+    iteration?: number;
+    pretty?: boolean;
+    workflow?: unknown;
+    stdout: NodeJS.WritableStream;
+    stderr: NodeJS.WritableStream;
+};
+
+/**
+ * @param {any} response
+ * @returns {string}
+ */
+declare function renderPrettyOutput(response: any): string;
+/**
+ * @param {RunOutputCommandInput} input
+ * @returns {Promise<RunOutputCommandResult>}
+ */
+declare function runOutputOnce(input: RunOutputCommandInput): Promise<RunOutputCommandResult>;
+type RunOutputCommandInput = RunOutputCommandInput$1;
+type RunOutputCommandResult = RunOutputCommandResult$1;
+
+export { type RunOutputCommandInput, type RunOutputCommandResult, renderPrettyOutput, runOutputOnce };

package/dist/resume-detached.d.ts

@@ -0,0 +1,17 @@
+import { S as SupervisorSpawnClaim$1 } from './SupervisorOptions-DtiPbGFx.js';
+import '@smithers-orchestrator/db/adapter';
+
+/** @typedef {import("./SupervisorOptions.ts").SupervisorSpawnClaim} SupervisorSpawnClaim */
+/**
+ * Resume an existing run by launching `smithers up ... --resume` as a detached process.
+ * Returns the spawned PID when available.
+ *
+ * @param {string} workflowPath
+ * @param {string} runId
+ * @param {SupervisorSpawnClaim} [claim]
+ * @returns {number | null}
+ */
+declare function resumeRunDetached(workflowPath: string, runId: string, claim?: SupervisorSpawnClaim): number | null;
+type SupervisorSpawnClaim = SupervisorSpawnClaim$1;
+
+export { type SupervisorSpawnClaim, resumeRunDetached };

package/dist/rewind.d.ts

@@ -0,0 +1,28 @@
+import { SmithersDb } from '@smithers-orchestrator/db/adapter';
+
+type RunRewindCommandResult$1 = {
+    exitCode: number;
+};
+
+type RunRewindCommandInput$1 = {
+    adapter: SmithersDb;
+    runId: string;
+    frameNo: number;
+    yes?: boolean;
+    json?: boolean;
+    confirm?: () => Promise<boolean>;
+    onResult?: (result: unknown) => void;
+    stdin: NodeJS.ReadStream;
+    stdout: NodeJS.WritableStream;
+    stderr: NodeJS.WritableStream;
+};
+
+/**
+ * @param {RunRewindCommandInput} input
+ * @returns {Promise<RunRewindCommandResult>}
+ */
+declare function runRewindOnce(input: RunRewindCommandInput): Promise<RunRewindCommandResult>;
+type RunRewindCommandInput = RunRewindCommandInput$1;
+type RunRewindCommandResult = RunRewindCommandResult$1;
+
+export { type RunRewindCommandInput, type RunRewindCommandResult, runRewindOnce };

package/dist/scheduler.d.ts

@@ -0,0 +1,3 @@
+declare function runScheduler(pollIntervalMs?: number): Promise<void>;
+
+export { runScheduler };

package/dist/smithersRuntime.d.ts

@@ -0,0 +1,23 @@
+import * as effect_Fiber from 'effect/Fiber';
+import { Effect } from 'effect';
+
+/**
+ * @template A, E, R
+ * @param {Effect.Effect<A, E, R>} effect
+ * @param {{ signal?: AbortSignal }} [options]
+ */
+declare function runPromise<A, E, R>(effect: Effect.Effect<A, E, R>, options?: {
+    signal?: AbortSignal;
+}): Promise<A>;
+/**
+ * @template A, E, R
+ * @param {Effect.Effect<A, E, R>} effect
+ */
+declare function runFork<A, E, R>(effect: Effect.Effect<A, E, R>): effect_Fiber.RuntimeFiber<A, E>;
+/**
+ * @template A, E, R
+ * @param {Effect.Effect<A, E, R>} effect
+ */
+declare function runSync<A, E, R>(effect: Effect.Effect<A, E, R>): A;
+
+export { runFork, runPromise, runSync };

package/dist/supervisor.d.ts

@@ -0,0 +1,44 @@
+import { a as SupervisorOptions$1 } from './SupervisorOptions-DtiPbGFx.js';
+import * as _smithers_orchestrator_db_adapter from '@smithers-orchestrator/db/adapter';
+import { Effect } from 'effect';
+export { isPidAlive, parseRuntimeOwnerPid } from '@smithers-orchestrator/engine/runtime-owner';
+
+type SupervisorPollSummary$1 = {
+    staleCount: number;
+    resumedCount: number;
+    skippedCount: number;
+    durationMs: number;
+};
+
+type RunAutoResumeSkipReason$1 = "pid-alive" | "missing-workflow" | "rate-limited";
+
+/**
+ * @param {string} raw
+ * @param {string} fieldName
+ * @returns {number}
+ */
+declare function parseDurationMs(raw: string, fieldName: string): number;
+/**
+ * @param {SupervisorOptions} options
+ * @returns {Effect.Effect<SupervisorPollSummary, never>}
+ */
+declare function supervisorPollEffect(options: SupervisorOptions): Effect.Effect<SupervisorPollSummary, never>;
+/**
+ * @param {SupervisorOptions} options
+ * @returns {Effect.Effect<void, never>}
+ */
+declare function supervisorLoopEffect(options: SupervisorOptions): Effect.Effect<void, never>;
+/** @typedef {import("./RunAutoResumeSkipReason.ts").RunAutoResumeSkipReason} RunAutoResumeSkipReason */
+/** @typedef {import("@smithers-orchestrator/db/adapter").SmithersDb} SmithersDb */
+/** @typedef {import("./SupervisorOptions.ts").SupervisorOptions} SupervisorOptions */
+/** @typedef {import("./SupervisorPollSummary.ts").SupervisorPollSummary} SupervisorPollSummary */
+declare const DEFAULT_SUPERVISOR_INTERVAL_MS: 10000;
+declare const DEFAULT_SUPERVISOR_STALE_THRESHOLD_MS: 30000;
+declare const DEFAULT_SUPERVISOR_MAX_CONCURRENT: 3;
+declare const SUPERVISOR_EVENT_RUN_ID: "__supervisor__";
+type RunAutoResumeSkipReason = RunAutoResumeSkipReason$1;
+type SmithersDb = _smithers_orchestrator_db_adapter.SmithersDb;
+type SupervisorOptions = SupervisorOptions$1;
+type SupervisorPollSummary = SupervisorPollSummary$1;
+
+export { DEFAULT_SUPERVISOR_INTERVAL_MS, DEFAULT_SUPERVISOR_MAX_CONCURRENT, DEFAULT_SUPERVISOR_STALE_THRESHOLD_MS, type RunAutoResumeSkipReason, SUPERVISOR_EVENT_RUN_ID, type SmithersDb, type SupervisorOptions, type SupervisorPollSummary, parseDurationMs, supervisorLoopEffect, supervisorPollEffect };

package/dist/tree.d.ts

@@ -0,0 +1,51 @@
+import { SmithersDb } from '@smithers-orchestrator/db/adapter';
+import * as _smithers_orchestrator_protocol_devtools from '@smithers-orchestrator/protocol/devtools';
+
+type RunTreeCommandResult$1 = {
+    exitCode: number;
+};
+
+type RunTreeCommandInput$1 = {
+    adapter: SmithersDb;
+    runId: string;
+    frameNo?: number;
+    depth?: number;
+    node?: string;
+    color?: boolean;
+    json?: boolean;
+    abortSignal?: AbortSignal;
+    stdout: NodeJS.WritableStream;
+    stderr: NodeJS.WritableStream;
+};
+
+type TreeRenderOptions$1 = {
+    depth?: number;
+    nodeId?: string;
+    color?: boolean;
+};
+
+/**
+ * @param {import("@smithers-orchestrator/protocol/devtools").DevToolsNode} root
+ * @param {string} nodeId
+ * @returns {import("@smithers-orchestrator/protocol/devtools").DevToolsNode | null}
+ */
+declare function selectSubtree(root: _smithers_orchestrator_protocol_devtools.DevToolsNode, nodeId: string): _smithers_orchestrator_protocol_devtools.DevToolsNode | null;
+/**
+ * @param {import("@smithers-orchestrator/protocol/devtools").DevToolsSnapshot} snapshot
+ * @param {TreeRenderOptions} [options]
+ * @returns {string}
+ */
+declare function renderDevToolsTree(snapshot: _smithers_orchestrator_protocol_devtools.DevToolsSnapshot, options?: TreeRenderOptions): string;
+/**
+ * @param {RunTreeCommandInput} input
+ * @returns {Promise<RunTreeCommandResult>}
+ */
+declare function runTreeOnce(input: RunTreeCommandInput): Promise<RunTreeCommandResult>;
+/** @param {RunTreeCommandInput} input @returns {Promise<RunTreeCommandResult>} */
+declare function runTreeWatch(input: RunTreeCommandInput): Promise<RunTreeCommandResult>;
+declare const TREE_INDENT: "  ";
+type TreeRenderOptions = TreeRenderOptions$1;
+type RunTreeCommandInput = RunTreeCommandInput$1;
+type RunTreeCommandResult = RunTreeCommandResult$1;
+
+export { type RunTreeCommandInput, type RunTreeCommandResult, TREE_INDENT, type TreeRenderOptions, renderDevToolsTree, runTreeOnce, runTreeWatch, selectSubtree };

package/dist/util/errorMessage.d.ts

@@ -0,0 +1,40 @@
+import { C as CliExitCode } from '../CliExitCode-dlFKbqup.js';
+
+type CliErrorMapping$1 = {
+    message: string;
+    hint: string;
+    exitCode: CliExitCode;
+};
+
+/**
+ * @param {string | undefined | null} code
+ * @param {string} [rawMessage]
+ * @returns {CliErrorMapping}
+ */
+declare function getCliErrorMapping(code: string | undefined | null, rawMessage?: string): CliErrorMapping;
+/**
+ * @param {string | undefined | null} code
+ * @param {string} [rawMessage]
+ * @returns {string}
+ */
+declare function formatCliErrorForStderr(code: string | undefined | null, rawMessage?: string): string;
+/**
+ * Exhaustive map of every typed error code the four devtools RPCs may
+ * return. Each entry yields a user-friendly message plus an actionable
+ * hint and the uniform exit code to surface.
+ *
+ * Codes come from:
+ * - getDevToolsSnapshot / streamDevTools  (ticket 0010, 0011)
+ * - getNodeDiff                           (ticket 0012)
+ * - getNodeOutput                         (ticket 0012)
+ * - jumpToFrame                           (ticket 0013)
+ *
+ * Plus two transport-level codes used by the CLI itself when it cannot
+ * reach the server or the auth token is missing.
+ *
+ * @type {Readonly<Record<string, CliErrorMapping>>}
+ */
+declare const CLI_ERROR_MESSAGES: Readonly<Record<string, CliErrorMapping>>;
+type CliErrorMapping = CliErrorMapping$1;
+
+export { CLI_ERROR_MESSAGES, type CliErrorMapping, formatCliErrorForStderr, getCliErrorMapping };

package/dist/util/exitCodes.d.ts

@@ -0,0 +1,19 @@
+import { C as CliExitCode$1 } from '../CliExitCode-dlFKbqup.js';
+
+/** @typedef {import("./CliExitCode.ts").CliExitCode} CliExitCode */
+/** Uniform CLI exit codes for the devtools live-run commands. */
+declare const EXIT_OK: 0;
+declare const EXIT_USER_ERROR: 1;
+declare const EXIT_SERVER_ERROR: 2;
+declare const EXIT_DECLINED: 3;
+declare const EXIT_SIGINT: 130;
+declare const CLI_EXIT_CODES: Readonly<{
+    ok: 0;
+    userError: 1;
+    serverError: 2;
+    declined: 3;
+    sigint: 130;
+}>;
+type CliExitCode = CliExitCode$1;
+
+export { CLI_EXIT_CODES, type CliExitCode, EXIT_DECLINED, EXIT_OK, EXIT_SERVER_ERROR, EXIT_SIGINT, EXIT_USER_ERROR };

package/dist/watch.d.ts

@@ -0,0 +1,44 @@
+type WatchLoopResult$1<T> = {
+    intervalMs: number;
+    tickCount: number;
+    stoppedBySignal: boolean;
+    reachedTerminal: boolean;
+    signal?: NodeJS.Signals;
+    lastData: T;
+};
+
+type WatchRenderContext$1 = {
+    tickCount: number;
+    initial: boolean;
+};
+
+type WatchLoopOptions$1<T> = {
+    intervalSeconds: number;
+    clearScreen?: boolean;
+    fetch: () => Promise<T>;
+    render: (snapshot: T, context: WatchRenderContext$1) => Promise<void> | void;
+    isTerminal?: (snapshot: T) => boolean;
+};
+
+/**
+ * @param {number} requestedMs
+ * @returns {number}
+ */
+declare function clampWatchIntervalMs(requestedMs: number): number;
+/**
+ * @param {number} intervalSeconds
+ * @returns {number}
+ */
+declare function watchIntervalSecondsToMs(intervalSeconds: number): number;
+/**
+ * @template T
+ * @param {WatchLoopOptions<T>} options
+ * @returns {Promise<WatchLoopResult<T>>}
+ */
+declare function runWatchLoop<T>(options: WatchLoopOptions<T>): Promise<WatchLoopResult<T>>;
+declare const WATCH_MIN_INTERVAL_MS: 500;
+type WatchRenderContext = WatchRenderContext$1;
+type WatchLoopOptions<T> = WatchLoopOptions$1<T>;
+type WatchLoopResult<T> = WatchLoopResult$1<T>;
+
+export { WATCH_MIN_INTERVAL_MS, type WatchLoopOptions, type WatchLoopResult, type WatchRenderContext, clampWatchIntervalMs, runWatchLoop, watchIntervalSecondsToMs };

package/dist/why-diagnosis.d.ts

@@ -0,0 +1,56 @@
+import * as _smithers_orchestrator_db_adapter from '@smithers-orchestrator/db/adapter';
+import { Effect } from 'effect';
+import { SmithersError } from '@smithers-orchestrator/errors';
+
+type WhyBlockerKind$1 = "waiting-approval" | "waiting-event" | "waiting-timer" | "stale-task-heartbeat" | "retry-backoff" | "retries-exhausted" | "stale-heartbeat" | "dependency-failed";
+
+type WhyBlocker$1 = {
+    kind: WhyBlockerKind$1;
+    nodeId: string;
+    iteration: number | null;
+    reason: string;
+    waitingSince: number;
+    unblocker: string;
+    context?: string;
+    signalName?: string | null;
+    dependencyNodeId?: string | null;
+    firesAtMs?: number | null;
+    remainingMs?: number | null;
+    attempt?: number | null;
+    maxAttempts?: number | null;
+};
+
+type WhyDiagnosis$1 = {
+    runId: string;
+    status: string;
+    summary: string;
+    generatedAtMs: number;
+    blockers: WhyBlocker$1[];
+    currentNodeId: string | null;
+};
+
+/**
+ * @param {SmithersDb} adapter
+ * @param {string} runId
+ * @returns {Effect.Effect<WhyDiagnosis, SmithersError>}
+ */
+declare function diagnoseRunEffect(adapter: SmithersDb, runId: string, nowMs?: number): Effect.Effect<WhyDiagnosis, SmithersError>;
+/**
+ * @param {WhyDiagnosis} diagnosis
+ * @returns {string}
+ */
+declare function renderWhyDiagnosisHuman(diagnosis: WhyDiagnosis): string;
+/**
+ * @param {WhyDiagnosis} diagnosis
+ * @returns {Array<{ command: string; description: string }>}
+ */
+declare function diagnosisCtaCommands(diagnosis: WhyDiagnosis): Array<{
+    command: string;
+    description: string;
+}>;
+type WhyBlockerKind = WhyBlockerKind$1;
+type SmithersDb = _smithers_orchestrator_db_adapter.SmithersDb;
+type WhyBlocker = WhyBlocker$1;
+type WhyDiagnosis = WhyDiagnosis$1;
+
+export { type SmithersDb, type WhyBlocker, type WhyBlockerKind, type WhyDiagnosis, diagnoseRunEffect, diagnosisCtaCommands, renderWhyDiagnosisHuman };

package/dist/workflow-pack.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @param {InitOptions} [options]
+ * @returns {InitResult}
+ */
+declare function initWorkflowPack(options?: InitOptions): InitResult;
+/**
+ * @param {string} workflowPath
+ * @returns {WorkflowCta[]}
+ */
+declare function getWorkflowFollowUpCtas(workflowPath: string): WorkflowCta[];
+type InitOptions = {
+    force?: boolean;
+    rootDir?: string;
+    skipInstall?: boolean;
+    agentsOnly?: boolean;
+};
+type InitInstallResult = {
+    status: "ok" | "skipped" | "failed";
+    reason?: string;
+};
+type InitResult = {
+    rootDir: string;
+    writtenFiles: string[];
+    skippedFiles: string[];
+    preservedPaths: string[];
+    install: InitInstallResult;
+};
+type WorkflowCta = {
+    command: string;
+    description: string;
+};
+type TemplateFile = {
+    path: string;
+    contents: string;
+    preserveExisting?: boolean;
+};
+
+export { type InitInstallResult, type InitOptions, type InitResult, type TemplateFile, type WorkflowCta, getWorkflowFollowUpCtas, initWorkflowPack };

package/dist/workflows.d.ts

@@ -0,0 +1,35 @@
+type WorkflowSourceType$1 = "user" | "seeded" | "generated" | (string & {});
+
+type DiscoveredWorkflow$1 = {
+    id: string;
+    displayName: string;
+    sourceType: WorkflowSourceType$1;
+    entryFile: string;
+    path: string;
+};
+
+/**
+ * @param {string} root
+ * @returns {DiscoveredWorkflow[]}
+ */
+declare function discoverWorkflows(root: string): DiscoveredWorkflow[];
+/**
+ * @param {string} name
+ */
+declare function validateWorkflowName(name: string): void;
+/**
+ * @param {string} id
+ * @param {string} root
+ * @returns {DiscoveredWorkflow}
+ */
+declare function resolveWorkflow(id: string, root: string): DiscoveredWorkflow;
+/**
+ * @param {string} name
+ * @param {string} root
+ * @returns {DiscoveredWorkflow}
+ */
+declare function createWorkflowFile(name: string, root: string): DiscoveredWorkflow;
+type WorkflowSourceType = WorkflowSourceType$1;
+type DiscoveredWorkflow = DiscoveredWorkflow$1;
+
+export { type DiscoveredWorkflow, type WorkflowSourceType, createWorkflowFile, discoverWorkflows, resolveWorkflow, validateWorkflowName };