@skastr0/prism-darwin-x64 0.1.1 → 0.1.2

package/types/prism-home.d.ts

@@ -0,0 +1,26 @@
+import { Schema } from "effect";
+export declare const PRISM_CONFIG_SCHEMA_VERSION = 1;
+export declare const DEFAULT_BACKUP_RETENTION_PER_TARGET = 3;
+export declare const BackupModeSchema: Schema.Literal<["always", "never"]>;
+export type BackupMode = typeof BackupModeSchema.Type;
+export interface PrismBackupConfig {
+    readonly mode: BackupMode;
+    readonly retentionPerTarget: number;
+}
+export interface PrismConfig {
+    readonly version: typeof PRISM_CONFIG_SCHEMA_VERSION;
+    readonly backup: PrismBackupConfig;
+}
+/**
+ * Resolve the Prism home directory from an override or the environment.
+ *
+ * WS2+: new code must NOT call this from library modules — consume the
+ * `PrismHome` Context.Tag from src/services/prism-env.ts instead; the env
+ * read happens exactly once at the CLI edge layer.
+ */
+export declare const resolvePrismHome: (override?: string) => string;
+export declare const prismConfigPath: (prismHome?: string) => string;
+export declare const prismStateDir: (prismHome?: string) => string;
+export declare const prismBackupDir: (prismHome?: string) => string;
+export declare const defaultPrismConfig: () => PrismConfig;
+export declare const readPrismConfig: (prismHome?: string) => Promise<PrismConfig>;

package/types/project-key.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Project identity (toolchain & distribution §4).
+ *
+ * A project key is derived at the CLI edge:
+ *   - the git repository root (worktree/origin root) when cwd is inside a git
+ *     repo,
+ *   - else realpath(cwd).
+ *
+ * The human-readable path is hashed (sha256) only to produce a filesystem-safe
+ * directory name; the original path is recorded alongside for inspection.
+ *
+ * Prism-owned generated types live machine-global, project-keyed, never in the
+ * project tree:
+ *   ~/.prism/state/projects/<key>/compile-manifest.json
+ *   ~/.prism/state/projects/<key>/generated/...
+ */
+/**
+ * The resolved project path (git root or realpath(cwd)) plus its
+ * filesystem-safe hash. Carry both: the hash names the directory, the path is
+ * for human inspection.
+ */
+export interface ProjectKey {
+    /** The resolved project root path (git toplevel, else realpath(cwd)). */
+    readonly path: string;
+    /** sha256(path) hex — the filesystem-safe directory name. */
+    readonly key: string;
+}
+/**
+ * Resolve the git repository root (worktree root) for a directory, or
+ * undefined when the directory is not inside a git repo (or git is missing).
+ * Synchronous: the workflow loader's `prism/refs` resolver and tsconfig path
+ * derivation run on a sync path.
+ */
+export declare const gitRepositoryRoot: (cwd: string) => string | undefined;
+/**
+ * Derive the project key for a directory: git root if inside a git repo, else
+ * realpath(cwd). The path is realpath-normalized either way so that distinct
+ * spellings of the same location collapse to one key.
+ */
+export declare const deriveProjectKey: (cwd?: string) => ProjectKey;
+/** ~/.prism/state/projects/<key> for a project key. */
+export declare const projectStateDir: (prismHome: string, key: string) => string;
+/** ~/.prism/state/projects/<key>/compile-manifest.json — per-project manifest. */
+export declare const projectCompileManifestPath: (prismHome: string, key: string) => string;
+/** ~/.prism/state/projects/<key>/generated — Prism-owned generated refs dir. */
+export declare const projectGeneratedRefsDir: (prismHome: string, key: string) => string;
+/** ~/.prism/state/projects/<key>/generated/agents.ts — the agents refs file. */
+export declare const projectGeneratedAgentsPath: (prismHome: string, key: string) => string;

package/types/source-selection.d.ts

