@skastr0/prism-darwin-x64 0.3.4 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skastr0/prism-darwin-x64",
-  "version": "0.3.4",
+  "version": "0.4.1",
   "type": "module",
   "description": "Prism standalone CLI binary for macOS x64.",
   "license": "MIT",
@@ -20,7 +20,7 @@
     "@modelcontextprotocol/sdk": "1.29.0",
     "@opencode-ai/plugin": "^1.15.13",
     "@opentui/core-darwin-x64": "0.4.1",
-    "@skastr0/prism-sdk": "0.3.4",
+    "@skastr0/prism-sdk": "0.4.1",
     "effect": "^3.21.1",
     "typescript": "^5.8.3",
     "zod": "4.4.3"

package/types/index.d.ts

@@ -182,6 +182,15 @@ export interface OrbitPhaseDefinition {
      * into generated orbit skills, but does not attach runtime semantics to it.
      */
     readonly workflow?: OrbitPhaseWorkflowDefinition;
+    /**
+     * Typed workflow I/O contract for this phase. Serialized to JSON Schema in
+     * the compile manifest for workflow runtimes; unsupported schema constructs
+     * fail the compile.
+     */
+    readonly contract?: {
+        readonly input?: import("effect/Schema").Schema.AnyNoContext;
+        readonly output?: import("effect/Schema").Schema.AnyNoContext;
+    };
     /**
      * Long-form markdown for this phase. When present, lowerers write it to
      * `references/<phase-name>.md` next to the orbit SKILL.md. Treat this as
@@ -313,6 +322,13 @@ export declare const hookEvent: {
     readonly permissionRequest: "permission.request";
     readonly sessionStart: "session.start";
     readonly sessionEnd: "session.end";
+    readonly toolFailure: "tool.failure";
+    readonly stop: "stop";
+    readonly subagentStart: "subagent.start";
+    readonly subagentStop: "subagent.stop";
+    readonly compactBefore: "compact.before";
+    readonly compactAfter: "compact.after";
+    readonly notification: "notification";
 };
 export type HookEvent = (typeof hookEvent)[keyof typeof hookEvent];
 export interface HookTargetContextDefinition {
@@ -378,7 +394,70 @@ export interface SessionEndHookEventDefinition {
     readonly reason?: string;
     readonly native?: Record<string, unknown>;
 }
-export type HookEventPayloadDefinition = ToolBeforeHookEventDefinition | ToolAfterHookEventDefinition | PromptSubmitHookEventDefinition | PermissionRequestHookEventDefinition | SessionStartHookEventDefinition | SessionEndHookEventDefinition;
+export interface ToolFailureHookEventDefinition {
+    readonly event: typeof hookEvent.toolFailure;
+    readonly target: HookTargetContextDefinition;
+    readonly tool: HookToolContextDefinition & {
+        readonly error: unknown;
+    };
+    readonly cwd?: string;
+    readonly session?: HookSessionContextDefinition;
+    readonly native?: Record<string, unknown>;
+}
+export interface StopHookEventDefinition {
+    readonly event: typeof hookEvent.stop;
+    readonly target: HookTargetContextDefinition;
+    readonly cwd?: string;
+    readonly session?: HookSessionContextDefinition;
+    readonly stopHookActive?: boolean;
+    readonly native?: Record<string, unknown>;
+}
+export interface SubagentContextDefinition {
+    readonly id?: string;
+    readonly type?: string;
+}
+export interface SubagentStartHookEventDefinition {
+    readonly event: typeof hookEvent.subagentStart;
+    readonly target: HookTargetContextDefinition;
+    readonly cwd?: string;
+    readonly session?: HookSessionContextDefinition;
+    readonly subagent?: SubagentContextDefinition;
+    readonly native?: Record<string, unknown>;
+}
+export interface SubagentStopHookEventDefinition {
+    readonly event: typeof hookEvent.subagentStop;
+    readonly target: HookTargetContextDefinition;
+    readonly cwd?: string;
+    readonly session?: HookSessionContextDefinition;
+    readonly subagent?: SubagentContextDefinition;
+    readonly native?: Record<string, unknown>;
+}
+export interface CompactBeforeHookEventDefinition {
+    readonly event: typeof hookEvent.compactBefore;
+    readonly target: HookTargetContextDefinition;
+    readonly cwd?: string;
+    readonly session?: HookSessionContextDefinition;
+    readonly trigger?: string;
+    readonly native?: Record<string, unknown>;
+}
+export interface CompactAfterHookEventDefinition {
+    readonly event: typeof hookEvent.compactAfter;
+    readonly target: HookTargetContextDefinition;
+    readonly cwd?: string;
+    readonly session?: HookSessionContextDefinition;
+    readonly trigger?: string;
+    readonly native?: Record<string, unknown>;
+}
+export interface NotificationHookEventDefinition {
+    readonly event: typeof hookEvent.notification;
+    readonly target: HookTargetContextDefinition;
+    readonly cwd?: string;
+    readonly session?: HookSessionContextDefinition;
+    readonly message?: string;
+    readonly kind?: string;
+    readonly native?: Record<string, unknown>;
+}
+export type HookEventPayloadDefinition = ToolBeforeHookEventDefinition | ToolAfterHookEventDefinition | PromptSubmitHookEventDefinition | PermissionRequestHookEventDefinition | SessionStartHookEventDefinition | SessionEndHookEventDefinition | ToolFailureHookEventDefinition | StopHookEventDefinition | SubagentStartHookEventDefinition | SubagentStopHookEventDefinition | CompactBeforeHookEventDefinition | CompactAfterHookEventDefinition | NotificationHookEventDefinition;
 export type HookEventPayloadFor<E extends HookEvent> = Extract<HookEventPayloadDefinition, {
     readonly event: E;
 }>;
@@ -386,18 +465,30 @@ export interface ContinueHookResultDefinition {
     readonly decision: "continue";
     readonly systemMessage?: string;
     readonly additionalContext?: string;
+    /** tool.before: replace the tool arguments before execution. */
+    readonly updatedInput?: unknown;
+    /** tool.after: replace the tool result before the model sees it. */
+    readonly updatedOutput?: unknown;
 }
 export interface BlockHookResultDefinition {
     readonly decision: "block";
     readonly message: string;
+    readonly systemMessage?: string;
 }
 export interface AllowHookResultDefinition {
     readonly decision: "allow";
     readonly systemMessage?: string;
+    readonly updatedInput?: unknown;
+}
+export interface AskHookResultDefinition {
+    readonly decision: "ask";
+    readonly systemMessage?: string;
 }
 export type ToolBeforeHookResultDefinition = ContinueHookResultDefinition | BlockHookResultDefinition;
-export type PermissionRequestHookResultDefinition = ContinueHookResultDefinition | AllowHookResultDefinition | BlockHookResultDefinition;
-export type HookResultFor<E extends HookEvent> = E extends typeof hookEvent.toolBefore ? ToolBeforeHookResultDefinition : E extends typeof hookEvent.permissionRequest ? PermissionRequestHookResultDefinition : ContinueHookResultDefinition;
+export type PermissionRequestHookResultDefinition = ContinueHookResultDefinition | AllowHookResultDefinition | AskHookResultDefinition | BlockHookResultDefinition;
+/** prompt.submit, stop, subagent.stop, compact.before — continue or block. */
+export type BlockableHookResultDefinition = ContinueHookResultDefinition | BlockHookResultDefinition;
+export type HookResultFor<E extends HookEvent> = E extends typeof hookEvent.toolBefore ? ToolBeforeHookResultDefinition : E extends typeof hookEvent.permissionRequest ? PermissionRequestHookResultDefinition : E extends typeof hookEvent.promptSubmit | typeof hookEvent.stop | typeof hookEvent.subagentStop | typeof hookEvent.compactBefore ? BlockableHookResultDefinition : ContinueHookResultDefinition;
 export type HookHandlerDefinition<E extends HookEvent> = (event: HookEventPayloadFor<E>) => import("effect").Effect.Effect<HookResultFor<E>, unknown, never>;
 export interface HookAnyToolMatcherDefinition {
     readonly kind: "hook-any-tool";
@@ -418,13 +509,17 @@ export type HookToolMatcherDefinition = HookAnyToolMatcherDefinition | HookTools
 export interface ToolHookMatchDefinition {
     readonly tool?: HookToolMatcherDefinition;
 }
-export type HookMatchDefinition<E extends HookEvent> = E extends typeof hookEvent.toolBefore | typeof hookEvent.toolAfter | typeof hookEvent.permissionRequest ? ToolHookMatchDefinition : never;
+export type HookMatchDefinition<E extends HookEvent> = E extends typeof hookEvent.toolBefore | typeof hookEvent.toolAfter | typeof hookEvent.toolFailure | typeof hookEvent.permissionRequest ? ToolHookMatchDefinition : never;
 export interface HookDefinition<E extends HookEvent = HookEvent> {
     readonly name: string;
     readonly description?: string;
     readonly event: E;
     readonly targets?: readonly string[];
     readonly match?: HookMatchDefinition<E>;
+    /** How to lower this hook on a target that cannot deliver every control it
+     * declares: "degrade" (default) omits with a fidelity note, "skip" omits
+     * silently, "fail" makes it a compile error. */
+    readonly onDegraded?: "fail" | "degrade" | "skip";
     readonly handle: HookHandlerDefinition<E>;
 }
 export type HookSource<E extends HookEvent = HookEvent> = HookDefinition<E>;
@@ -467,20 +562,4 @@ export declare const hookMatcher: {
         readonly canonical: (ref: string) => HookCanonicalToolMatcherDefinition;
     };
 };
