@skastr0/prism-linux-x64 0.2.2 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skastr0/prism-linux-x64",
-  "version": "0.2.2",
+  "version": "0.3.1",
   "type": "module",
   "description": "Prism standalone CLI binary for Linux x64.",
   "license": "MIT",
@@ -19,6 +19,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.29.0",
     "@opencode-ai/plugin": "^1.15.13",
+    "@skastr0/prism-sdk": "0.3.1",
     "effect": "^3.21.1",
     "typescript": "^5.8.3",
     "zod": "4.4.3"

package/types/content-hash.d.ts

@@ -1 +1,15 @@
 export declare const computeContentHash: (content: string | Uint8Array) => string;
+/**
+ * Normalizes the dynamic `mcpServers[*].url` authority (host:port) out of a
+ * generated MCP HTTP config before hashing, so an owner daemon rebinding to a
+ * different ephemeral port is never mistaken for content drift. Detection is
+ * purely structural (`{ mcpServers: { url: "http(s)://..." } }`); content that
+ * does not match this shape is returned unchanged.
+ */
+export declare const normalizeMcpHttpConfigForHash: (content: string) => string;
+/**
+ * Content hash for a generated MCP HTTP config owned file. Equal for two
+ * renders that differ only in the dynamic port/url authority; still differs
+ * for a genuine content change (e.g. an added/removed server entry).
+ */
+export declare const computeMcpHttpConfigContentHash: (content: string) => string;

package/types/index.d.ts

@@ -13,19 +13,11 @@
  * These helpers are identity constructors for authoring ergonomics.
  */
 export * from "./workflow-errors.js";
+export * from "./workflow-harness-detection.js";
 export * from "./workflows.js";
-export * from "./workflow-tsconfig.js";
-export * from "./workflow-antigravity-worker.js";
-export * from "./workflow-amp-worker.js";
-export * from "./workflow-claude-worker.js";
-export * from "./workflow-codex-worker.js";
-export * from "./workflow-loader.js";
-export * from "./workflow-opencode-worker.js";
 export * from "./workflow-runner.js";
-export * from "./workflow-store.js";
 export * from "./workflow-worker-contract.js";
 export * from "./workflow-worker-metadata.js";