@@ -0,0 +1,38 @@
+import { type HarnessId, type HarnessScope, type PluginArtifactType, type PluginManifestTargets, type PluginRuntimeConfig, type PluginTargetId, type TargetPresetId } from "./types.js";
+export declare const SOURCE_NOUNS: readonly ["rules", "commands", "agents", "skills", "orbits", "tools", "toolspaces", "modelspaces", "skillspaces", "hooks"];
+export type SourceNoun = (typeof SOURCE_NOUNS)[number];
+export interface SourceRuntimeRequirements {
+    readonly mcpConfigured: boolean;
+    readonly streamableHttpMcp: boolean;
+}
+export interface SourceSelectionEntry {
+    readonly noun: SourceNoun;
+    readonly declaredTargets: readonly PluginTargetId[];
+    readonly harnesses: readonly HarnessId[];
+}
+export interface SourceSelection {
+    readonly entries: readonly SourceSelectionEntry[];
+    readonly runtime: PluginRuntimeConfig;
+}
+export interface TargetSourceSelection {
+    readonly target: HarnessId;
+    readonly scope?: HarnessScope;
+    readonly nouns: Readonly<Record<SourceNoun, boolean>>;
+    readonly runtime: SourceRuntimeRequirements;
+    readonly hasLowerableSources: boolean;
+}
+export declare const getCompileManagedPluginArtifactTargets: (artifact: PluginArtifactType) => readonly HarnessId[];
+export declare function isTargetPresetId(value: string): value is TargetPresetId;
+export declare function isPluginTargetId(value: unknown): value is PluginTargetId;
+export declare const targetSupportsSourceNoun: (harnessId: HarnessId, noun: SourceNoun) => boolean;
+export declare function resolveManifestTargets(targets: readonly PluginTargetId[]): HarnessId[];
+export declare function resolveManifestTargetsForSourceNoun(targets: readonly PluginTargetId[], noun: SourceNoun): HarnessId[];
+export declare function unsupportedDirectTargetsForSourceNoun(targets: readonly PluginTargetId[], noun: SourceNoun): HarnessId[];
+export declare function presetsWithNoSupportedTargetsForSourceNoun(targets: readonly PluginTargetId[], noun: SourceNoun): TargetPresetId[];
+export declare function validateSourceTargetSupport(noun: SourceNoun, declaredTargets: readonly unknown[]): string[];
+export declare const sourceSelectionFromManifestTargets: (targets: PluginManifestTargets, options?: {
+    readonly runtime?: PluginRuntimeConfig;
+}) => SourceSelection;
+export declare const selectSourcesForTarget: (selection: SourceSelection, target: HarnessId, options?: {
+    readonly scope?: HarnessScope;
+}) => TargetSourceSelection;

package/types/state/lock.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Advisory run lock — one concurrent plan→apply→commit per PRISM_HOME.
+ *
+ * O_EXCL create of `<PRISM_HOME>/state/lock` holding {pid}; a lock whose pid
+ * is dead is stale and taken over. Ledger files were bare read-modify-write
+ * JSON with no concurrency story; the snapshot store inherits a real one.
+ */
+export declare const lockPath: (prismHome: string) => string;
+export declare class SnapshotLockHeldError extends Error {
+    readonly path: string;
+    readonly pid: number | undefined;
+    constructor(path: string, pid: number | undefined);
+}
+export declare const withSnapshotLock: <T>(prismHome: string, run: () => Promise<T>) => Promise<T>;

package/types/types.d.ts