-/** Transitional identity wrapper. The canonical public source type is `AgentSource`. */
-export declare const defineAgent: <T extends AgentSource>(agent: T) => T;
-/** Transitional identity wrapper. The canonical public source type is `TraitSource`. */
-export declare const defineTrait: <T extends TraitSource>(trait: T) => T;
-/** Transitional identity wrapper. The canonical public source type is `OrbitSource`. */
-export declare const defineOrbit: <T extends OrbitSource>(orbit: T) => T;
-/** Transitional identity wrapper. The canonical public source type is `ToolSource`. */
-export declare const defineTool: <T extends ToolSource>(tool: T) => T;
-/** Transitional identity wrapper. The canonical public source type is `ToolspaceSource`. */
-export declare const defineToolspace: <T extends ToolspaceSource>(toolspace: T) => T;
-/** Transitional identity wrapper. The canonical public source type is `ModelspaceSource`. */
-export declare const defineModelspace: <T extends ModelspaceSource>(modelspace: T) => T;
-/** Transitional identity wrapper. The canonical public source type is `SkillspaceSource`. */
-export declare const defineSkillspace: <T extends SkillspaceSource>(skillspace: T) => T;
-/** Transitional identity wrapper. The canonical public source type is `HookSource`. */
-export declare const defineHook: <E extends HookEvent, T extends HookSource<E>>(hook: T) => T;
 export type { ToolRuntimeContext, ToolRuntimeCost } from "./compile/runtime/schema-bridge";

package/types/lowerer-capabilities.d.ts

@@ -176,7 +176,11 @@ export declare const LOWERER_CAPABILITIES: {
                 readonly path: "<prism-home>/runtime/mcp/<plugin>/server.mjs";
                 readonly summary: "Canonical tools lower to the canonical PRISM_HOME union MCP server referenced from config.yaml.";
             };
-            readonly hooks: LowererSurfaceCapability;
+            readonly hooks: {
+                readonly kind: "config-patch";
+                readonly path: "<hermes-root>/config.yaml#hooks";
+                readonly summary: "Compile patches managed Hermes hook entries and wrapper files.";
+            };
             readonly mcpConfig: {
                 readonly kind: "config-patch";
                 readonly path: "<hermes-root>/config.yaml#mcp_servers";
@@ -528,6 +532,56 @@ export declare const LOWERER_CAPABILITIES: {
         };
         readonly notes: readonly ["Pi packages are referenced from settings.json#packages; project scope uses .pi/settings.json.", "Compiled Pi agents use pi-agents markdown discovery: ~/.pi/agents globally and nearest .pi/agents in project scope."];
     };
+    readonly omp: {
+        readonly harness: "omp";
+        readonly family: "coding-harness";
+        readonly workflowWorker: true;
+        readonly compile: CompileTargetCapabilities;
+        readonly surfaces: {
+            readonly pluginBundle: {
+                readonly kind: "native-plugin-bundle";
+                readonly path: "<omp-root>/extensions/prism-generated-<plugin>/";
+                readonly summary: "Compile emits OMP native extensions under the extensions surface.";
+            };
+            readonly rules: {
+                readonly kind: "direct-file";
+                readonly path: "<omp-root>/rules/";
+                readonly summary: "Compile writes OMP native rule files.";
+            };
+            readonly commands: {
+                readonly kind: "direct-file";
+                readonly path: "<omp-root>/commands/";
+                readonly summary: "Compile writes OMP native command files.";
+            };
+            readonly agents: {
+                readonly kind: "direct-file";
+                readonly path: "<omp-root>/agents/";
+                readonly summary: "Compile writes OMP native agent files.";
+            };
+            readonly skills: {
+                readonly kind: "direct-file";
+                readonly path: "<omp-root>/skills/";
+                readonly summary: "Compile writes OMP native skill folders.";
+            };
+            readonly generatedTools: {
+                readonly kind: "native-plugin-api";
+                readonly path: "<omp-root>/extensions/prism-generated-<plugin>/";
+                readonly summary: "Canonical tools lower through OMP's native extension API.";
+            };
+            readonly hooks: {
+                readonly kind: "native-plugin-api";
+                readonly path: "<omp-root>/extensions/prism-generated-<plugin>/";
+                readonly summary: "Hooks lower through OMP's native extension API.";
+            };
+            readonly mcpConfig: LowererSurfaceCapability;
+            readonly agentConfig: {
+                readonly kind: "direct-file";
+                readonly path: "<omp-root>/agents/";
+                readonly summary: "OMP agent model bindings and settings live in generated agent files.";
+            };
+        };
+        readonly notes: readonly ["OMP is a distinct harness from Pi and uses ~/.omp/agent globally or .omp project-local.", "OMP does not expose a verified per-agent skill permission surface; permission-only skill access fails closed."];
+    };
     readonly grok: {
         readonly harness: "grok";
         readonly family: "coding-harness";
@@ -577,6 +631,46 @@ export declare const LOWERER_CAPABILITIES: {
             };
         };
     };