-export * from "./workflow-workers.js";
 export interface NamedRefDefinition {
     readonly plugin?: string;
     readonly name: string;

package/types/lowerer-capabilities.d.ts

@@ -2,8 +2,10 @@ import type { HarnessId } from "./types.js";
 export type GeneratedCanonicalToolSupport = "executable" | "unsupported";
 export type SkillPermissionSupport = "supported" | "unsupported";
 export type CompileSurfaceSupport = "supported" | "unsupported";
+export type AgentModelBindingSupport = "consumed" | "ignored";
 export interface CompileTargetCapabilities {
     readonly agents: CompileSurfaceSupport;
+    readonly agentModelBindings: AgentModelBindingSupport;
     readonly generatedCanonicalTools: GeneratedCanonicalToolSupport;
     readonly hooks: CompileSurfaceSupport;
     readonly skillPermissions: SkillPermissionSupport;
@@ -21,6 +23,14 @@ export interface LowererSurfaceCapability {
 export interface LowererCapabilityProfile {
     readonly harness: HarnessId;
     readonly family: HarnessFamily;
+    /**
+     * Whether Prism Workflows can dispatch a task to this harness (a worker
+     * module exists under `src/workflow-*-worker.ts` and the harness is a
+     * member of `WorkflowWorkerId`, workflows.ts). This is the single source
+     * for `WORKFLOW_WORKERS` (workflow-catalog.ts) — do not hand-list harness
+     * ids elsewhere.
+     */
+    readonly workflowWorker: boolean;
     readonly compile: CompileTargetCapabilities;
     readonly surfaces: Record<LowererSurfaceId, LowererSurfaceCapability>;
     readonly notes?: readonly string[];
@@ -29,6 +39,7 @@ export declare const LOWERER_CAPABILITIES: {
     readonly "claude-code": {
         readonly harness: "claude-code";
         readonly family: "coding-harness";
+        readonly workflowWorker: true;
         readonly compile: CompileTargetCapabilities;
         readonly surfaces: {
             readonly pluginBundle: {
@@ -77,6 +88,7 @@ export declare const LOWERER_CAPABILITIES: {
     readonly opencode: {
         readonly harness: "opencode";
         readonly family: "coding-harness";
+        readonly workflowWorker: true;
         readonly compile: CompileTargetCapabilities;
         readonly surfaces: {
             readonly pluginBundle: {
@@ -125,6 +137,7 @@ export declare const LOWERER_CAPABILITIES: {
     readonly openclaw: {
         readonly harness: "openclaw";
         readonly family: "claw-harness";
+        readonly workflowWorker: false;
         readonly compile: CompileTargetCapabilities;
         readonly surfaces: {
             readonly pluginBundle: LowererSurfaceCapability;
@@ -146,6 +159,7 @@ export declare const LOWERER_CAPABILITIES: {
     readonly hermes: {
         readonly harness: "hermes";
         readonly family: "claw-harness";
+        readonly workflowWorker: true;
         readonly compile: CompileTargetCapabilities;
         readonly surfaces: {
             readonly pluginBundle: LowererSurfaceCapability;
@@ -174,6 +188,7 @@ export declare const LOWERER_CAPABILITIES: {
     readonly "codex-cli": {
         readonly harness: "codex-cli";
         readonly family: "coding-harness";
+        readonly workflowWorker: true;
         readonly compile: CompileTargetCapabilities;
         readonly surfaces: {
             readonly pluginBundle: LowererSurfaceCapability;
@@ -222,6 +237,7 @@ export declare const LOWERER_CAPABILITIES: {
     readonly "antigravity-cli": {
         readonly harness: "antigravity-cli";
         readonly family: "coding-harness";
+        readonly workflowWorker: true;
         readonly compile: CompileTargetCapabilities;
         readonly surfaces: {
             readonly pluginBundle: {
@@ -270,6 +286,7 @@ export declare const LOWERER_CAPABILITIES: {
     readonly "kimi-code": {
         readonly harness: "kimi-code";
         readonly family: "coding-harness";
+        readonly workflowWorker: true;
         readonly compile: CompileTargetCapabilities;
         readonly surfaces: {
             readonly pluginBundle: {
@@ -323,6 +340,7 @@ export declare const LOWERER_CAPABILITIES: {
     readonly "amp-code": {
         readonly harness: "amp-code";
         readonly family: "coding-harness";
+        readonly workflowWorker: true;
         readonly compile: CompileTargetCapabilities;
         readonly surfaces: {
             readonly pluginBundle: {
@@ -368,6 +386,7 @@ export declare const LOWERER_CAPABILITIES: {
     readonly cursor: {
         readonly harness: "cursor";
         readonly family: "coding-harness";
+        readonly workflowWorker: false;
         readonly compile: CompileTargetCapabilities;
         readonly surfaces: {
             readonly pluginBundle: {
@@ -409,6 +428,7 @@ export declare const LOWERER_CAPABILITIES: {
     readonly "factory-droid": {
         readonly harness: "factory-droid";
         readonly family: "coding-harness";
+        readonly workflowWorker: false;
         readonly compile: CompileTargetCapabilities;
         readonly surfaces: {
             readonly pluginBundle: {
@@ -461,6 +481,7 @@ export declare const LOWERER_CAPABILITIES: {
     readonly pi: {
         readonly harness: "pi";
         readonly family: "coding-harness";
+        readonly workflowWorker: false;
         readonly compile: CompileTargetCapabilities;
         readonly surfaces: {
             readonly pluginBundle: {
@@ -510,6 +531,7 @@ export declare const LOWERER_CAPABILITIES: {
     readonly grok: {
         readonly harness: "grok";
         readonly family: "coding-harness";
+        readonly workflowWorker: true;
         readonly compile: CompileTargetCapabilities;
         readonly surfaces: {
             readonly pluginBundle: {
@@ -557,3 +579,15 @@ export declare const LOWERER_CAPABILITIES: {
     };
 };
 export declare const getCompileTargetCapabilities: (harness: string) => CompileTargetCapabilities;
+/**
+ * Harness ids flagged `workflowWorker: true` above — computed at the type
+ * level from the literal `as const` table, so it narrows exactly (no wider
+ * than `HarnessId`, no manual re-listing). Consumers (workflow-catalog.ts)
+ * assert this set against their own worker-module registry so a harness
+ * flagged here without a matching worker module is a tsc error.
+ */
+export type WorkflowWorkerHarnessId = {
+    [K in HarnessId]: (typeof LOWERER_CAPABILITIES)[K]["workflowWorker"] extends true ? K : never;
+}[HarnessId];
+/** Harness ids that can be dispatched as Prism Workflows workers, derived from the `workflowWorker` bit. */
+export declare const workflowWorkerHarnessIds: () => readonly WorkflowWorkerHarnessId[];

package/types/workflow-bun-runtime.d.ts

@@ -0,0 +1,21 @@
+export interface WorkflowBunSpawnOptions {
+    readonly cmd: ReadonlyArray<string>;
+    readonly cwd?: string;
+    readonly env?: Record<string, string | undefined>;
+    readonly stdin: "ignore";
+    readonly stdout: "ignore" | "pipe";
+    readonly stderr: "ignore" | "pipe";
+}
+export interface WorkflowBunSpawnedProcess {
+    readonly pid?: number;
+    readonly stdout?: ReadableStream<Uint8Array>;
+    readonly stderr: ReadableStream<Uint8Array>;
+    readonly exited: Promise<number | null>;
+    kill(signal?: NodeJS.Signals | number): void;
+    unref?(): void;
+}
+export interface WorkflowBunRuntime {
+    which(name: string): string | null;
+    spawn(options: WorkflowBunSpawnOptions): WorkflowBunSpawnedProcess;
+}
+export declare const workflowBunRuntime: (capability: string) => WorkflowBunRuntime;

package/types/workflow-errors.d.ts

@@ -17,5 +17,12 @@ export declare class WorkflowTaskEscalatedError extends Error {
     readonly name = "WorkflowTaskEscalatedError";
     constructor(taskId: string, criterion: string, feedback?: string | undefined);
 }
-export type WorkflowRuntimeError = WorkflowTaskDecodeError | WorkflowTaskEscalatedError | WorkflowRunStoppedError | Error;
-export declare const toWorkflowRuntimeError: (error: unknown) => WorkflowRuntimeError;
+export declare class WorkflowBunRuntimeUnavailableError extends Error {
+    readonly name = "WorkflowBunRuntimeUnavailableError";
+    constructor(capability: string, cause?: unknown);
+}
+export declare class WorkflowUnsupportedHarnessError extends Error {
+    readonly name = "WorkflowUnsupportedHarnessError";
+    constructor(harness: string, validHarnesses: ReadonlyArray<string>);
+}
+export type WorkflowRuntimeError = WorkflowBunRuntimeUnavailableError | WorkflowUnsupportedHarnessError | WorkflowTaskDecodeError | WorkflowTaskEscalatedError | WorkflowRunStoppedError | Error;

package/types/workflow-harness-detection.d.ts

@@ -0,0 +1,85 @@
+import { type WorkflowWorkerHarnessId } from "./lowerer-capabilities.js";
+import type { HarnessId } from "./types.js";
+/**
+ * Workflow-worker harness ids, derived from the capability registry's
+ * `workflowWorker` bit (`lowerer-capabilities.ts`) — the single source of
+ * truth for this set (PQ-163). Never hand-list these ids here; add a harness
+ * by flipping its `workflowWorker` capability in the registry, which also
+ * forces `WORKFLOW_HARNESS_DETECTION_SPECS` below to gain the matching entry
+ * at compile time.
+ */
+export declare const WORKFLOW_HARNESS_IDS: ReadonlyArray<WorkflowWorkerHarnessId>;
+export type WorkflowHarnessId = WorkflowWorkerHarnessId;
+export type WorkflowHarnessDetectionStatus = "available" | "missing" | "broken";
+export type WorkflowHarnessDetectionReasonCode = "executable-found" | "executable-missing" | "probe-succeeded" | "probe-exited-nonzero" | "probe-timed-out" | "probe-failed";
+export interface WorkflowHarnessDetectionReason {
+    readonly code: WorkflowHarnessDetectionReasonCode;
+    readonly message: string;
+    readonly command: string;
+    readonly executablePath?: string;
+    readonly exitCode?: number | null;
+    readonly stderr?: string;
+}
+export interface WorkflowHarnessDetection {
+    readonly schema: "prism.workflow-harness-detection.v1";
+    readonly harness: WorkflowHarnessId;
+    readonly available: boolean;
+    readonly status: WorkflowHarnessDetectionStatus;
+    readonly reason: WorkflowHarnessDetectionReason;
+}
+export interface WorkflowHarnessDetectionSpec {
+    readonly harness: WorkflowHarnessId;
+    readonly command: string;
+    readonly envVar: string;
+    readonly probeArgs: ReadonlyArray<string>;
+    /**
+     * Cheap-fast-tier model used by `resolveWorkflowTaskModel` when a task
+     * declares this harness but nothing (task, profile, or CLI --model) supplies
+     * a concrete model. Chosen from the empirical modelspace's throughput/triage
+     * profiles (not the premium tier) so a scaffolded workflow never crashes at
+     * run with "no concrete model for workflow worker X".
+     */
+    readonly defaultModel: string;
+}
+export interface WorkflowHarnessProbeRunResult {
+    readonly exitCode: number | null;
+    readonly stderr?: string;
+    readonly timedOut?: boolean;
+}
+export interface WorkflowHarnessProbeRunOptions {
+    readonly timeoutMs: number;
+}
+export interface WorkflowHarnessDetectionOptions {
+    /**
+     * Environment map used only to read Prism workflow binary override variables.
+     * Defaults to process.env when omitted.
+     */
+    readonly env?: Readonly<Record<string, string | undefined>>;
+    /**
+     * Optional executable resolver. Inject this in apps/tests to keep detection
+     * deterministic and side-effect free.
+     */
+    readonly resolveExecutable?: (command: string) => string | undefined | Promise<string | undefined>;
+    /**
+     * When true, detection runs a short version probe after resolving the binary.
+     * The default false mode only inspects PATH/override variables and is safe to
+     * call during application startup: no files are written, no config is loaded,
+     * and no harness process is spawned.
+     */
+    readonly verify?: boolean;
+    readonly probeTimeoutMs?: number;
+    readonly runProbe?: (command: string, args: ReadonlyArray<string>, options: WorkflowHarnessProbeRunOptions) => Promise<WorkflowHarnessProbeRunResult>;
+}
+export declare const WORKFLOW_HARNESS_DETECTION_SPECS: Readonly<Record<WorkflowHarnessId, WorkflowHarnessDetectionSpec>>;
+export declare const isWorkflowHarnessId: (id: string) => id is WorkflowHarnessId;
+/**
+ * Cheap-fast-tier default model for a workflow harness, or `undefined` for an
+ * id outside the registry. Single source of truth for `resolveWorkflowTaskModel`
+ * (src/workflows.ts) — do not hand-maintain a second per-harness default list.
+ */
+export declare const workflowHarnessDefaultModel: (harness: string) => string | undefined;
+export declare const workflowHarnessIdsForHarnesses: (harnesses: ReadonlyArray<HarnessId>) => WorkflowHarnessId[];
+export declare const detectWorkflowHarness: (harness: WorkflowHarnessId, options?: WorkflowHarnessDetectionOptions) => Promise<WorkflowHarnessDetection>;
+export declare const detectWorkflowHarnesses: (options?: WorkflowHarnessDetectionOptions & {
+    readonly harnesses?: ReadonlyArray<WorkflowHarnessId>;
+}) => Promise<ReadonlyArray<WorkflowHarnessDetection>>;

package/types/workflow-identity.d.ts

@@ -0,0 +1,48 @@
+import { type AnyWorkflowTask, type WorkflowRuntimeOptions } from "./workflows.js";
+export interface WorkflowTaskIdentity {
+    readonly workflow: string;
+    readonly taskId: string;
+    readonly cacheKey: string;
+    readonly promptHash: string;
+    readonly agentManifestHash: string;
+}
+export interface WorkflowJudgeIdentity {
+    readonly workflow: string;
+    readonly taskId: string;
+    readonly taskCacheKey: string;
+    readonly criterion: string;
+    readonly cacheKey: string;
+}
+export interface WorkflowRunTaskSnapshot {
+    readonly runId: string;
+    readonly ordinal: number;
+    readonly taskId: string;
+    readonly phase?: string;
+    readonly prompt: string;
+    readonly cacheKey: string;
+    readonly promptHash: string;
+    readonly agentManifestHash: string;
+    readonly agent: {
+        readonly plugin: string;
+        readonly name: string;
+        readonly description: string;
+        readonly sourceHash: string;
+        readonly manifestHash: string;
+    };
+    readonly worker?: {
+        readonly worker?: string;
+        readonly model?: string;
+        readonly profile?: string;
+    };
+    readonly outputSchema?: unknown;
+    readonly finishCriteria: ReadonlyArray<string>;
+    readonly createdAt: string;
+}
+export declare const workflowTaskIdentity: (workflow: string, task: AnyWorkflowTask, runtimeOptions?: WorkflowRuntimeOptions) => WorkflowTaskIdentity;
+export declare const workflowRunTaskSnapshotForTask: (input: {
+    readonly runId: string;
+    readonly ordinal: number;
+    readonly workflow: string;
+    readonly task: AnyWorkflowTask;
+    readonly runtimeOptions?: WorkflowRuntimeOptions;
+}) => Omit<WorkflowRunTaskSnapshot, "createdAt">;

package/types/workflow-runner.d.ts

@@ -1,10 +1,11 @@
 import { type AnyWorkflowDefinition, type AnyWorkflowTask, type WorkflowRuntimeOptions } from "./workflows.js";
-import { type WorkflowStore } from "./workflow-store.js";
+import type { WorkflowStore } from "./workflow-store.js";
 import { type WorkflowRepairLoopContinuationWorkerId, type WorkflowStableSession } from "./workflow-session.js";
 export interface WorkflowTaskExecution {
     readonly output: unknown;
     readonly metadata?: Record<string, unknown>;
 }
+export type WorkflowRunTaskResultStatus = "completed" | "failed" | "escalated";
 export interface WorkflowRunTaskResult {
     readonly id: string;
     readonly agent: {
@@ -13,7 +14,9 @@ export interface WorkflowRunTaskResult {
     };
     readonly output: unknown;
     readonly cached: boolean;
+    readonly status: WorkflowRunTaskResultStatus;
     readonly metadata?: Record<string, unknown>;
+    readonly error?: string;
 }
 export interface WorkflowRunResult {
     readonly runId: string | null;

package/types/workflow-runtime.d.ts

@@ -0,0 +1,24 @@
+import { type WorkflowBunSpawnedProcess, type WorkflowBunSpawnOptions } from "./workflow-bun-runtime.js";
+export interface WorkflowDatabaseQuery<Row, Params extends ReadonlyArray<unknown>> {
+    get(...params: Params): Row | null;
+    all(...params: Params): Row[];
+    run(...params: Params): unknown;
+}
+export interface WorkflowDatabase {
+    exec(statement: string): unknown;
+    close(): void;
+    query<Row = unknown, Params extends ReadonlyArray<unknown> = ReadonlyArray<unknown>>(statement: string): WorkflowDatabaseQuery<Row, Params>;
+    transaction<T extends (...args: never[]) => unknown>(fn: T): T;
+}
+export interface WorkflowSpawnOptions extends WorkflowBunSpawnOptions {
+    readonly cwd: string;
+}
+export interface WorkflowSpawnedProcess extends WorkflowBunSpawnedProcess {
+    readonly pid: number;
+    readonly stdout: ReadableStream<Uint8Array>;
+    readonly stderr: ReadableStream<Uint8Array>;
+    unref(): void;
+}
+export declare const openWorkflowDatabase: (path: string) => WorkflowDatabase;
+export declare const spawnWorkflowProcess: (options: WorkflowSpawnOptions) => WorkflowSpawnedProcess;
+export declare const findWorkflowExecutable: (name: string) => string | undefined;

package/types/workflow-session.d.ts

@@ -116,7 +116,6 @@ export declare const workflowHarnessContinuationSupport: {
 };
 export declare const stableSessionIdFromUnknown: (value: unknown) => StableSessionId | undefined;
 export declare const workflowContinuationAdapterForWorker: (worker: string) => WorkflowContinuationAdapterId | undefined;
-export declare const workflowWorkerSupportsRepairLoopContinuation: (worker: string) => worker is WorkflowRepairLoopContinuationWorkerId;
 export declare const workflowContinuationSupportForAdapter: (adapter: string | undefined) => WorkflowHarnessContinuationSupport | undefined;
 export declare const workflowAdapterFromMetadata: (metadata: Record<string, unknown> | undefined) => WorkflowContinuationAdapterId | undefined;
 export declare const workflowStableSessionFromMetadata: (metadata: Record<string, unknown> | undefined) => WorkflowStableSession | undefined;

package/types/workflow-store.d.ts

@@ -1,19 +1,7 @@
-import { Database } from "bun:sqlite";
-import { type AnyWorkflowTask, type WorkflowJudgeVerdict, type WorkflowRuntimeOptions } from "./workflows.js";
-export interface WorkflowTaskIdentity {
-    readonly workflow: string;
-    readonly taskId: string;
-    readonly cacheKey: string;
-    readonly promptHash: string;
-    readonly agentManifestHash: string;
-}
-export interface WorkflowJudgeIdentity {
-    readonly workflow: string;
-    readonly taskId: string;
-    readonly taskCacheKey: string;
-    readonly criterion: string;
-    readonly cacheKey: string;
-}
+import type { WorkflowJudgeVerdict } from "./workflows.js";
+import type { WorkflowJudgeIdentity, WorkflowRunTaskSnapshot, WorkflowTaskIdentity } from "./workflow-identity.js";
+export { workflowRunTaskSnapshotForTask, workflowTaskIdentity, type WorkflowJudgeIdentity, type WorkflowRunTaskSnapshot, type WorkflowTaskIdentity } from "./workflow-identity.js";
+import { type WorkflowDatabase } from "./workflow-runtime.js";
 export type WorkflowTaskOutputSource = "mock-output";
 export interface CompletedWorkflowTaskRecord {
     readonly identity: WorkflowTaskIdentity;
@@ -105,31 +93,6 @@ export interface WorkflowRunSnapshot {
     readonly createdAt: string;
     readonly updatedAt: string;
 }
-export interface WorkflowRunTaskSnapshot {
-    readonly runId: string;
-    readonly ordinal: number;
-    readonly taskId: string;
-    readonly phase?: string;
-    readonly prompt: string;
-    readonly cacheKey: string;
-    readonly promptHash: string;
-    readonly agentManifestHash: string;
-    readonly agent: {
-        readonly plugin: string;
-        readonly name: string;
-        readonly description: string;
-        readonly sourceHash: string;
-        readonly manifestHash: string;
-    };
-    readonly worker?: {
-        readonly worker?: string;
-        readonly model?: string;
-        readonly profile?: string;
-    };
-    readonly outputSchema?: unknown;
-    readonly finishCriteria: ReadonlyArray<string>;
-    readonly createdAt: string;
-}
 export type WorkflowCacheBadge = "hit" | "miss" | "skipped" | "cached" | "fresh" | "write" | "mock" | `repair ${number}`;
 export interface WorkflowMonitorTask extends WorkflowRunTaskCompactSummary {
     readonly phase?: string;
@@ -179,6 +142,15 @@ export interface WorkflowRunRecord {
     readonly heartbeatAt?: string;
 }
 export type WorkflowRunStatus = "running" | "completed" | "failed" | "escalated" | "unknown";
+/**
+ * A run's persisted status can read "completed" while carrying isolated task failures: the
+ * dynamic runtime's fault-isolation contract (PQ-166) lets an author's `run` program finish
+ * successfully after recovering from a task that itself failed or escalated (e.g. via
+ * `Effect.either`). That is not a caller-visible success — a caller gating on `$?` (the CLI)
+ * must still see the partial failure. Success requires both: the run itself reached
+ * "completed", and every recorded task did too.
+ */
+export declare function isWorkflowRunOutcomeSuccessful(runStatus: WorkflowRunStatus, taskStatuses: ReadonlyArray<WorkflowRunTaskProgressStatus>): boolean;
 export interface WorkflowEventRecord {
     readonly sequence: number;
     readonly runId: string;
@@ -187,18 +159,11 @@ export interface WorkflowEventRecord {
     readonly payload: unknown;
     readonly createdAt: string;
 }
-export declare const defaultWorkflowStorePath: (projectPath: string) => string;
-export declare const workflowTaskIdentity: (workflow: string, task: AnyWorkflowTask, runtimeOptions?: WorkflowRuntimeOptions) => WorkflowTaskIdentity;
-export declare const workflowRunTaskSnapshotForTask: (input: {
-    readonly runId: string;
-    readonly ordinal: number;
-    readonly workflow: string;
-    readonly task: AnyWorkflowTask;
-    readonly runtimeOptions?: WorkflowRuntimeOptions;
-}) => Omit<WorkflowRunTaskSnapshot, "createdAt">;
+export declare const projectWorkflowStoreDir: (prismHome: string, cwd?: string) => string;
+export declare const defaultWorkflowStorePath: (prismHome: string, cwd?: string) => string;
 export declare class WorkflowStore {
     private readonly db;
-    constructor(db: Database);
+    constructor(db: WorkflowDatabase);
     static open(path: string): Promise<WorkflowStore>;
     close(): void;
     getCompleted(identity: WorkflowTaskIdentity, options?: {

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

@@ -4,7 +4,8 @@ export declare const WORKFLOW_WORKER_JSON_INSTRUCTION_SOURCE = "workflow-worker-
 export declare class WorkflowOutputParseError extends Error {
     readonly name = "WorkflowOutputParseError";
     readonly rawText?: string;
-    constructor(message: string, rawText?: string);
+    readonly metadata?: Record<string, unknown>;
+    constructor(message: string, rawText?: string, metadata?: Record<string, unknown>);
 }
 export declare const workflowWorkerJsonInstruction: (task: AnyWorkflowTask) => string;
 export declare const parseWorkflowWorkerJsonOutput: (text: string) => unknown;

package/types/workflows.d.ts

@@ -42,6 +42,20 @@ export interface WorkflowAgentRef {
     readonly model?: WorkflowModelRef;
     readonly installs: ReadonlyArray<string>;
 }
+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 type WorkflowOutputSchema = Schema.Schema.AnyNoContext;
 export type WorkflowFinishCriterionError = Error;
 export type WorkflowWorkerId = "amp-code" | "antigravity-cli" | "claude-code" | "codex-cli" | "grok" | "hermes" | "kimi-code" | "opencode";
@@ -68,6 +82,15 @@ export type WorkflowResolvedModelTarget = Readonly<Record<string, WorkflowResolv
 export declare class WorkflowModelResolutionError extends Error {
     readonly name = "WorkflowModelResolutionError";
 }
+export type WorkflowTaskModelResolutionSource = "task" | "profile" | "default" | "cli-fallback";
+export interface WorkflowTaskModelResolution {
+    readonly model: string;
+    readonly source: WorkflowTaskModelResolutionSource;
+}
+export declare const resolveWorkflowTaskModelResolution: (task: AnyWorkflowTask, options?: {
+    readonly worker?: string;
+    readonly fallbackModel?: string;
+}) => WorkflowTaskModelResolution | undefined;
 export declare const resolveWorkflowTaskModel: (task: AnyWorkflowTask, options?: {
     readonly worker?: string;
     readonly fallbackModel?: string;
@@ -145,6 +168,8 @@ export interface WorkflowTask<Id extends string = string, Agent extends Workflow
 }
 export type AnyWorkflowTask = WorkflowTask<string, WorkflowAgentRef, WorkflowOutputSchema>;
 export type WorkflowTaskOutput<Task extends AnyWorkflowTask> = Schema.Schema.Type<Task["output"]>;
+export declare const isWorkflowAgentRef: (value: unknown) => value is WorkflowAgentRef;
+export declare const isWorkflowTask: (value: unknown) => value is AnyWorkflowTask;
 export interface WorkflowDefinition<Name extends string, Tasks extends ReadonlyArray<AnyWorkflowTask>> {
     readonly kind: "workflow";
     readonly name: Name;
@@ -165,6 +190,8 @@ export interface DynamicWorkflowDefinition<Name extends string, Result = unknown
     readonly run: (runtime: WorkflowRuntime) => Effect.Effect<Result, Err, never>;
 }
 export type AnyWorkflowDefinition = WorkflowDefinition<string, ReadonlyArray<AnyWorkflowTask>> | DynamicWorkflowDefinition<string>;
+export declare const isWorkflowDefinition: (value: unknown) => value is AnyWorkflowDefinition;
+export declare const workflowSummary: (path: string, workflow: AnyWorkflowDefinition) => WorkflowValidationSummary;
 export declare const defineTask: <const Id extends string, const Agent extends WorkflowAgentRef, const Output extends WorkflowOutputSchema>(definition: WorkflowTaskDefinition<Id, Agent, Output>) => WorkflowTask<Id, Agent, Output>;
 export declare function defineWorkflow<const Name extends string, const Tasks extends ReadonlyArray<AnyWorkflowTask>>(definition: {
     readonly name: Name;

package/types/compile/authoring-runtime.d.ts

@@ -1,27 +0,0 @@
-import { Effect } from "effect";
-/**
- * Minimal in-memory authoring runtime that stubs the `prism` module for
- * plugin source files. It provides the typed-ref helpers and definition
- * builders used by `.agent.ts`, `.orbit.ts`, `.trait.ts`, `.tool.ts`,
- * `.toolspace.ts`, `.modelspace.ts`, `.skillspace.ts`, and `.hook.ts` files.
- *
- * The real semantic validation happens later in the compiler; this runtime
- * only needs to return plain data structures so that source modules can be
- * imported/bundled without resolving the full `prism` package.
- */
-export declare const AUTHORING_RUNTIME_JS = "\nconst withNamedRef = (kind, first, second) =>\n  second === undefined ? { kind, name: first } : { kind, plugin: first, name: second };\n\nexport const traitRef = (first, second) => withNamedRef(\"trait-ref\", first, second);\nexport const agentRef = (first, second) => withNamedRef(\"agent-ref\", first, second);\nexport const orbitRef = (first, second) => withNamedRef(\"orbit-ref\", first, second);\n\nexport const toolRef = (first, second, third) =>\n  third === undefined\n    ? { kind: \"tool-ref\", toolspace: first, name: second }\n    : { kind: \"tool-ref\", plugin: first, toolspace: second, name: third };\n\nexport const toolGroupRef = (first, second, third) =>\n  third === undefined\n    ? { kind: \"tool-group-ref\", toolspace: first, name: second }\n    : { kind: \"tool-group-ref\", plugin: first, toolspace: second, name: third };\n\nexport const modelProfileRef = (first, second, third) =>\n  third === undefined\n    ? { kind: \"model-profile-ref\", modelspace: first, name: second }\n    : { kind: \"model-profile-ref\", plugin: first, modelspace: second, name: third };\n\nexport const skillRef = (first, second) => withNamedRef(\"skill-ref\", first, second);\n\nexport const skillspaceRef = (first, second, third) =>\n  third === undefined\n    ? { kind: \"skillspace-ref\", skillspace: first, name: second }\n    : { kind: \"skillspace-ref\", plugin: first, skillspace: second, name: third };\n\nexport const schemaSlot = (options = {}) => ({ kind: \"schema\", ...options });\nexport const bindTrait = (trait, options = {}) => ({\n  kind: \"trait-binding\",\n  trait,\n  ...(options.tools ? { tools: options.tools } : {}),\n});\n\nexport const defineAgent = (agent) => agent;\nexport const defineTrait = (trait) => trait;\nexport const defineOrbit = (orbit) => orbit;\nexport const defineTool = (tool) => tool;\nexport const defineToolspace = (toolspace) => toolspace;\nexport const defineModelspace = (modelspace) => modelspace;\nexport const defineSkillspace = (skillspace) => skillspace;\nexport const defineHook = (hook) => hook;\n\nexport const hookEvent = {\n  toolBefore: \"tool.before\",\n  toolAfter: \"tool.after\",\n  promptSubmit: \"prompt.submit\",\n  permissionRequest: \"permission.request\",\n  sessionStart: \"session.start\",\n  sessionEnd: \"session.end\",\n};\n\nexport const hookTool = {\n  any: () => ({ kind: \"hook-any-tool\" }),\n  tool: (tool) => ({ kind: \"hook-toolspace-tool\", tool }),\n  group: (group) => ({ kind: \"hook-toolspace-group\", group }),\n  canonical: (ref) => ({ kind: \"hook-canonical-tool\", ref }),\n};\n\nexport const hookMatcher = {\n  tool: hookTool,\n};\n";
-declare class AuthoringRuntimeWriteError {
-    readonly cause: unknown;
-    readonly _tag = "AuthoringRuntimeWriteError";
-    constructor(cause: unknown);
-}
-/**
- * Return a file path to a persisted copy of the authoring runtime. The file
- * is written once per process and reused across plugin compiles.
- */
-export declare const getAuthoringRuntimePath: () => Effect.Effect<string, AuthoringRuntimeWriteError, never>;
-/**
- * For tests that need to clean up the machine-global temp runtime file.
- */
-export declare const getAuthoringRuntimeDir: () => string | undefined;
-export {};

package/types/compile/bundle-utils.d.ts

@@ -1,16 +0,0 @@
-export declare const NODE_BUILTIN_EXTERNALS: string[];
-export declare const BARE_IMPORT_PATTERN: RegExp;
-export declare const RELATIVE_IMPORT_PATTERN: RegExp;
-export declare const collectRelativeImportSpecifiers: (source: string) => string[];
-export declare const packageNameFromSpecifier: (specifier: string) => string;
-export declare const relativeModulePath: (fromFile: string, toFileWithoutExtension: string) => string;
-export declare const resolveImportedSourcePath: (sourcePath: string, source: string) => string;
-export declare const stripToolAuthoringHelpers: (source: string) => string;
-export declare const rewriteGeneratedPluginBundleImports: (source: string, currentGeneratedPath: string) => string;
-export declare const resolveTsImportCandidate: (absoluteWithoutQuery: string, fileExists: (path: string) => Promise<boolean>) => Promise<string | undefined>;
-export declare const rewriteBareImportsForBundle: (source: string, replacements: ReadonlyMap<string, string>) => string;
-export declare const rewriteBareEffectImportsForBundle: (source: string) => string;
-export declare const rewriteBarePluginDependencyImportsForBundle: (options: {
-    readonly source: string;
-    readonly pluginRoot?: string;
-}) => Promise<string>;