@@ -0,0 +1,193 @@
+/**
+ * Core types for prism - the unified plugin distribution system
+ */
+export type HarnessId = "claude-code" | "opencode" | "openclaw" | "hermes" | "codex-cli" | "antigravity-cli" | "kimi-code" | "amp-code" | "cursor" | "factory-droid" | "pi" | "grok";
+export declare const HARNESS_SCOPES: readonly ["global", "project"];
+export type HarnessScope = (typeof HARNESS_SCOPES)[number];
+export interface HarnessConfig {
+    id: HarnessId;
+    name: string;
+    globalConfigPath: string;
+    projectConfigPath: string | null;
+    rulesFile: string | null;
+    rulesDir: string | null;
+    commandsDir: string | null;
+    agentsDir: string | null;
+    toolsDir: string | null;
+    skillsDir: string | null;
+    configFile: string | null;
+    configFormat: "json" | "yaml" | "toml" | "markdown" | "mdc";
+    supportsTools: boolean;
+    supportsCommands: boolean;
+    supportsAgents: boolean;
+    supportsSkills: boolean;
+    supportsMCP: boolean;
+    alternativeRulesFiles?: string[];
+}
+export declare const PLUGIN_ARTIFACT_TYPES: readonly ["rules", "commands", "agents", "skills"];
+export type PluginArtifactType = (typeof PLUGIN_ARTIFACT_TYPES)[number];
+export declare const COMPILE_ARTIFACT_TYPES: readonly ["orbits", "tools", "toolspaces", "modelspaces", "skillspaces", "hooks"];
+export type CompileArtifactType = (typeof COMPILE_ARTIFACT_TYPES)[number];
+export declare const TARGET_PRESET_IDS: readonly ["coding-harness", "claw-harness"];
+export type TargetPresetId = (typeof TARGET_PRESET_IDS)[number];
+export type PluginTargetId = HarnessId | TargetPresetId;
+export type AnyArtifactType = PluginArtifactType | CompileArtifactType;
+export type PluginManifestTargets = Partial<Record<AnyArtifactType, PluginTargetId[]>>;
+export type PrismMcpTransport = "streamable-http";
+export interface PluginRuntimeMcpHarnessConfig {
+    transport?: PrismMcpTransport;
+    host?: string;
+    port?: number;
+    tokenEnv?: string;
+    connectTimeoutMs?: number;
+    toolTimeoutMs?: number;
+}
+export interface PluginRuntimeConfig {
+    mcp?: Partial<Record<HarnessId, PluginRuntimeMcpHarnessConfig>>;
+}
+export interface PluginManifest {
+    name: string;
+    version: string;
+    description?: string;
+    targets: PluginManifestTargets;
+    deps?: Record<string, string>;
+    runtime?: PluginRuntimeConfig;
+    projects?: Record<string, ProjectConfig>;
+}
+export interface ProjectConfig {
+    pattern?: string;
+    rulesDir?: string;
+}
+export interface InstallOptions {
+    pluginPath: string;
+    harnesses: HarnessId[];
+    projectPath?: string;
+    overwrite: boolean;
+    dryRun: boolean;
+}
+export type FileOperationType = "copy" | "append" | "merge" | "prune" | "drift" | "skip";
+export interface ManagedFileOperationMetadata {
+    entryId: string;
+    pluginName: string;
+    pluginVersion?: string;
+    pluginPath: string;
+    scope: HarnessScope;
+    root: string;
+    kind: "file" | "directory" | "section" | "config";
+    sourcePath?: string;
+    contentHash: string;
+}
+export interface FileOperation {
+    type: FileOperationType;
+    source: string;
+    target: string;
+    harness: HarnessId;
+    artifact: "rules" | "command" | "agent" | "tool" | "skill" | "config" | "compile";
+    content?: string;
+    reason?: string;
+    managed?: ManagedFileOperationMetadata;
+}
+export interface InstallResult {
+    success: boolean;
+    operations: FileOperation[];
+    errors: InstallError[];
+    backups: string[];
+}
+export interface InstallError {
+    operation: FileOperation;
+    message: string;
+}
+export type OpenCodePermission = "allow" | "ask" | "deny";
+export interface OpenCodeAgentFrontmatter {
+    description?: string;
+    mode?: "subagent" | "primary" | "all";
+    model?: string;
+    temperature?: number;
+    top_p?: number;
+    tools?: Record<string, boolean>;
+    color?: string;
+    maxSteps?: number;
+    disable?: boolean;
+    permission?: {
+        edit?: OpenCodePermission;
+        bash?: OpenCodePermission | Record<string, OpenCodePermission>;
+        webfetch?: OpenCodePermission;
+        doom_loop?: OpenCodePermission;
+        external_directory?: OpenCodePermission;
+        skill?: OpenCodePermission | Record<string, OpenCodePermission>;
+    };
+}
+export interface ClaudeCodeFrontmatter {
+    description?: string;
+    "allowed-tools"?: string[];
+    model?: "sonnet" | "opus" | "haiku" | string;
+    temperature?: number;
+    top_p?: number;
+}
+export interface CursorFrontmatter {
+    description?: string;
+    globs?: string[];
+    alwaysApply?: boolean;
+}
+export interface FactoryDroidFrontmatter {
+    description?: string;
+    model?: string | "inherit";
+    reasoningEffort?: "low" | "medium" | "high";
+    tools?: string | string[];
+    "user-invocable"?: boolean;
+    "disable-model-invocation"?: boolean;
+    "argument-hint"?: string;
+}
+export interface CodexCliFrontmatter {
+    description?: string;
+    model?: string;
+    model_reasoning_effort?: "low" | "medium" | "high" | "xhigh";
+    sandbox_mode?: "read-only" | "full" | "danger-full-access";
+}
+export interface UnifiedFrontmatter {
+    description?: string;
+    "claude-code"?: ClaudeCodeFrontmatter;
+    opencode?: OpenCodeAgentFrontmatter;
+    openclaw?: Record<string, unknown>;
+    hermes?: Record<string, unknown>;
+    "codex-cli"?: CodexCliFrontmatter;
+    "antigravity-cli"?: Record<string, unknown>;
+    "kimi-code"?: Record<string, unknown>;
+    "amp-code"?: Record<string, unknown>;
+    cursor?: CursorFrontmatter;
+    "factory-droid"?: FactoryDroidFrontmatter;
+    pi?: Record<string, unknown>;
+    grok?: Record<string, unknown>;
+}
+export interface SkillFrontmatter {
+    name: string;
+    description: string;
+    compatibility?: string;
+    license?: string;
+    "allowed-tools"?: string[];
+    metadata?: Record<string, string>;
+}
+export declare const SKILL_VALIDATION: {
+    readonly NAME_MAX_LENGTH: 64;
+    readonly NAME_PATTERN: RegExp;
+    readonly DESCRIPTION_MAX_LENGTH: 1024;
+    readonly COMPATIBILITY_MAX_LENGTH: 500;
+    readonly RECOMMENDED_BODY_MAX_LINES: 500;
+    readonly ALLOWED_FRONTMATTER_KEYS: Set<string>;
+};
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+export interface SkillValidationResult extends ValidationResult {
+    skillName?: string;
+    skillPath: string;
+}
+export interface AgentValidationResult extends ValidationResult {
+    agentName?: string;
+    agentPath: string;
+}
+export declare const AGENT_VALIDATION: {
+    readonly DESCRIPTION_MAX_LENGTH: 1024;
+};