+    readonly devin: {
+        readonly harness: "devin";
+        readonly family: "coding-harness";
+        readonly workflowWorker: true;
+        readonly compile: {
+            readonly agents: "unsupported";
+            readonly agentModelBindings: "ignored";
+            readonly generatedCanonicalTools: "unsupported";
+            readonly hooks: "supported";
+            readonly skillPermissions: "unsupported";
+        };
+        readonly surfaces: {
+            readonly pluginBundle: LowererSurfaceCapability;
+            readonly rules: {
+                readonly kind: "direct-file";
+                readonly path: "<devin-root>/AGENTS.md";
+                readonly summary: "Install appends managed sections to the native AGENTS.md instructions file.";
+            };
+            readonly commands: LowererSurfaceCapability;
+            readonly agents: LowererSurfaceCapability;
+            readonly skills: {
+                readonly kind: "direct-file";
+                readonly path: "<devin-root>/skills/";
+                readonly summary: "Install and compile write Agent Skill folders (global and project .devin/skills).";
+            };
+            readonly generatedTools: LowererSurfaceCapability;
+            readonly hooks: {
+                readonly kind: "direct-file";
+                readonly path: "project: hooks.v1.json; global: config.json#hooks json-array-member + hooks/*.mjs";
+                readonly summary: "Project scope writes hooks.v1.json; global scope upserts Prism entries into config.json hooks without whole-file adopt. Wrappers under hooks/.";
+            };
+            readonly mcpConfig: LowererSurfaceCapability;
+            readonly agentConfig: {
+                readonly kind: "direct-file";
+                readonly path: "ephemeral --agent-config for workflow runs";
+                readonly summary: "Workflow worker writes temporary agent-config (system_instructions, allowed_tools); not a durable install surface.";
+            };
+        };
+        readonly notes: readonly ["Never whole-file adopt ~/.config/devin/config.json — herdr hooks and user prefs live there.", "Workflow default model is swe-1-7; headless via `devin -p` + ATIF --export session resume via -r."];
+    };
 };
 export declare const getCompileTargetCapabilities: (harness: string) => CompileTargetCapabilities;
 /**

package/types/types.d.ts

@@ -1,7 +1,7 @@
 /**
  * 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 type HarnessId = "claude-code" | "opencode" | "openclaw" | "hermes" | "codex-cli" | "antigravity-cli" | "kimi-code" | "amp-code" | "cursor" | "factory-droid" | "pi" | "omp" | "grok" | "devin";
 export declare const HARNESS_SCOPES: readonly ["global", "project"];
 export type HarnessScope = (typeof HARNESS_SCOPES)[number];
 export interface HarnessConfig {
@@ -15,6 +15,7 @@ export interface HarnessConfig {
     agentsDir: string | null;
     toolsDir: string | null;
     skillsDir: string | null;
+    extensionsDir?: string | null;
     configFile: string | null;
     configFormat: "json" | "yaml" | "toml" | "markdown" | "mdc";
     supportsTools: boolean;
@@ -157,7 +158,9 @@ export interface UnifiedFrontmatter {
     cursor?: CursorFrontmatter;
     "factory-droid"?: FactoryDroidFrontmatter;
     pi?: Record<string, unknown>;
+    omp?: Record<string, unknown>;
     grok?: Record<string, unknown>;
+    devin?: Record<string, unknown>;
 }
 export interface SkillFrontmatter {
     name: string;

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

@@ -1,10 +1,22 @@
-export interface WorkflowBunSpawnOptions {
+interface WorkflowBunSpawnBaseOptions {
     readonly cmd: ReadonlyArray<string>;
     readonly cwd?: string;
     readonly env?: Record<string, string | undefined>;
+    readonly detached?: boolean;
+    /** A `number` redirects to that open file descriptor (e.g. a log file opened before spawn). */
+    readonly stdout: "ignore" | "pipe" | number;
+    readonly stderr: "ignore" | "pipe" | number;
+}
+export interface WorkflowBunSpawnOptions extends WorkflowBunSpawnBaseOptions {
     readonly stdin: "ignore";
-    readonly stdout: "ignore" | "pipe";
-    readonly stderr: "ignore" | "pipe";
+}
+export interface WorkflowBunPipedSpawnOptions extends WorkflowBunSpawnBaseOptions {
+    readonly stdin: "pipe";
+    readonly stdout: "pipe";
+    readonly stderr: "pipe";
+}
+export interface WorkflowBunWritableStdin {
+    end(error?: Error): number | Promise<number>;
 }
 export interface WorkflowBunSpawnedProcess {
     readonly pid?: number;
@@ -14,8 +26,14 @@ export interface WorkflowBunSpawnedProcess {
     kill(signal?: NodeJS.Signals | number): void;
     unref?(): void;
 }
+export interface WorkflowBunPipedSpawnedProcess extends WorkflowBunSpawnedProcess {
+    readonly stdin: WorkflowBunWritableStdin;
+    readonly stdout: ReadableStream<Uint8Array>;
+}
 export interface WorkflowBunRuntime {
     which(name: string): string | null;
     spawn(options: WorkflowBunSpawnOptions): WorkflowBunSpawnedProcess;
+    spawn(options: WorkflowBunPipedSpawnOptions): WorkflowBunPipedSpawnedProcess;
 }
 export declare const workflowBunRuntime: (capability: string) => WorkflowBunRuntime;
+export {};

package/types/workflow-data-governance.d.ts

@@ -0,0 +1,43 @@
+import type { WorkflowRunnerLogRemoval } from "./workflow-runner-log.js";
+export declare const DEFAULT_WORKFLOW_RETENTION_DAYS = 30;
+export declare const DEFAULT_WORKFLOW_RETENTION_MS: number;
+export declare const DEFAULT_WORKFLOW_RETENTION_AGE = "30d";
+export declare const parseWorkflowRetentionAge: (input: string) => number;
+export interface WorkflowRunArtifactCounts {
+    readonly runs: number;
+    readonly tasks: number;
+    readonly attempts: number;
+    readonly events: number;
+    readonly spans: number;
+    readonly runSnapshots: number;
+    readonly taskSnapshots: number;
+}
+export interface WorkflowCacheArtifactCounts {
+    readonly taskCache: number;
+    readonly judgeCache: number;
+}
+export interface WorkflowRunDeletionReport {
+    readonly runId: string;
+    readonly status: "deleted" | "missing";
+    readonly rows: WorkflowRunArtifactCounts;
+    readonly runnerLog: WorkflowRunnerLogRemoval;
+}
+export interface WorkflowRetentionCleanupReport {
+    readonly policy: "workflow-ledger-retention-v1";
+    readonly olderThanMs: number;
+    readonly cutoff: string;
+    readonly runs: {
+        readonly matched: number;
+        readonly deleted: number;
+        readonly rows: WorkflowRunArtifactCounts;
+    };
+    readonly caches: WorkflowCacheArtifactCounts;
+    readonly runnerLogs: {
+        readonly deleted: number;
+        readonly missing: number;
+        readonly skippedUnsafeRunId: number;
+    };
+}
+export declare const emptyWorkflowRunArtifactCounts: () => WorkflowRunArtifactCounts;
+export declare const addWorkflowRunArtifactCounts: (left: WorkflowRunArtifactCounts, right: WorkflowRunArtifactCounts) => WorkflowRunArtifactCounts;
+export declare const workflowRetentionCutoff: (olderThanMs: number, now?: Date) => Date;

package/types/workflow-data-policy.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Central workflow-ledger data policy.
+ *
+ * All durable workflow evidence and telemetry exports pass through this module.
+ * Exact-continuation identifiers and execution provenance are deliberately
+ * preserved: they are operational routing data, not authentication secrets.
+ * Cache payloads are never mutated. Callers must skip a cache write when
+ * `workflowCachePersistenceDecision` rejects it.
+ */
+export declare const WORKFLOW_DATA_POLICY_VERSION = 1;
+export declare const WORKFLOW_REDACTION_MARKER = "[REDACTED]";
+export declare const WORKFLOW_SECRET_DIGEST_PREFIX = "sha256:";
+export type WorkflowSensitiveDataReason = "sensitive-key" | "bearer-credential" | "provider-token" | "credential-assignment" | "private-key" | "url-password";
+export interface WorkflowSensitiveDataFinding {
+    readonly path: string;
+    readonly reason: WorkflowSensitiveDataReason;
+}
+export interface WorkflowDataPolicyResult<Value> {
+    readonly value: Value;
+    readonly findings: ReadonlyArray<WorkflowSensitiveDataFinding>;
+}
+export type WorkflowCachePersistenceDecision = {
+    readonly safe: true;
+} | {
+    readonly safe: false;
+    readonly reason: "sensitive-data";
+    readonly findings: ReadonlyArray<WorkflowSensitiveDataFinding>;
+};
+export declare const applyWorkflowDataPolicy: <Value>(input: Value) => WorkflowDataPolicyResult<Value>;
+export declare const inspectWorkflowSensitiveData: (input: unknown) => ReadonlyArray<WorkflowSensitiveDataFinding>;
+export declare const redactWorkflowData: <Value>(input: Value) => Value;
+export declare const redactWorkflowText: (input: string) => string;
+export declare const digestWorkflowSecret: (input: string) => string;
+export declare const workflowCachePersistenceDecision: (input: {
+    readonly output: unknown;
+    readonly metadata?: Record<string, unknown>;
+    readonly identity?: unknown;
+    readonly agent?: unknown;
+}) => WorkflowCachePersistenceDecision;

package/types/workflow-errors.d.ts

@@ -1,3 +1,38 @@
+export declare class WorkflowRunTimeoutError extends Error {
+    readonly limitMs: number;
+    readonly name = "WorkflowRunTimeoutError";
+    constructor(limitMs: number);
+}
+export declare class WorkflowTaskNoProgressError extends Error {
+    readonly taskId: string;
+    readonly limitMs: number;
+    readonly name = "WorkflowTaskNoProgressError";
+    constructor(taskId: string, limitMs: number);
+}
+export declare class WorkflowFanoutExceededError extends Error {
+    readonly limit: number;
+    readonly observed: number;
+    readonly name = "WorkflowFanoutExceededError";
+    constructor(limit: number, observed: number);
+}
+export declare class WorkflowCostExceededError extends Error {
+    readonly limitUsd: number;
+    readonly observedUsd: number;
+    readonly name = "WorkflowCostExceededError";
+    constructor(limitUsd: number, observedUsd: number);
+}
+export declare class WorkflowCostUnavailableError extends Error {
+    readonly limitUsd: number;
+    readonly name = "WorkflowCostUnavailableError";
+    constructor(limitUsd: number);
+}
+export declare class WorkflowPromptLimitError extends Error {
+    readonly taskId: string;
+    readonly limitBytes: number;
+    readonly observedBytes: number;
+    readonly name = "WorkflowPromptLimitError";
+    constructor(taskId: string, limitBytes: number, observedBytes: number);
+}
 /** Errors surfaced by {@link WorkflowRuntime.runTask} and dynamic workflow runs. */
 export declare class WorkflowTaskDecodeError extends Error {
     readonly taskId: string;
@@ -25,4 +60,4 @@ export declare class WorkflowUnsupportedHarnessError extends Error {
     readonly name = "WorkflowUnsupportedHarnessError";
     constructor(harness: string, validHarnesses: ReadonlyArray<string>);
 }
-export type WorkflowRuntimeError = WorkflowBunRuntimeUnavailableError | WorkflowUnsupportedHarnessError | WorkflowTaskDecodeError | WorkflowTaskEscalatedError | WorkflowRunStoppedError | Error;
+export type WorkflowRuntimeError = WorkflowBunRuntimeUnavailableError | WorkflowUnsupportedHarnessError | WorkflowTaskDecodeError | WorkflowTaskEscalatedError | WorkflowRunStoppedError | WorkflowRunTimeoutError | WorkflowTaskNoProgressError | WorkflowFanoutExceededError | WorkflowCostExceededError | WorkflowCostUnavailableError | WorkflowPromptLimitError | Error;

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

@@ -10,6 +10,8 @@ import type { HarnessId } from "./types.js";
  */
 export declare const WORKFLOW_HARNESS_IDS: ReadonlyArray<WorkflowWorkerHarnessId>;
 export type WorkflowHarnessId = WorkflowWorkerHarnessId;
+/** Shared env/CLI integer parser kept off the worker-process module so the public SDK graph stays free of spawn runtime. */
+export declare const parsePositiveInteger: (value: string | undefined) => number | undefined;
 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 {

package/types/workflow-identity.d.ts

@@ -1,4 +1,16 @@
 import { type AnyWorkflowTask, type WorkflowRuntimeOptions } from "./workflows.js";
+/**
+ * `cacheKey` and `promptHash` AND together in the cache primary key
+ * (workflow-store.ts) — `cacheKey` never substitutes for `promptHash`, and
+ * there is no override/terminal-marker mechanism to make a stale prompt hash
+ * replay anyway. `promptHash` hashes the literal rendered `task.prompt`
+ * string, so interpolating volatile upstream text (judge prose, logs, whole
+ * objects) into a downstream prompt guarantees resume misses by construction.
+ * Authoring discipline: interpolate only narrow, stable upstream fields —
+ * ids, hashes, short enums (e.g. `build.commitSha`) — never freeform upstream
+ * text. There is no `--no-cache` bypass (removed; cache is mandatory) — the
+ * sanctioned no-reuse path is a fresh `--store`.
+ */
 export interface WorkflowTaskIdentity {
     readonly workflow: string;
     readonly taskId: string;

package/types/workflow-runner-log.d.ts

@@ -0,0 +1,34 @@
+export declare const WORKFLOW_RUNNER_LOG_FILE_MODE = 384;
+export declare const WORKFLOW_RUNNER_LOG_DIRECTORY_MODE = 448;
+export type WorkflowRunnerLogRemoval = {
+    readonly status: "deleted";
+    readonly path: string;
+} | {
+    readonly status: "missing";
+    readonly path: string;
+} | {
+    readonly status: "skipped-unsafe-run-id";
+};
+export type WorkflowRunnerLogRedaction = {
+    readonly status: "redacted" | "unchanged";
+    readonly path: string;
+} | {
+    readonly status: "missing";
+    readonly path: string;
+} | {
+    readonly status: "skipped-unsafe-run-id" | "skipped-non-file";
+};
+export declare const workflowRunnerLogDir: (storePath: string) => string;
+export declare const workflowRunnerLogPath: (storePath: string, runId: string) => string;
+export declare const workflowRunnerLogPathIfPresent: (storePath: string, run: {
+    readonly runId: string;
+    readonly runnerPid?: number;
+}) => string | undefined;
+export declare const secureWorkflowRunnerLog: (path: string) => Promise<void>;
+export declare const readRedactedWorkflowRunnerLog: (storePath: string, runId: string) => Promise<{
+    readonly path: string;
+    readonly bytes: number;
+    readonly content: string;
+} | null>;
+export declare const redactWorkflowRunnerLogInPlace: (storePath: string, runId: string) => Promise<WorkflowRunnerLogRedaction>;
+export declare const removeWorkflowRunnerLog: (storePath: string, runId: string) => Promise<WorkflowRunnerLogRemoval>;

package/types/workflow-runner.d.ts

@@ -24,8 +24,10 @@ export interface WorkflowRunResult {
     readonly tasks: ReadonlyArray<WorkflowRunTaskResult>;
     readonly output?: unknown;
 }
-export { WorkflowRunStoppedError, WorkflowTaskDecodeError, WorkflowTaskEscalatedError, type WorkflowRuntimeError, } from "./workflow-errors.js";
+export { WorkflowRunStoppedError, WorkflowTaskDecodeError, WorkflowTaskEscalatedError, WorkflowRunTimeoutError, WorkflowTaskNoProgressError, WorkflowFanoutExceededError, WorkflowCostExceededError, WorkflowCostUnavailableError, WorkflowPromptLimitError, type WorkflowRuntimeError, } from "./workflow-errors.js";
 export type WorkflowTaskRepairMode = "native-continuation" | "fresh-executor-invocation" | "none";
+export type WorkflowTaskProgressSource = "executor" | "worker-stdout" | "worker-stderr";
+export type WorkflowTaskProgressReporter = (source?: WorkflowTaskProgressSource) => void;
 export type WorkflowTaskRepairFallbackReason = "adapter-does-not-support-continuation" | "executor-does-not-advertise-continuation" | "missing-session-id";
 interface WorkflowTaskRepairContextBase {
     readonly attempt: number;
@@ -44,10 +46,12 @@ export type WorkflowTaskRepairContext = WorkflowTaskRepairContextBase & ({
 });
 export interface WorkflowTaskExecutionContext {
     readonly abortSignal?: AbortSignal;
+    readonly reportProgress?: WorkflowTaskProgressReporter;
     readonly repair?: WorkflowTaskRepairContext;
 }
 export interface WorkflowTaskExecutionContextWithoutRepair {
     readonly abortSignal?: AbortSignal;
+    readonly reportProgress?: WorkflowTaskProgressReporter;
 }
 export type WorkflowTaskRepairLoopOption<Worker extends string> = Worker extends WorkflowRepairLoopContinuationWorkerId ? {
     readonly repair?: WorkflowTaskRepairContext;
@@ -56,12 +60,17 @@ export type WorkflowTaskRepairLoopOption<Worker extends string> = Worker extends
 };
 export type WorkflowTaskExecutor = (task: AnyWorkflowTask, context?: WorkflowTaskExecutionContext) => Promise<unknown | WorkflowTaskExecution>;
 export declare const DEFAULT_WORKFLOW_TASK_CONCURRENCY = 8;
+export declare const DEFAULT_WORKFLOW_MAX_PROMPT_BYTES: number;
 export declare const runWorkflow: (workflow: AnyWorkflowDefinition, options: {
     readonly executeTask: WorkflowTaskExecutor;
     readonly store?: WorkflowStore;
-    readonly cache?: boolean;
     readonly mockOutput?: boolean;
     readonly maxConcurrentTasks?: number;
+    readonly maxWallMs?: number;
+    readonly taskNoProgressMs?: number;
+    readonly maxTasks?: number;
+    readonly maxCostUsd?: number;
+    readonly maxPromptBytes?: number;
     readonly runId?: string;
     readonly runtimeOptions?: WorkflowRuntimeOptions;
     readonly abortSignal?: AbortSignal;

package/types/workflow-runtime.d.ts

@@ -1,4 +1,4 @@
-import { type WorkflowBunSpawnedProcess, type WorkflowBunSpawnOptions } from "./workflow-bun-runtime.js";
+import { type WorkflowBunPipedSpawnOptions, type WorkflowBunPipedSpawnedProcess, 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[];
@@ -13,12 +13,21 @@ export interface WorkflowDatabase {
 export interface WorkflowSpawnOptions extends WorkflowBunSpawnOptions {
     readonly cwd: string;
 }
+export interface WorkflowPipedSpawnOptions extends WorkflowBunPipedSpawnOptions {
+    readonly cwd: string;
+}
 export interface WorkflowSpawnedProcess extends WorkflowBunSpawnedProcess {
     readonly pid: number;
     readonly stdout: ReadableStream<Uint8Array>;
     readonly stderr: ReadableStream<Uint8Array>;
     unref(): void;
 }
+export interface WorkflowPipedSpawnedProcess extends WorkflowBunPipedSpawnedProcess {
+    readonly pid: number;
+    readonly stderr: ReadableStream<Uint8Array>;
+    unref(): void;
+}
 export declare const openWorkflowDatabase: (path: string) => WorkflowDatabase;
-export declare const spawnWorkflowProcess: (options: WorkflowSpawnOptions) => WorkflowSpawnedProcess;
+export declare function spawnWorkflowProcess(options: WorkflowPipedSpawnOptions): WorkflowPipedSpawnedProcess;
+export declare function spawnWorkflowProcess(options: WorkflowSpawnOptions): WorkflowSpawnedProcess;
 export declare const findWorkflowExecutable: (name: string) => string | undefined;

package/types/workflow-session.d.ts

@@ -1,17 +1,17 @@
 import { Schema } from "effect";
-export declare const WorkflowContinuationAdapterIdSchema: Schema.Literal<["amp-code", "antigravity-cli", "claude-code", "codex-cli", "grok-cli", "hermes", "kimi-code", "opencode-cli"]>;
+export declare const WorkflowContinuationAdapterIdSchema: Schema.Literal<["amp-code", "antigravity-cli", "claude-code", "codex-cli", "devin", "grok-cli", "hermes", "kimi-code", "opencode-cli", "omp-cli"]>;
 export type WorkflowContinuationAdapterId = typeof WorkflowContinuationAdapterIdSchema.Type;
-export declare const WorkflowContinuationWorkerIdSchema: Schema.Literal<["amp-code", "antigravity-cli", "claude-code", "codex-cli", "grok", "hermes", "kimi-code", "opencode"]>;
+export declare const WorkflowContinuationWorkerIdSchema: Schema.Literal<["amp-code", "antigravity-cli", "claude-code", "codex-cli", "devin", "grok", "hermes", "kimi-code", "opencode", "omp"]>;
 export type WorkflowContinuationWorkerId = typeof WorkflowContinuationWorkerIdSchema.Type;
 export declare const StableSessionIdSchema: Schema.brand<typeof Schema.NonEmptyTrimmedString, "StableSessionId">;
 export type StableSessionId = typeof StableSessionIdSchema.Type;
 export declare const WorkflowStableSessionSchema: Schema.Struct<{
-    adapter: Schema.Literal<["amp-code", "antigravity-cli", "claude-code", "codex-cli", "grok-cli", "hermes", "kimi-code", "opencode-cli"]>;
+    adapter: Schema.Literal<["amp-code", "antigravity-cli", "claude-code", "codex-cli", "devin", "grok-cli", "hermes", "kimi-code", "opencode-cli", "omp-cli"]>;
     sessionId: Schema.brand<typeof Schema.NonEmptyTrimmedString, "StableSessionId">;
 }>;
 export type WorkflowStableSession = typeof WorkflowStableSessionSchema.Type;
 export declare const WorkflowHarnessContinuationSupportSchema: Schema.Union<[Schema.Struct<{
-    adapter: Schema.Literal<["amp-code", "antigravity-cli", "claude-code", "codex-cli", "grok-cli", "hermes", "kimi-code", "opencode-cli"]>;
+    adapter: Schema.Literal<["amp-code", "antigravity-cli", "claude-code", "codex-cli", "devin", "grok-cli", "hermes", "kimi-code", "opencode-cli", "omp-cli"]>;
     workflowWorker: typeof Schema.Boolean;
     stableSessionIds: Schema.Literal<[true]>;
     exactSameSessionContinuation: Schema.Literal<[true]>;
@@ -19,7 +19,7 @@ export declare const WorkflowHarnessContinuationSupportSchema: Schema.Union<[Sch
     continueCommand: typeof Schema.NonEmptyTrimmedString;
     capture: typeof Schema.NonEmptyTrimmedString;
 }>, Schema.Struct<{
-    adapter: Schema.Literal<["amp-code", "antigravity-cli", "claude-code", "codex-cli", "grok-cli", "hermes", "kimi-code", "opencode-cli"]>;
+    adapter: Schema.Literal<["amp-code", "antigravity-cli", "claude-code", "codex-cli", "devin", "grok-cli", "hermes", "kimi-code", "opencode-cli", "omp-cli"]>;
     workflowWorker: typeof Schema.Boolean;
     stableSessionIds: Schema.Literal<[false]>;
     exactSameSessionContinuation: Schema.Literal<[false]>;
@@ -32,10 +32,12 @@ export declare const workflowContinuationAdapterByWorker: {
     readonly "antigravity-cli": "antigravity-cli";
     readonly "claude-code": "claude-code";
     readonly "codex-cli": "codex-cli";
+    readonly devin: "devin";
     readonly grok: "grok-cli";
     readonly hermes: "hermes";
     readonly "kimi-code": "kimi-code";
     readonly opencode: "opencode-cli";
+    readonly omp: "omp-cli";
 };
 export type WorkflowRepairLoopContinuationWorkerId = keyof typeof workflowContinuationAdapterByWorker;
 export type WorkflowRepairLoopContinuationCapability = "stable-session-repair-loop" | "no-repair-loop-continuation";
@@ -104,6 +106,15 @@ export declare const workflowHarnessContinuationSupport: {
         readonly continueCommand: "kimi --session <sessionId> --prompt <prompt>";
         readonly capture: "stream-json session.resume_hint.session_id or session index recovery";
     };
+    readonly devin: {
+        readonly adapter: "devin";
+        readonly workflowWorker: true;
+        readonly stableSessionIds: true;
+        readonly exactSameSessionContinuation: true;
+        readonly sessionIdField: "sessionId";
+        readonly continueCommand: "devin -p -r <sessionId> --prompt-file <prompt>";
+        readonly capture: "ATIF export session_id via --export";
+    };
     readonly "opencode-cli": {
         readonly adapter: "opencode-cli";
         readonly workflowWorker: true;
@@ -113,6 +124,15 @@ export declare const workflowHarnessContinuationSupport: {
         readonly continueCommand: "opencode run -s <sessionId> <prompt>";
         readonly capture: "json step_start sessionID, session list, export, database, or log recovery";
     };
+    readonly "omp-cli": {
+        readonly adapter: "omp-cli";
+        readonly workflowWorker: true;
+        readonly stableSessionIds: true;
+        readonly exactSameSessionContinuation: true;
+        readonly sessionIdField: "sessionId";
+        readonly continueCommand: "omp --mode json --resume <sessionId> -- <prompt>";
+        readonly capture: "json session event id";
+    };
 };
 export declare const stableSessionIdFromUnknown: (value: unknown) => StableSessionId | undefined;
 export declare const workflowContinuationAdapterForWorker: (worker: string) => WorkflowContinuationAdapterId | undefined;

package/types/workflow-store.d.ts

@@ -1,7 +1,10 @@
+import { type WorkflowRetentionCleanupReport, type WorkflowRunArtifactCounts, type WorkflowRunDeletionReport } from "./workflow-data-governance.js";
 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";
+import type { WorkflowSpanRecord } from "./workflow-tracing.js";
+import { type WorkflowUsage, type WorkflowUsageTotals } from "./workflow-usage.js";
 export type WorkflowTaskOutputSource = "mock-output";
 export interface CompletedWorkflowTaskRecord {
     readonly identity: WorkflowTaskIdentity;
@@ -30,6 +33,14 @@ export interface WorkflowJudgeRecord {
     readonly createdAt: string;
     readonly updatedAt: string;
 }
+export type WorkflowCacheWriteResult = {
+    readonly stored: true;
+} | {
+    readonly stored: false;
+    readonly reason: "sensitive-data";
+    readonly findingCount: number;
+    readonly findingPaths: ReadonlyArray<string>;
+};
 export type WorkflowRunTaskStatus = "completed" | "failed" | "escalated";
 export interface WorkflowRunTaskRecord {
     readonly runId: string;
@@ -45,7 +56,7 @@ export interface WorkflowRunTaskRecord {
     readonly output: unknown;
     readonly metadata?: Record<string, unknown>;
 }
-export type WorkflowRunTaskProgressStatus = "running" | "completed" | "failed" | "escalated";
+export type WorkflowRunTaskProgressStatus = "running" | "completed" | "failed" | "escalated" | "stopped" | "crashed";
 export type WorkflowRunTaskCacheLookup = "hit" | "miss" | "skipped";
 export interface WorkflowRunTaskProgress {
     readonly ordinal?: number;
@@ -85,6 +96,7 @@ export interface WorkflowRunTaskCompactSummary {
     readonly externalSessionPointer: string | null;
     readonly lastEventType?: string;
     readonly lastEventAt?: string;
+    readonly attempts: ReadonlyArray<WorkflowTaskAttemptRecord>;
 }
 export interface WorkflowRunSnapshot {
     readonly runId: string;
@@ -130,18 +142,77 @@ export interface WorkflowRunCompactSummary {
         readonly repairs: number;
         readonly status: WorkflowRunStatus;
         readonly durationMs: number | null;
+        readonly usage: WorkflowUsageTotals;
     };
     readonly tasks: WorkflowRunTaskCompactSummary[];
 }
+export type WorkflowRunCompletedCause = {
+    readonly kind: "completed";
+};
+export type WorkflowRunTaskFailureCause = {
+    readonly kind: "task-failed" | "task-escalated";
+    readonly taskId: string;
+    readonly ordinal: number;
+    readonly attempt: number;
+    readonly errorName: string;
+    readonly message: string;
+};
+export type WorkflowRunFailureCause = {
+    readonly kind: "workflow-failed";
+    readonly errorName: string;
+    readonly message: string;
+};
+export type WorkflowRunStoppedCause = {
+    readonly kind: "stopped";
+    readonly reason: string;
+    readonly signal?: string;
+};
+export type WorkflowRunCrashedCause = {
+    readonly kind: "crashed";
+    readonly reason: string;
+    readonly runnerPid?: number;
+    readonly heartbeatAt?: string;
+};
+export type WorkflowRunTimeoutCause = {
+    readonly kind: "workflow-timeout";
+    readonly limitMs: number;
+};
+export type WorkflowRunFanoutExceededCause = {
+    readonly kind: "workflow-fanout-exceeded";
+    readonly limit: number;
+    readonly observed: number;
+};
+export type WorkflowRunCostExceededCause = {
+    readonly kind: "workflow-cost-exceeded";
+    readonly limitUsd: number;
+    readonly observedUsd: number;
+};
+export type WorkflowRunCostUnavailableCause = {
+    readonly kind: "workflow-cost-unavailable";
+    readonly limitUsd: number;
+};
+export type WorkflowRunPromptLimitCause = {
+    readonly kind: "workflow-prompt-limit-exceeded";
+    readonly taskId: string;
+    readonly limitBytes: number;
+    readonly observedBytes: number;
+};
+export type WorkflowRunTerminalCause = WorkflowRunCompletedCause | WorkflowRunTaskFailureCause | WorkflowRunFailureCause | WorkflowRunStoppedCause | WorkflowRunCrashedCause | WorkflowRunTimeoutCause | WorkflowRunFanoutExceededCause | WorkflowRunCostExceededCause | WorkflowRunCostUnavailableCause | WorkflowRunPromptLimitCause;
 export interface WorkflowRunRecord {
     readonly runId: string;
     readonly workflow: string;
     readonly status: WorkflowRunStatus;
+    readonly terminalCause: WorkflowRunTerminalCause | null;
     readonly finishedAt: string | null;
     readonly runnerPid?: number;
     readonly heartbeatAt?: string;
+    readonly liveness: WorkflowRunLiveness;
+    readonly createdAt?: string;
+    readonly usage: WorkflowUsageTotals;
 }
-export type WorkflowRunStatus = "running" | "completed" | "failed" | "escalated" | "unknown";
+export type WorkflowRunLiveness = "alive" | "stale" | "unknown";
+export declare const WORKFLOW_RUN_LIVENESS_STALE_AFTER_MS = 10000;
+export type WorkflowRunStatus = "running" | "completed" | "failed" | "escalated" | "stopped" | "crashed" | "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
@@ -159,13 +230,124 @@ export interface WorkflowEventRecord {
     readonly payload: unknown;
     readonly createdAt: string;
 }
+export interface WorkflowRunInspection {
+    readonly schema: "prism.workflow-run-inspection.v1";
+    readonly dataPolicyVersion: number;
+    readonly store: {
+        readonly path: string;
+        readonly schemaVersion: number;
+        readonly files: ReadonlyArray<{
+            readonly path: string;
+            readonly present: boolean;
+            readonly mode: number | null;
+            readonly bytes: number | null;
+        }>;
+    };
+    readonly run: WorkflowRunRecord;
+    readonly rows: WorkflowRunArtifactCounts;
+    readonly runnerLog: {
+        readonly path: string | null;
+        readonly present: boolean;
+        readonly bytes: number | null;
+    };
+}
+export interface WorkflowRunExport {
+    readonly schema: "prism.workflow-run-export.v1";
+    readonly dataPolicyVersion: number;
+    readonly exportedAt: string;
+    readonly run: WorkflowRunRecord;
+    readonly snapshot: WorkflowRunSnapshot | null;
+    readonly tasks: ReadonlyArray<WorkflowRunTaskRecord>;
+    readonly taskSnapshots: ReadonlyArray<WorkflowRunTaskSnapshot>;
+    readonly attempts: ReadonlyArray<WorkflowTaskAttemptRecord>;
+    readonly events: ReadonlyArray<WorkflowEventRecord>;
+    readonly spans: ReadonlyArray<Omit<WorkflowSpanRecord, "startNs" | "endNs"> & {
+        readonly startNs: string;
+        readonly endNs: string | null;
+    }>;
+    readonly runnerLog: {
+        readonly path: string;
+        readonly bytes: number;
+        readonly content: string;
+    } | null;
+}
+export type WorkflowTaskAttemptStatus = "running" | "completed" | "failed" | "stopped" | "crashed";
+export type WorkflowTaskAttemptFailureKind = "executor" | "decode" | "finish" | "stopped" | "crashed";
+export interface WorkflowTaskAttemptFailure {
+    readonly kind: WorkflowTaskAttemptFailureKind;
+    readonly message: string;
+}
+export interface WorkflowTaskAttemptStartedInput {
+    readonly runId: string;
+    readonly ordinal: number;
+    readonly attempt: number;
+    readonly taskId: string;
+    readonly metadata?: Record<string, unknown>;
+}
+export interface WorkflowTaskAttemptFinishedInput {
+    readonly runId: string;
+    readonly ordinal: number;
+    readonly attempt: number;
+    readonly status: Exclude<WorkflowTaskAttemptStatus, "running">;
+    readonly metadata?: Record<string, unknown>;
+    readonly failure?: WorkflowTaskAttemptFailure;
+}
+export interface WorkflowTaskAttemptRecord {
+    readonly runId: string;
+    readonly ordinal: number;
+    readonly attempt: number;
+    readonly taskId: string;
+    readonly status: WorkflowTaskAttemptStatus;
+    readonly startedAt: string;
+    readonly finishedAt: string | null;
+    readonly adapter?: string;
+    readonly model?: string;
+    readonly nativeAgent?: string;
+    readonly sessionId?: string;
+    readonly failure?: WorkflowTaskAttemptFailure;
+    readonly usage?: WorkflowUsage;
+    readonly metadata?: Record<string, unknown>;
+}
 export declare const projectWorkflowStoreDir: (prismHome: string, cwd?: string) => string;
 export declare const defaultWorkflowStorePath: (prismHome: string, cwd?: string) => string;
+export declare const WORKFLOW_STORE_SCHEMA_VERSION = 5;
+/**
+ * Surfaces the one-time soft-divergence direction (WFE-007): a pre-existing store opened at a
+ * schema version older than the binary's `WORKFLOW_STORE_SCHEMA_VERSION` migrates in place inside
+ * `WorkflowStore.open`, silently by design, but callers reporting on the store (`runs list`,
+ * `runs show`) surface that a migration just ran. The other direction — a store newer than this
+ * binary supports — is not migratable and is already a hard error in `open`. Never populated for
+ * a brand-new store (nothing to diverge from).
+ */
+export interface WorkflowStoreSchemaNotice {
+    readonly severity: "info";
+    readonly openedVersion: number;
+    readonly currentVersion: number;
+    readonly message: string;
+}
+export declare const workflowRunLiveness: (run: Pick<WorkflowRunRecord, "status" | "runnerPid" | "heartbeatAt">, nowMs?: number) => WorkflowRunLiveness;
 export declare class WorkflowStore {
     private readonly db;
-    constructor(db: WorkflowDatabase);
-    static open(path: string): Promise<WorkflowStore>;
+    readonly path: string;
+    readonly schemaNotice: WorkflowStoreSchemaNotice | null;
+    initialRetentionCleanup: WorkflowRetentionCleanupReport | null;
+    constructor(db: WorkflowDatabase, path: string, schemaNotice?: WorkflowStoreSchemaNotice | null);
+    private updateRunUsageInCurrentTransaction;
+    static open(path: string, options?: {
+        readonly applyDefaultRetention?: boolean;
+    }): Promise<WorkflowStore>;
     close(): void;
+    private countRunArtifacts;
+    private deleteRunRowsInCurrentTransaction;
+    private removeQueuedRunnerLog;
+    private flushQueuedRunnerLogCleanup;
+    inspectRun(runId: string): Promise<WorkflowRunInspection>;
+    exportRun(runId: string): Promise<WorkflowRunExport>;
+    deleteRun(runId: string): Promise<WorkflowRunDeletionReport>;
+    pruneByAge(options?: {
+        readonly olderThanMs?: number;
+        readonly now?: Date;
+    }): Promise<WorkflowRetentionCleanupReport>;
     getCompleted(identity: WorkflowTaskIdentity, options?: {
         readonly allowMockSourced?: boolean;
     }): CompletedWorkflowTaskRecord | null;
@@ -176,7 +358,7 @@ export declare class WorkflowStore {
         readonly evidence: unknown;
         readonly output: unknown;
         readonly taskMetadata: unknown;
-    }): void;
+    }): WorkflowCacheWriteResult;
     listJudgeRecords(options?: {
         readonly workflow?: string;
         readonly taskId?: string;
@@ -202,7 +384,11 @@ export declare class WorkflowStore {
     consumeRunHandoffToken(runId: string, token: string): boolean;
     markRunRunnerStarted(runId: string, runnerPid: number): void;
     heartbeatRun(runId: string): void;
-    finishRun(runId: string, status: Exclude<WorkflowRunStatus, "running" | "unknown">): void;
+    recordTaskAttemptStarted(input: WorkflowTaskAttemptStartedInput): void;
+    recordTaskAttemptFinished(input: WorkflowTaskAttemptFinishedInput): void;
+    listRunTaskAttempts(runId: string): WorkflowTaskAttemptRecord[];
+    private finishRunInCurrentTransaction;
+    finishRun(runId: string, status: Exclude<WorkflowRunStatus, "running" | "unknown">, terminalCause?: WorkflowRunTerminalCause): void;
     stopRun(runId: string, reason?: string): WorkflowRunRecord | null;
     stopRunningRun(runId: string, reason?: string): WorkflowRunRecord | null;
     restartRunningRun(input: {
@@ -220,6 +406,15 @@ export declare class WorkflowStore {
         readonly type: string;
         readonly payload: unknown;
     }): void;
+    recordSpanStart(span: WorkflowSpanRecord): void;
+    recordSpanEnd(input: {
+        readonly spanId: string;
+        readonly endNs: bigint;
+        readonly status: "ok" | "error";
+        readonly errorMessage: string | null;
+        readonly attributes: Record<string, unknown>;
+    }): void;
+    listSpans(runId: string): WorkflowSpanRecord[];
     listRunEvents(runId: string): WorkflowEventRecord[];
     failDeadPidRuns(): WorkflowRunRecord[];
     failStaleRuns(olderThanMs: number, now?: Date): WorkflowRunRecord[];
@@ -252,5 +447,5 @@ export declare class WorkflowStore {
         readonly output: unknown;
         readonly metadata?: Record<string, unknown>;
         readonly outputSource?: WorkflowTaskOutputSource;
-    }): void;
+    }): WorkflowCacheWriteResult;
 }

package/types/workflow-tracing.d.ts

@@ -0,0 +1,85 @@
+import { Tracer } from "effect";
+import type { WorkflowStore } from "./workflow-store.js";
+export type WorkflowSpanStatus = "ok" | "error" | "unset";
+/** One row in `workflow_spans` — the sqlite-native span shape shared by the engine, the Effect tracer bridge, and the CLI trace renderer. */
+export interface WorkflowSpanRecord {
+    readonly runId: string;
+    readonly traceId: string;
+    readonly spanId: string;
+    readonly parentSpanId: string | null;
+    readonly taskId: string | null;
+    readonly name: string;
+    readonly kind: string;
+    readonly startNs: bigint;
+    readonly endNs: bigint | null;
+    readonly status: WorkflowSpanStatus;
+    readonly errorMessage: string | null;
+    readonly attributes: Record<string, unknown>;
+}
+export declare const generateWorkflowTraceId: () => string;
+export declare const generateWorkflowSpanId: () => string;
+export declare const currentTimeNanos: () => bigint;
+export interface WorkflowSpanStartInput {
+    readonly traceId: string;
+    readonly spanId: string;
+    readonly parentSpanId: string | null;
+    readonly taskId: string | null;
+    readonly name: string;
+    readonly kind: string;
+    readonly startNs: bigint;
+}
+export interface WorkflowSpanEndInput {
+    readonly spanId: string;
+    readonly endNs: bigint;
+    readonly status: Exclude<WorkflowSpanStatus, "unset">;
+    readonly errorMessage: string | null;
+    readonly attributes: Record<string, unknown>;
+}
+export interface WorkflowSpanHandle {
+    readonly spanId: string;
+    readonly traceId: string;
+    annotate(key: string, value: unknown): void;
+    end(status: Exclude<WorkflowSpanStatus, "unset">, error?: unknown): void;
+}
+/**
+ * The per-run span sink. Spans are written to the run's own sqlite store
+ * (start row on open, end update on close) so a killed run still shows its
+ * partial trace, and a running run is traceable live. When the run is not
+ * persisted (no store / null runId) every operation is a no-op.
+ */
+export interface WorkflowTraceRecorder {
+    readonly enabled: boolean;
+    readonly traceId: string;
+    recordSpanStart(input: WorkflowSpanStartInput): void;
+    recordSpanEnd(input: WorkflowSpanEndInput): void;
+    startSpan(name: string, options?: {
+        readonly parentSpanId?: string | null;
+        readonly taskId?: string | null;
+        readonly attributes?: Record<string, unknown>;
+    }): WorkflowSpanHandle;
+}
+export declare const createWorkflowTraceRecorder: (input: {
+    readonly store?: WorkflowStore;
+    readonly runId: string | null;
+    readonly traceId?: string;
+}) => WorkflowTraceRecorder;
+export declare const makeWorkflowEffectTracer: (recorder: WorkflowTraceRecorder, options?: {
+    readonly defaultParentSpanId?: string;
+}) => Tracer.Tracer;
+export interface WorkflowSpanTreeNode {
+    readonly span: WorkflowSpanRecord;
+    readonly children: ReadonlyArray<WorkflowSpanTreeNode>;
+}
+/** Spans whose parent is unknown (or absent) become roots; children stay in start order. */
+export declare const buildWorkflowSpanTree: (spans: ReadonlyArray<WorkflowSpanRecord>) => ReadonlyArray<WorkflowSpanTreeNode>;
+export declare const renderWorkflowTraceHuman: (spans: ReadonlyArray<WorkflowSpanRecord>, options?: {
+    readonly minDurationMs?: number;
+}) => string;
+/**
+ * Serialize span records as an OTLP/HTTP JSON `ExportTraceServiceRequest`,
+ * POSTable to any collector's `/v1/traces` endpoint.
+ */
+export declare const workflowSpansToOtlpJson: (spans: ReadonlyArray<WorkflowSpanRecord>, resource: {
+    readonly serviceName: string;
+    readonly attributes?: Record<string, unknown>;
+}) => unknown;

package/types/workflow-usage.d.ts

@@ -0,0 +1,21 @@
+export type WorkflowCostReporting = "full" | "tokens" | "none";
+export interface WorkflowUsage {
+    readonly tokensIn?: number;
+    readonly tokensOut?: number;
+    readonly costUsd?: number;
+    readonly durationMs?: number;
+    readonly costReporting: WorkflowCostReporting;
+}
+export interface WorkflowUsageTotals {
+    readonly agentRuns: number;
+    readonly reused: number;
+    readonly tokensIn: number;
+    readonly tokensOut: number;
+    readonly costUsd: number;
+    readonly durationMs: number;
+}
+export declare const emptyWorkflowUsageTotals: () => WorkflowUsageTotals;
+/** Normalize provider-specific task metadata into Prism's durable usage contract. */
+export declare const workflowUsageFromMetadata: (metadata: Record<string, unknown> | undefined) => WorkflowUsage;
+export declare const addWorkflowUsage: (totals: WorkflowUsageTotals, usage: WorkflowUsage) => WorkflowUsageTotals;
+export declare const addWorkflowReuse: (totals: WorkflowUsageTotals) => WorkflowUsageTotals;

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

@@ -6,3 +6,19 @@ export interface WorkflowWorkerStderrMetadata {
     readonly stderrTruncated?: boolean;
 }
 export declare const summarizeWorkflowWorkerStderr: (stderr: string, maxExcerptBytes?: number) => WorkflowWorkerStderrMetadata;
+/**
+ * Forensics attached to a worker adapter's thrown error on the failure path (OBS-006).
+ * On success, every adapter already returns `{ adapter, ..., sessionId, ...stderr summary }`
+ * as its `WorkflowTaskExecution.metadata`. On failure, that same shape was previously
+ * discarded entirely — the runner persisted only `{contractVersion, instructionSource}` —
+ * so a failed task could not be joined to its harness session or its stderr tail. Adapters
+ * attach this to their custom Error's `metadata` property at each failure throw site; the
+ * runner merges `error.metadata` into both the `task.executor.failed` event and the
+ * persisted task record.
+ */
+export declare const workflowWorkerFailureMetadata: (input: {
+    readonly adapter: string;
+    readonly stderr: string;
+    readonly sessionId?: string;
+    readonly maxExcerptBytes?: number;
+}) => Record<string, unknown>;

package/types/workflows.d.ts

@@ -58,15 +58,27 @@ export interface WorkflowValidationSummary {
 }
 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";
+export type WorkflowWorkerId = "amp-code" | "antigravity-cli" | "claude-code" | "codex-cli" | "devin" | "grok" | "hermes" | "kimi-code" | "opencode" | "omp";
 export type WorkflowPermissionMode = "legacy" | "permissive" | "restricted" | "interactive" | "sandbox-read-only" | "sandbox-workspace-write" | "full-access";
 export type AntigravityWorkflowPermissionMode = Extract<WorkflowPermissionMode, "legacy" | "permissive" | "full-access">;
+/**
+ * Per-task override for the executor-level transient-failure retry (WFE-009). Only
+ * classified-transient executor failures (process/idle timeout, unclassified non-zero
+ * exit) are retried; config/load errors and cancellation-barrier outcomes never are.
+ * `maxAttempts` counts total attempts (default 2, i.e. one retry) — the same convention
+ * as the shipped `agy` adapter's own `maxAttempts` option.
+ */
+export interface WorkflowTaskWorkerRetryOptions {
+    readonly maxAttempts?: number;
+    readonly backoffMs?: number;
+}
 type WorkflowTaskWorkerOptionsBase = {
     readonly model?: string | WorkflowModelProfileRef;
     readonly modelResolver?: (models: WorkflowResolvedModelTarget) => string;
     readonly profile?: string;
     readonly restrictedTools?: ReadonlyArray<string>;
     readonly processTimeoutMs?: number;
+    readonly retry?: WorkflowTaskWorkerRetryOptions;
 };
 export type WorkflowTaskWorkerOptions = (WorkflowTaskWorkerOptionsBase & {
     readonly worker?: Exclude<WorkflowWorkerId, "antigravity-cli">;
@@ -87,6 +99,8 @@ export interface WorkflowTaskModelResolution {
     readonly model: string;
     /** Harness-side inference provider (e.g. hermes `--provider xai-oauth`), from the modelspace target or harness default. */
     readonly provider?: string;
+    /** Harness-bound model variant, such as Codex reasoning effort. */
+    readonly variant?: string;
     readonly source: WorkflowTaskModelResolutionSource;
 }
 export declare const resolveWorkflowTaskModelResolution: (task: AnyWorkflowTask, options?: {
@@ -151,8 +165,15 @@ export interface WorkflowJudgeFinishCriterion<Output, Evidence = unknown> {
     readonly evaluate: (context: WorkflowJudgeCriterionContext<Output, Evidence>) => Effect.Effect<WorkflowJudgeVerdict, WorkflowFinishCriterionError>;
 }
 export type WorkflowFinishCriterion<Output> = WorkflowDeterministicFinishCriterion<Output> | WorkflowJudgeFinishCriterion<Output>;
+export declare const DEFAULT_WORKFLOW_DECODE_REPAIRS = 2;
 export interface WorkflowFinishOptions<Output> {
+    /** Maximum repairs requested by deterministic or judge finish criteria. Defaults to zero. */
     readonly maxRepairs?: number;
+    /**
+     * Maximum repairs after JSON parse or output schema decode failures.
+     * Defaults to DEFAULT_WORKFLOW_DECODE_REPAIRS.
+     */
+    readonly maxDecodeRepairs?: number;
     readonly criteria?: ReadonlyArray<WorkflowFinishCriterion<Output>>;
 }
 export interface WorkflowTaskDefinition<Id extends string, Agent extends WorkflowAgentRef, Output extends WorkflowOutputSchema> {
@@ -177,8 +198,43 @@ export interface WorkflowDefinition<Name extends string, Tasks extends ReadonlyA
     readonly name: Name;
     readonly tasks: Tasks;
 }
+export interface PhaseFraming {
+    readonly telos?: string;
+    readonly when?: string;
+    readonly coordination?: string;
+    readonly escalation?: string;
+}
+export interface PhaseContract<Name extends string, Agents extends Readonly<Record<string, WorkflowAgentRef>>, Output extends WorkflowOutputSchema> {
+    readonly name: Name;
+    readonly orbit: string;
+    readonly plugin: string;
+    readonly agents: Agents;
+    readonly output: Output;
+    readonly criteria?: readonly string[];
+    readonly framing?: PhaseFraming;
+}
+export type PhaseTaskFinishOptions<Output> = WorkflowFinishOptions<Output> & {
+    readonly inherit?: boolean;
+};
+export type PhaseTaskDefinition<Id extends string, Agent extends WorkflowAgentRef, Output extends WorkflowOutputSchema = WorkflowOutputSchema> = Omit<WorkflowTaskDefinition<Id, Agent, Output>, "output" | "phase" | "finish"> & {
+    readonly output?: Output;
+    readonly phase?: string;
+    readonly finish?: PhaseTaskFinishOptions<Schema.Schema.Type<Output>>;
+    readonly brief?: boolean;
+};
+export type PhaseCtxTask<Agents extends Readonly<Record<string, WorkflowAgentRef>>, DefaultOutput extends WorkflowOutputSchema> = <const Id extends string, const Agent extends Agents[keyof Agents], const TaskOutput extends WorkflowOutputSchema = DefaultOutput>(def: PhaseTaskDefinition<Id, Agent, TaskOutput>) => Effect.Effect<WorkflowTaskOutput<WorkflowTask<Id, Agent, TaskOutput>>, WorkflowRuntimeError>;
+export interface PhaseCtx<Name extends string, Agents extends Readonly<Record<string, WorkflowAgentRef>>, DefaultOutput extends WorkflowOutputSchema> {
+    readonly name: Name;
+    readonly orbit: string;
+    readonly plugin: string;
+    readonly agents: Agents;
+    readonly phase: string;
+    readonly task: PhaseCtxTask<Agents, DefaultOutput>;
+}
+export declare const phase: <const Name extends string, const Agents extends Readonly<Record<string, WorkflowAgentRef>>, const Output extends WorkflowOutputSchema, Result, Err = WorkflowRuntimeError>(runtime: Pick<WorkflowRuntime, "runTask">, contract: PhaseContract<Name, Agents, Output>, fn: (ctx: PhaseCtx<Name, Agents, Output>) => Effect.Effect<Result, Err, never>) => Effect.Effect<Result, Err | WorkflowRuntimeError, never>;
 export interface WorkflowRuntime {
     runTask: <Task extends AnyWorkflowTask>(task: Task) => Effect.Effect<WorkflowTaskOutput<Task>, WorkflowRuntimeError>;
+    phase: <const Name extends string, const Agents extends Readonly<Record<string, WorkflowAgentRef>>, const Output extends WorkflowOutputSchema, Result, Err = WorkflowRuntimeError>(contract: PhaseContract<Name, Agents, Output>, fn: (ctx: PhaseCtx<Name, Agents, Output>) => Effect.Effect<Result, Err, never>) => Effect.Effect<Result, Err | WorkflowRuntimeError, never>;
 }
 export interface WorkflowRuntimeOptions {
     readonly fallbackWorker?: string;