package/types/workflow-amp-worker.d.ts

@@ -0,0 +1,12 @@
+import type { AnyWorkflowTask } from "./workflows.js";
+import type { WorkflowTaskExecution } from "./workflow-runner.js";
+export interface AmpWorkflowWorkerOptions {
+    readonly cwd: string;
+    readonly bin?: string;
+    readonly model?: string;
+    readonly abortSignal?: AbortSignal;
+}
+export declare class AmpWorkflowWorkerError extends Error {
+    readonly name = "AmpWorkflowWorkerError";
+}
+export declare const runAmpWorkflowTask: (task: AnyWorkflowTask, options: AmpWorkflowWorkerOptions) => Promise<WorkflowTaskExecution>;

package/types/workflow-antigravity-worker.d.ts

@@ -0,0 +1,14 @@
+import type { AnyWorkflowTask } from "./workflows.js";
+import type { WorkflowTaskExecution } from "./workflow-runner.js";
+export interface AntigravityWorkflowWorkerOptions {
+    readonly cwd: string;
+    readonly bin?: string;
+    readonly model?: string;
+    readonly printTimeout?: string;
+    readonly processTimeoutMs?: number;
+    readonly abortSignal?: AbortSignal;
+}
+export declare class AntigravityWorkflowWorkerError extends Error {
+    readonly name = "AntigravityWorkflowWorkerError";
+}
+export declare const runAntigravityWorkflowTask: (task: AnyWorkflowTask, options: AntigravityWorkflowWorkerOptions) => Promise<WorkflowTaskExecution>;

package/types/workflow-claude-worker.d.ts

@@ -0,0 +1,13 @@
+import type { AnyWorkflowTask } from "./workflows.js";
+import type { WorkflowTaskExecution, WorkflowTaskRepairContext } from "./workflow-runner.js";
+export interface ClaudeWorkflowWorkerOptions {
+    readonly cwd: string;
+    readonly bin?: string;
+    readonly model?: string;
+    readonly abortSignal?: AbortSignal;
+    readonly repair?: WorkflowTaskRepairContext;
+}
+export declare class ClaudeWorkflowWorkerError extends Error {
+    readonly name = "ClaudeWorkflowWorkerError";
+}
+export declare const runClaudeWorkflowTask: (task: AnyWorkflowTask, options: ClaudeWorkflowWorkerOptions) => Promise<WorkflowTaskExecution>;

package/types/workflow-codex-worker.d.ts

@@ -0,0 +1,12 @@
+import type { AnyWorkflowTask } from "./workflows.js";
+import type { WorkflowTaskExecution } from "./workflow-runner.js";
+export interface CodexWorkflowWorkerOptions {
+    readonly cwd: string;
+    readonly bin?: string;
+    readonly model?: string;
+    readonly abortSignal?: AbortSignal;
+}
+export declare class CodexWorkflowWorkerError extends Error {
+    readonly name = "CodexWorkflowWorkerError";
+}
+export declare const runCodexWorkflowTask: (task: AnyWorkflowTask, options: CodexWorkflowWorkerOptions) => Promise<WorkflowTaskExecution>;

package/types/workflow-grok-worker.d.ts

@@ -0,0 +1,14 @@
+import type { AnyWorkflowTask } from "./workflows.js";
+import type { WorkflowTaskExecution } from "./workflow-runner.js";
+export interface GrokWorkflowWorkerOptions {
+    readonly cwd: string;
+    readonly bin?: string;
+    readonly model?: string;
+    readonly effort?: string;
+    readonly abortSignal?: AbortSignal;
+}
+export declare class WorkflowWorkerError extends Error {
+    readonly name = "WorkflowWorkerError";
+}
+export declare const runGrokWorkflowTask: (task: AnyWorkflowTask, options: GrokWorkflowWorkerOptions) => Promise<WorkflowTaskExecution>;
+export { parseWorkflowWorkerJsonOutput, WorkflowOutputParseError } from "./workflow-worker-contract.js";

package/types/workflow-hermes-worker.d.ts

@@ -0,0 +1,14 @@
+import type { AnyWorkflowTask } from "./workflows.js";
+import type { WorkflowTaskExecution } from "./workflow-runner.js";
+export interface HermesWorkflowWorkerOptions {
+    readonly cwd: string;
+    readonly bin?: string;
+    readonly model?: string;
+    readonly profile?: string;
+    readonly processTimeoutMs?: number;
+    readonly abortSignal?: AbortSignal;
+}
+export declare class HermesWorkflowWorkerError extends Error {
+    readonly name = "HermesWorkflowWorkerError";
+}
+export declare const runHermesWorkflowTask: (task: AnyWorkflowTask, options: HermesWorkflowWorkerOptions) => Promise<WorkflowTaskExecution>;

package/types/workflow-kimi-worker.d.ts

@@ -0,0 +1,13 @@
+import type { AnyWorkflowTask } from "./workflows.js";
+import type { WorkflowTaskExecution } from "./workflow-runner.js";
+export interface KimiWorkflowWorkerOptions {
+    readonly cwd: string;
+    readonly bin?: string;
+    readonly model?: string;
+    readonly processTimeoutMs?: number;
+    readonly abortSignal?: AbortSignal;
+}
+export declare class KimiWorkflowWorkerError extends Error {
+    readonly name = "KimiWorkflowWorkerError";
+}
+export declare const runKimiWorkflowTask: (task: AnyWorkflowTask, options: KimiWorkflowWorkerOptions) => Promise<WorkflowTaskExecution>;

package/types/workflow-loader.d.ts

@@ -0,0 +1,64 @@
+import type { AnyWorkflowDefinition } from "./workflows.js";
+export interface WorkflowTaskSummary {
+    readonly id: string;
+    readonly agent: {
+        readonly plugin: string;
+        readonly name: string;
+    };
+    readonly cacheKey?: string;
+}
+export interface WorkflowValidationSummary {
+    readonly path: string;
+    readonly name: string;
+    readonly tasks: ReadonlyArray<WorkflowTaskSummary>;
+    readonly dynamic: boolean;
+}
+export interface WorkflowTypecheckDiagnostic {
+    readonly file: string;
+    readonly line: number | null;
+    readonly character: number | null;
+    readonly message: string;
+}
+export declare class WorkflowLoadError extends Error {
+    readonly name = "WorkflowLoadError";
+}
+export declare class WorkflowTypecheckError extends Error {
+    readonly filePath: string;
+    readonly diagnostics: ReadonlyArray<WorkflowTypecheckDiagnostic>;
+    readonly name = "WorkflowTypecheckError";
+    constructor(filePath: string, diagnostics: ReadonlyArray<WorkflowTypecheckDiagnostic>);
+}
+export declare const isWorkflowDefinition: (value: unknown) => value is AnyWorkflowDefinition;
+export declare const workflowSummary: (path: string, workflow: AnyWorkflowDefinition) => WorkflowValidationSummary;
+/**
+ * Check whether the generated refs are fresh relative to the current compile
+ * manifest. Emits a warning to stderr when drift is detected. The check is
+ * best-effort: missing refs or missing manifest produce no warning (the refs
+ * file may simply not exist yet).
+ */
+export declare const checkWorkflowRefsFreshness: (options: {
+    readonly prismHome?: string;
+}) => Promise<void>;
+/**
+ * Run an in-process TypeScript typecheck on a workflow file using the
+ * binary-embedded TypeScript and the resolved type environment.
+ *
+ * Behaviour:
+ *  - No resolvable type environment at all (never compiled, no shipped types):
+ *    warn to stderr and proceed — the runtime loader works regardless.
+ *  - Module-not-found / no-types-configured diagnostics: warn and proceed.
+ *  - A genuine type error inside the workflow (e.g. an unknown agent ref like
+ *    `agents.forge.doesNotExist`): throw WorkflowTypecheckError. This is the
+ *    moat.
+ */
+export declare const typecheckWorkflowFile: (filePath: string, options?: {
+    readonly prismHome?: string;
+}) => void;
+export declare const loadWorkflowFile: (filePath: string, options?: {
+    readonly prismHome?: string;
+    readonly skipTypecheck?: boolean;
+}) => Promise<AnyWorkflowDefinition>;
+export declare const validateWorkflowFile: (filePath: string, options?: {
+    readonly prismHome?: string;
+    readonly skipTypecheck?: boolean;
+}) => Promise<WorkflowValidationSummary>;

package/types/workflow-opencode-worker.d.ts

@@ -0,0 +1,12 @@
+import type { AnyWorkflowTask } from "./workflows.js";
+import type { WorkflowTaskExecution } from "./workflow-runner.js";
+export interface OpenCodeWorkflowWorkerOptions {
+    readonly cwd: string;
+    readonly bin?: string;
+    readonly model?: string;
+    readonly abortSignal?: AbortSignal;
+}
+export declare class OpenCodeWorkflowWorkerError extends Error {
+    readonly name = "OpenCodeWorkflowWorkerError";
+}
+export declare const runOpenCodeWorkflowTask: (task: AnyWorkflowTask, options: OpenCodeWorkflowWorkerOptions) => Promise<WorkflowTaskExecution>;

package/types/workflow-runner.d.ts

@@ -0,0 +1,69 @@
+import { type AnyWorkflowDefinition, type AnyWorkflowTask, type WorkflowRuntimeOptions } from "./workflows.js";
+import { type WorkflowStore } from "./workflow-store.js";
+export interface WorkflowTaskExecution {
+    readonly output: unknown;
+    readonly metadata?: Record<string, unknown>;
+}
+export interface WorkflowRunTaskResult {
+    readonly id: string;
+    readonly agent: {
+        readonly plugin: string;
+        readonly name: string;
+    };
+    readonly output: unknown;
+    readonly cached: boolean;
+    readonly metadata?: Record<string, unknown>;
+}
+export interface WorkflowRunResult {
+    readonly runId: string | null;
+    readonly workflow: string;
+    readonly tasks: ReadonlyArray<WorkflowRunTaskResult>;
+    readonly output?: unknown;
+}
+export declare class WorkflowTaskDecodeError extends Error {
+    readonly taskId: string;
+    readonly cause: unknown;
+    readonly name = "WorkflowTaskDecodeError";
+    constructor(taskId: string, cause: unknown);
+}
+export declare class WorkflowRunStoppedError extends Error {
+    readonly runId: string;
+    readonly name = "WorkflowRunStoppedError";
+    constructor(runId: string);
+}
+export declare class WorkflowTaskEscalatedError extends Error {
+    readonly taskId: string;
+    readonly criterion: string;
+    readonly feedback?: string | undefined;
+    readonly name = "WorkflowTaskEscalatedError";
+    constructor(taskId: string, criterion: string, feedback?: string | undefined);
+}
+export type WorkflowTaskRepairMode = "native-continuation" | "fresh-executor-invocation" | "none";
+export interface WorkflowTaskRepairContext {
+    readonly attempt: number;
+    readonly criterion: string;
+    readonly repairPrompt: string;
+    readonly mode: Exclude<WorkflowTaskRepairMode, "none">;
+    readonly previousMetadata?: Record<string, unknown>;
+    readonly fallbackReason?: "adapter-does-not-support-continuation" | "executor-does-not-advertise-continuation" | "missing-session-id";
+    readonly continuation?: {
+        readonly adapter: string;
+        readonly sessionId: string;
+    };
+}
+export interface WorkflowTaskExecutionContext {
+    readonly abortSignal?: AbortSignal;
+    readonly repair?: WorkflowTaskRepairContext;
+}
+export type WorkflowTaskExecutor = (task: AnyWorkflowTask, context?: WorkflowTaskExecutionContext) => Promise<unknown | WorkflowTaskExecution>;
+export declare const DEFAULT_WORKFLOW_TASK_CONCURRENCY = 8;
+export declare const runWorkflow: (workflow: AnyWorkflowDefinition, options: {
+    readonly executeTask: WorkflowTaskExecutor;
+    readonly store?: WorkflowStore;
+    readonly cache?: boolean;
+    readonly mockOutput?: boolean;
+    readonly maxConcurrentTasks?: number;
+    readonly runId?: string;
+    readonly runtimeOptions?: WorkflowRuntimeOptions;
+    readonly abortSignal?: AbortSignal;
+}) => Promise<WorkflowRunResult>;