@skastr0/prism-linux-arm64 0.1.3 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skastr0/prism-linux-arm64",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "type": "module",
   "description": "Prism standalone CLI binary for Linux arm64.",
   "license": "MIT",
@@ -23,6 +23,10 @@
     "typescript": "^5.8.3",
     "zod": "4.4.3"
   },
+  "optionalDependencies": {
+    "@opentui/core-linux-arm64": "0.4.1",
+    "@opentui/core-linux-arm64-musl": "0.4.1"
+  },
   "os": [
     "linux"
   ],

package/types/compile/generated-plugin.d.ts

@@ -1,4 +1,5 @@
 import type { ResolvedContractBinding } from "./resolve.js";
+export declare const GENERATED_EXTERNAL_TOOL_NAME_MAX_LENGTH = 52;
 export declare const normalizeGeneratedPluginName: (pluginName: string) => string;
 export declare const sanitizeGeneratedToolSegment: (value: string, fallback: string) => string;
 export declare const generatedToolNamespace: (pluginName: string) => string;

package/types/compile/sources.d.ts

@@ -1338,24 +1338,24 @@ declare const Trait_base: Schema.Class<Trait, {
         skills: Schema.Array$<typeof Schema.String>;
     }>;
 }>, never, {
-    readonly name: string;
-} & {
-    readonly description?: string | undefined;
-} & {
-    readonly sourcePath: string;
-} & {
     readonly tools: {
         readonly [x: string]: {
             readonly ref: string;
         };
     };
+} & {
+    readonly name: string;
+} & {
+    readonly description?: string | undefined;
+} & {
+    readonly sourcePath: string;
 } & {
     readonly instructions: readonly string[];
 } & {
     readonly access: {
+        readonly skills: readonly string[];
         readonly tools: readonly string[];
         readonly toolGroups: readonly string[];
-        readonly skills: readonly string[];
     };
 } & {
     readonly inject: {
@@ -1363,8 +1363,8 @@ declare const Trait_base: Schema.Class<Trait, {
     };
 } & {
     readonly require: {
-        readonly tools: readonly string[];
         readonly skills: readonly string[];
+        readonly tools: readonly string[];
     };
 }, {}, {}>;
 export declare class Trait extends Trait_base {
@@ -1711,6 +1711,25 @@ declare const Agent_base: Schema.Class<Agent, {
     targets: Schema.Record$<typeof Schema.String, typeof Schema.Object>;
 }>, never, {
     readonly model?: string | undefined;
+} & {
+    readonly skills: readonly string[];
+} & {
+    readonly traits: readonly {
+        readonly tools: {
+            readonly [x: string]: {
+                readonly slots: {
+                    readonly [x: string]: {
+                        readonly schema: unknown;
+                        readonly source: {
+                            readonly sourcePath: string;
+                            readonly exportName: string;
+                        };
+                    };
+                };
+            };
+        };
+        readonly ref: string;
+    }[];
 } & {
     readonly name: string;
 } & {
@@ -1723,33 +1742,14 @@ declare const Agent_base: Schema.Class<Agent, {
     };
 } & {
     readonly sourcePath: string;
-} & {
-    readonly skills: readonly string[];
 } & {
     readonly access: {
+        readonly skills: readonly string[];
         readonly tools: readonly string[];
         readonly toolGroups: readonly string[];
-        readonly skills: readonly string[];
     };
 } & {
     readonly personality?: string | undefined;
-} & {
-    readonly traits: readonly {
-        readonly ref: string;
-        readonly tools: {
-            readonly [x: string]: {
-                readonly slots: {
-                    readonly [x: string]: {
-                        readonly schema: unknown;
-                        readonly source: {
-                            readonly sourcePath: string;
-                            readonly exportName: string;
-                        };
-                    };
-                };
-            };
-        };
-    }[];
 } & {
     readonly color?: string | undefined;
 }, {}, {}>;
@@ -1885,12 +1885,6 @@ declare const Toolspace_base: Schema.Class<Toolspace, {
         tools: Schema.Array$<typeof Schema.String>;
     }>>;
 }>, never, {
-    readonly name: string;
-} & {
-    readonly description?: string | undefined;
-} & {
-    readonly sourcePath: string;
-} & {
     readonly tools: {
         readonly [x: string]: {
             readonly description?: string | undefined;
@@ -1899,11 +1893,17 @@ declare const Toolspace_base: Schema.Class<Toolspace, {
             };
         };
     };
+} & {
+    readonly name: string;
+} & {
+    readonly description?: string | undefined;
+} & {
+    readonly sourcePath: string;
 } & {
     readonly groups: {
         readonly [x: string]: {
-            readonly description?: string | undefined;
             readonly tools: readonly string[];
+            readonly description?: string | undefined;
         };
     };
 }, {}, {}>;
@@ -2032,12 +2032,6 @@ declare const Skillspace_base: Schema.Class<Skillspace, {
         }>>;
     }>>;
 }>, never, {
-    readonly name: string;
-} & {
-    readonly description?: string | undefined;
-} & {
-    readonly sourcePath: string;
-} & {
     readonly skills: {
         readonly [x: string]: {
             readonly description?: string | undefined;
@@ -2048,6 +2042,12 @@ declare const Skillspace_base: Schema.Class<Skillspace, {
             };
         };
     };
+} & {
+    readonly name: string;
+} & {
+    readonly description?: string | undefined;
+} & {
+    readonly sourcePath: string;
 }, {}, {}>;
 export declare class Skillspace extends Skillspace_base {
 }
@@ -2725,6 +2725,7 @@ declare const Orbit_base: Schema.Class<Orbit, {
             readonly finish_criteria?: readonly string[] | undefined;
             readonly escalation?: string | undefined;
         } | undefined;
+        readonly agents: readonly string[];
         readonly name: string;
         readonly body?: string | undefined;
         readonly orbit?: string | undefined;
@@ -2734,7 +2735,6 @@ declare const Orbit_base: Schema.Class<Orbit, {
                 readonly [x: string]: string;
             } | undefined;
         } | undefined;
-        readonly agents: readonly string[];
         readonly requires: readonly {
             readonly all: readonly string[];
             readonly min?: number | undefined;

package/types/errors.d.ts

@@ -61,6 +61,15 @@ export declare class McpBundleMissingError extends McpBundleMissingError_base {
     get hint(): string;
     get message(): string;
 }
+declare const McpPortConflictError_base: Schema.TaggedErrorClass<McpPortConflictError, "McpPortConflictError", {
+    readonly _tag: Schema.tag<"McpPortConflictError">;
+} & {
+    host: typeof Schema.String;
+    port: typeof Schema.Number;
+}>;
+export declare class McpPortConflictError extends McpPortConflictError_base {
+    get message(): string;
+}
 declare const BlockedTargetError_base: Schema.TaggedErrorClass<BlockedTargetError, "BlockedTargetError", {
     readonly _tag: Schema.tag<"BlockedTargetError">;
 } & {
@@ -75,7 +84,7 @@ export declare class BlockedTargetError extends BlockedTargetError_base {
  * Every typed error Prism may surface to a human. `CompileError` (which
  * includes `PluginManifestError`) is defined in src/compile/errors.ts.
  */
-export type PrismError = CompileError | PrismConfigError | BundleBuildError | McpBundleMissingError | BlockedTargetError;
+export type PrismError = CompileError | PrismConfigError | BundleBuildError | McpBundleMissingError | McpPortConflictError | BlockedTargetError;
 export declare const PRISM_ERROR_TAGS: ReadonlySet<string>;
 export declare const isPrismError: (value: unknown) => value is PrismError;
 export interface PrismErrorRender {

package/types/harnesses.d.ts

@@ -1,10 +1,18 @@
 /**
  * Harness registry - configurations for all supported AI coding harnesses
  */
+import { Layer } from "effect";
+import { HarnessRoots, type HarnessRootsEnv } from "./services/prism-env.js";
 import type { HarnessConfig, HarnessId, HarnessScope } from "./types.js";
 export declare const HARNESSES: Record<HarnessId, HarnessConfig>;
 export declare function getHarness(id: HarnessId): HarnessConfig;
 export declare function getAllHarnessIds(): HarnessId[];
 export declare function isValidHarnessId(id: string): id is HarnessId;
-export declare function resolveHarnessRoot(harness: HarnessConfig, scope: HarnessScope, projectPath?: string): string | null;
+/**
+ * Live layer mapping each harness to its registry globalConfigPath, expanded
+ * through the current HOME. This belongs with the registry because it is the
+ * only module that owns the harness definitions.
+ */
+export declare const HarnessRootsLive: Layer.Layer<HarnessRoots>;
+export declare function resolveHarnessRoot(harness: HarnessConfig, scope: HarnessScope, projectPath?: string, roots?: HarnessRootsEnv): string | null;
 export declare function harnessSupportsProjectScope(harness: HarnessConfig): boolean;

package/types/index.d.ts

@@ -12,6 +12,7 @@
  *
  * These helpers are identity constructors for authoring ergonomics.
  */
+export * from "./workflow-errors.js";
 export * from "./workflows.js";
 export * from "./workflow-tsconfig.js";
 export * from "./workflow-antigravity-worker.js";

package/types/services/prism-env.d.ts

@@ -0,0 +1,45 @@
+/**
+ * PrismHome — the Effect service carrying the resolved Prism home directory
+ * (docs/overhaul-one-writer-plan.md, WS2).
+ *
+ * The env read (`PRISM_HOME`, falling back to ~/.prism) happens exactly once,
+ * at the CLI edge, when `PrismHomeLive` is built into the runtime. Library
+ * code never falls back to the environment: new code (WS3+ snapshot store,
+ * sync engine, MCP supervisor) consumes the `PrismHome` tag, so tests are
+ * structurally unable to touch real state — they provide `PrismHomeTest`.
+ *
+ * Do not add `resolvePrismHome()` default-argument fallbacks to new modules;
+ * thread this service instead.
+ */
+import { Context, Layer } from "effect";
+import type { HarnessId } from "../types.js";
+export interface PrismEnv {
+    /** Absolute path of the Prism home directory. */
+    readonly home: string;
+}
+declare const PrismHome_base: Context.TagClass<PrismHome, "prism/PrismHome", PrismEnv>;
+export declare class PrismHome extends PrismHome_base {
+}
+/**
+ * Live layer for the CLI edge. Reads the environment once when the layer is
+ * built; everything downstream sees one immutable value.
+ */
+export declare const PrismHomeLive: Layer.Layer<PrismHome>;
+/** In-memory layer for tests — no env read, no disk. */
+export declare const PrismHomeTest: (home: string) => Layer.Layer<PrismHome>;
+/**
+ * HarnessRoots — the Effect service carrying the resolved base directory for
+ * each harness global root. Production resolves via the harness registry's
+ * globalConfigPath; tests provide a map of harness IDs to temp directories so
+ * refresh/compile/doctor never touch real harness configs.
+ */
+export interface HarnessRootsEnv {
+    /** Resolve the global root directory for a harness. */
+    readonly resolve: (harnessId: HarnessId) => string;
+}
+declare const HarnessRoots_base: Context.TagClass<HarnessRoots, "prism/HarnessRoots", HarnessRootsEnv>;
+export declare class HarnessRoots extends HarnessRoots_base {
+}
+/** In-memory layer for tests — maps harnesses to caller-supplied roots. */
+export declare const HarnessRootsTest: (roots: Partial<Record<HarnessId, string>>) => Layer.Layer<HarnessRoots>;
+export {};

package/types/types.d.ts

@@ -52,6 +52,7 @@ export interface PluginManifest {
     deps?: Record<string, string>;
     runtime?: PluginRuntimeConfig;
     projects?: Record<string, ProjectConfig>;
+    inlineSkills?: string[];
 }
 export interface ProjectConfig {
     pattern?: string;

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

@@ -1,12 +1,28 @@
-import type { AnyWorkflowTask } from "./workflows.js";
-import type { WorkflowTaskExecution } from "./workflow-runner.js";
-export interface AmpWorkflowWorkerOptions {
+import type { AnyWorkflowTask, WorkflowPermissionMode } from "./workflows.js";
+import type { WorkflowTaskExecution, WorkflowTaskRepairLoopOption } from "./workflow-runner.js";
+export type AmpWorkflowWorkerOptions = {
     readonly cwd: string;
     readonly bin?: string;
     readonly model?: string;
+    readonly resolvedPermission: WorkflowPermissionMode;
+    readonly processTimeoutMs?: number;
     readonly abortSignal?: AbortSignal;
-}
+} & WorkflowTaskRepairLoopOption<"amp-code">;
 export declare class AmpWorkflowWorkerError extends Error {
     readonly name = "AmpWorkflowWorkerError";
 }
+export type AmpWorkflowMode = "deep" | "rush";
+export declare const assertAmpWorkflowMode: (mode: string | undefined) => AmpWorkflowMode | undefined;
+export declare const buildAmpArgs: (input: {
+    readonly mode?: string;
+    readonly prompt: string;
+    readonly sessionId?: string;
+    readonly permission?: WorkflowPermissionMode;
+    /**
+     * Required for permissive/full-access. runAmpWorkflowTask supplies a temp
+     * settings file with amp.dangerouslyAllowAll enabled before invoking this.
+     */
+    readonly settingsFile?: string;
+}) => ReadonlyArray<string>;
+export declare const ampSessionId: (stdout: string, stderr: string) => string | undefined;
 export declare const runAmpWorkflowTask: (task: AnyWorkflowTask, options: AmpWorkflowWorkerOptions) => Promise<WorkflowTaskExecution>;

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

@@ -0,0 +1,22 @@
+import type { WorkflowWorkerProcessOptions, WorkflowWorkerProcessResult } from "./workflow-worker-process.js";
+/**
+ * Embedded Python PTY wrapper for spawning the Antigravity CLI (`agy`) with a
+ * controlling terminal. The upstream `agy --print` mode is known to drop or
+ * stall stdout when stdin is not a TTY; allocating a PTY works around the
+ * issue and also lets us reliably terminate the whole process group.
+ *
+ * The wrapper runs on Python 3, uses only stdlib modules, and is written to
+ * be compatible with both macOS and Linux.
+ */
+export declare const antigravityPtyWrapperScript: () => string;
+export interface AntigravityPtyProcessOptions extends WorkflowWorkerProcessOptions {
+    /** Go-style duration string passed to `agy --print-timeout`. */
+    readonly printTimeout: string;
+}
+/**
+ * Run a command through the Python PTY wrapper with process-group cleanup.
+ *
+ * This is intentionally lower-level than `runWorkflowWorkerProcess` so the
+ * Antigravity worker can decide when the extra weight is justified.
+ */
+export declare const runAntigravityPtyProcess: (options: AntigravityPtyProcessOptions) => Promise<WorkflowWorkerProcessResult>;

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

@@ -1,14 +1,75 @@
-import type { AnyWorkflowTask } from "./workflows.js";
-import type { WorkflowTaskExecution } from "./workflow-runner.js";
-export interface AntigravityWorkflowWorkerOptions {
+import type { AntigravityWorkflowPermissionMode, AnyWorkflowTask, WorkflowPermissionMode } from "./workflows.js";
+import type { WorkflowTaskExecution, WorkflowTaskRepairLoopOption } from "./workflow-runner.js";
+/**
+ * Environment-variable overrides for the Antigravity workflow worker:
+ *
+ * - PRISM_WORKFLOW_ANTIGRAVITY_BIN: path to the `agy` executable.
+ * - PRISM_WORKFLOW_ANTIGRAVITY_PRINT_TIMEOUT: value passed to `agy --print-timeout`.
+ * - PRISM_WORKFLOW_ANTIGRAVITY_PROCESS_TIMEOUT_MS: outer watchdog before Prism kills `agy`.
+ * - PRISM_WORKFLOW_ANTIGRAVITY_PTY: set to "1" or "true" to force a Python PTY wrapper.
+ *   Useful when `agy --print` drops stdout because stdin is not a TTY.
+ * - PRISM_WORKFLOW_ANTIGRAVITY_PTY_PYTHON: path to a Python 3 interpreter (default: `python3` on PATH).
+ * - PRISM_WORKFLOW_ANTIGRAVITY_RETRY_MAX_ATTEMPTS: retries on sentinel/empty output (default: 3).
+ * - PRISM_WORKFLOW_ANTIGRAVITY_RETRY_BACKOFF_MS: delay between retries (default: 2000).
+ */
+export type AntigravityWorkflowWorkerOptions = {
     readonly cwd: string;
     readonly bin?: string;
     readonly model?: string;
+    readonly resolvedPermission: AntigravityWorkflowPermissionMode;
     readonly printTimeout?: string;
     readonly processTimeoutMs?: number;
     readonly abortSignal?: AbortSignal;
-}
+    /** Override the default retry budget. Mostly useful in tests. */
+    readonly maxAttempts?: number;
+    /** Override the default retry backoff. Mostly useful in tests. */
+    readonly backoffMs?: number;
+} & WorkflowTaskRepairLoopOption<"antigravity-cli">;
 export declare class AntigravityWorkflowWorkerError extends Error {
     readonly name = "AntigravityWorkflowWorkerError";
 }
+export declare const DEFAULT_ANTIGRAVITY_MODEL = "Gemini 3.5 Flash (Medium)";
+export type AgyConversationId = string & {
+    readonly __brand: "AgyConversationId";
+};
+type AgyValue<Kind extends string> = string & {
+    readonly __agyValue: Kind;
+};
+type AgyLogFile = AgyValue<"log-file">;
+type AgyPrintTimeout = AgyValue<"print-timeout">;
+type AgyWorkspaceDir = AgyValue<"workspace-dir">;
+type AgyModel = AgyValue<"model">;
+type AgyPrompt = AgyValue<"prompt">;
+type AgyLogFileArgs = readonly ["--log-file", AgyLogFile];
+type AgyConversationArgs = readonly ["--conversation", AgyConversationId];
+type AgyPermissionArgs = readonly ["--dangerously-skip-permissions", "--sandbox"];
+type AgyTimeoutArgs = readonly ["--print-timeout", AgyPrintTimeout];
+type AgyWorkspaceArgs = readonly ["--add-dir", AgyWorkspaceDir];
+type AgyModelArgs = readonly ["--model", AgyModel];
+type AgyRequiredPrintArgs = readonly [
+    ...AgyPermissionArgs,
+    ...AgyTimeoutArgs,
+    ...AgyWorkspaceArgs,
+    ...AgyModelArgs,
+    "--print",
+    AgyPrompt
+];
+export type AgyForbiddenWorkflowFlag = "--continue" | "-c";
+export type AgyPrintArgs = AgyRequiredPrintArgs | readonly [...AgyLogFileArgs, ...AgyRequiredPrintArgs] | readonly [...AgyConversationArgs, ...AgyRequiredPrintArgs] | readonly [...AgyLogFileArgs, ...AgyConversationArgs, ...AgyRequiredPrintArgs];
+export declare const AGY_FORBIDDEN_WORKFLOW_FLAGS: Set<AgyForbiddenWorkflowFlag>;
+export declare const assertAgyPrintArgsWorkflowSafe: (args: readonly string[]) => void;
+export declare const detectAgyPrintTimeout: (stdout: string, stderr: string) => boolean;
+export declare const resolveAntigravityPermission: (mode: WorkflowPermissionMode) => AntigravityWorkflowPermissionMode;
+export declare const buildAgyArgs: (input: {
+    readonly cwd: string;
+    readonly model: string;
+    readonly permission?: AntigravityWorkflowPermissionMode;
+    readonly printTimeout: string;
+    readonly prompt: string;
+    readonly conversationId?: AgyConversationId;
+    readonly logFile?: string;
+}) => AgyPrintArgs;
+export declare const parseAgyConversationId: (value: string | undefined) => AgyConversationId | undefined;
+export declare const extractAgyConversationId: (logText: string) => AgyConversationId | undefined;
 export declare const runAntigravityWorkflowTask: (task: AnyWorkflowTask, options: AntigravityWorkflowWorkerOptions) => Promise<WorkflowTaskExecution>;
+export {};

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

@@ -1,13 +1,32 @@
-import type { AnyWorkflowTask } from "./workflows.js";
-import type { WorkflowTaskExecution, WorkflowTaskRepairContext } from "./workflow-runner.js";
-export interface ClaudeWorkflowWorkerOptions {
+import type { AnyWorkflowTask, WorkflowPermissionMode } from "./workflows.js";
+import { type WorkflowJsonSchema } from "./workflow-output-schema.js";
+import type { WorkflowTaskExecution, WorkflowTaskRepairLoopOption } from "./workflow-runner.js";
+export type ClaudeWorkflowWorkerOptions = {
     readonly cwd: string;
     readonly bin?: string;
     readonly model?: string;
+    readonly resolvedPermission: WorkflowPermissionMode;
+    readonly restrictedTools?: readonly string[];
+    readonly processTimeoutMs?: number;
     readonly abortSignal?: AbortSignal;
-    readonly repair?: WorkflowTaskRepairContext;
-}
+} & WorkflowTaskRepairLoopOption<"claude-code">;
 export declare class ClaudeWorkflowWorkerError extends Error {
     readonly name = "ClaudeWorkflowWorkerError";
 }
+export interface ClaudeGeneratedPluginDiscovery {
+    readonly pluginDir?: string;
+    readonly mcpConfig?: string;
+    readonly allowedTools?: readonly string[];
+}
+export declare const discoverClaudeGeneratedPlugin: (task: AnyWorkflowTask) => ClaudeGeneratedPluginDiscovery;
+export declare const buildClaudeArgs: (input: {
+    readonly agent: string;
+    readonly model?: string;
+    readonly prompt: string;
+    readonly resumeSessionId?: string;
+    readonly generatedPlugin?: ClaudeGeneratedPluginDiscovery;
+    readonly outputSchema?: WorkflowJsonSchema;
+    readonly permission?: WorkflowPermissionMode;
+    readonly restrictedTools?: readonly string[];
+}) => ReadonlyArray<string>;
 export declare const runClaudeWorkflowTask: (task: AnyWorkflowTask, options: ClaudeWorkflowWorkerOptions) => Promise<WorkflowTaskExecution>;

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

@@ -1,12 +1,24 @@
-import type { AnyWorkflowTask } from "./workflows.js";
-import type { WorkflowTaskExecution } from "./workflow-runner.js";
-export interface CodexWorkflowWorkerOptions {
+import type { AnyWorkflowTask, WorkflowPermissionMode } from "./workflows.js";
+import type { WorkflowTaskExecution, WorkflowTaskRepairLoopOption } from "./workflow-runner.js";
+export type CodexWorkflowWorkerOptions = {
     readonly cwd: string;
     readonly bin?: string;
     readonly model?: string;
+    readonly resolvedPermission: WorkflowPermissionMode;
+    readonly processTimeoutMs?: number;
     readonly abortSignal?: AbortSignal;
-}
+} & WorkflowTaskRepairLoopOption<"codex-cli">;
 export declare class CodexWorkflowWorkerError extends Error {
     readonly name = "CodexWorkflowWorkerError";
 }
+export declare const buildCodexArgs: (input: {
+    readonly cwd: string;
+    readonly model?: string;
+    readonly outputSchemaPath?: string;
+    readonly outputPath: string;
+    readonly prompt: string;
+    readonly resumeSessionId?: string;
+    readonly permission?: WorkflowPermissionMode;
+}) => ReadonlyArray<string>;
+export declare const codexSessionId: (stdout: string, stderr: string) => string | undefined;
 export declare const runCodexWorkflowTask: (task: AnyWorkflowTask, options: CodexWorkflowWorkerOptions) => Promise<WorkflowTaskExecution>;

package/types/workflow-errors.d.ts

@@ -0,0 +1,21 @@
+/** Errors surfaced by {@link WorkflowRuntime.runTask} and dynamic workflow runs. */
+export declare class WorkflowTaskDecodeError extends Error {
+    readonly taskId: string;
+    readonly cause: unknown;
+    readonly name = "WorkflowTaskDecodeError";
+    constructor(taskId: string, cause: unknown);
+}
+export declare class WorkflowRunStoppedError extends Error {
+    readonly runId: string;
+    readonly name = "WorkflowRunStoppedError";
+    constructor(runId: string);
+}
+export declare class WorkflowTaskEscalatedError extends Error {
+    readonly taskId: string;
+    readonly criterion: string;
+    readonly feedback?: string | undefined;
+    readonly name = "WorkflowTaskEscalatedError";
+    constructor(taskId: string, criterion: string, feedback?: string | undefined);
+}
+export type WorkflowRuntimeError = WorkflowTaskDecodeError | WorkflowTaskEscalatedError | WorkflowRunStoppedError | Error;
+export declare const toWorkflowRuntimeError: (error: unknown) => WorkflowRuntimeError;

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

@@ -1,14 +1,27 @@
-import type { AnyWorkflowTask } from "./workflows.js";
-import type { WorkflowTaskExecution } from "./workflow-runner.js";
-export interface GrokWorkflowWorkerOptions {
+import type { AnyWorkflowTask, WorkflowPermissionMode } from "./workflows.js";
+import type { WorkflowTaskExecution, WorkflowTaskRepairLoopOption } from "./workflow-runner.js";
+export type GrokWorkflowWorkerOptions = {
     readonly cwd: string;
     readonly bin?: string;
     readonly model?: string;
     readonly effort?: string;
+    readonly resolvedPermission: WorkflowPermissionMode;
+    readonly processTimeoutMs?: number;
     readonly abortSignal?: AbortSignal;
-}
+} & WorkflowTaskRepairLoopOption<"grok">;
 export declare class WorkflowWorkerError extends Error {
     readonly name = "WorkflowWorkerError";
 }
+export declare const isGrokAuthOutput: (output: string) => boolean;
+export declare const buildGrokArgs: (input: {
+    readonly cwd: string;
+    readonly agent: string;
+    readonly model?: string;
+    readonly effort?: string;
+    readonly prompt: string;
+    readonly sessionId?: string;
+    readonly permission?: WorkflowPermissionMode;
+}) => ReadonlyArray<string>;
+export declare const grokSessionId: (stdout: string, stderr: string) => string | undefined;
 export declare const runGrokWorkflowTask: (task: AnyWorkflowTask, options: GrokWorkflowWorkerOptions) => Promise<WorkflowTaskExecution>;
 export { parseWorkflowWorkerJsonOutput, WorkflowOutputParseError } from "./workflow-worker-contract.js";

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

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

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

@@ -1,14 +1,24 @@
-import type { AnyWorkflowTask } from "./workflows.js";
-import type { WorkflowTaskExecution } from "./workflow-runner.js";
-export interface KimiWorkflowWorkerOptions {
+import type { AnyWorkflowTask, WorkflowPermissionMode } from "./workflows.js";
+import type { WorkflowTaskExecution, WorkflowTaskRepairLoopOption } from "./workflow-runner.js";
+export type KimiWorkflowWorkerOptions = {
     readonly cwd: string;
     readonly bin?: string;
     readonly model?: string;
     readonly kimiHome?: string;
+    readonly resolvedPermission: WorkflowPermissionMode;
     readonly processTimeoutMs?: number;
     readonly abortSignal?: AbortSignal;
-}
+} & WorkflowTaskRepairLoopOption<"kimi-code">;
 export declare class KimiWorkflowWorkerError extends Error {
     readonly name = "KimiWorkflowWorkerError";
 }
+export declare const isKimiAuthOutput: (output: string) => boolean;
+export declare const kimiSessionIdFromStream: (stdout: string) => string | undefined;
+export declare const buildKimiArgs: (input: {
+    readonly model?: string;
+    readonly prompt: string;
+    readonly skillsDir: string;
+    readonly sessionId?: string;
+    readonly permission?: WorkflowPermissionMode;
+}) => ReadonlyArray<string>;
 export declare const runKimiWorkflowTask: (task: AnyWorkflowTask, options: KimiWorkflowWorkerOptions) => Promise<WorkflowTaskExecution>;

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

@@ -1,12 +1,22 @@
-import type { AnyWorkflowTask } from "./workflows.js";
-import type { WorkflowTaskExecution } from "./workflow-runner.js";
-export interface OpenCodeWorkflowWorkerOptions {
+import type { AnyWorkflowTask, WorkflowPermissionMode } from "./workflows.js";
+import type { WorkflowTaskExecution, WorkflowTaskRepairLoopOption } from "./workflow-runner.js";
+export type OpenCodeWorkflowWorkerOptions = {
     readonly cwd: string;
     readonly bin?: string;
     readonly model?: string;
+    readonly resolvedPermission: WorkflowPermissionMode;
+    readonly processTimeoutMs?: number;
     readonly abortSignal?: AbortSignal;
-}
+} & WorkflowTaskRepairLoopOption<"opencode">;
 export declare class OpenCodeWorkflowWorkerError extends Error {
     readonly name = "OpenCodeWorkflowWorkerError";
 }
+export declare const buildOpenCodeArgs: (input: {
+    readonly cwd: string;
+    readonly agent: string;
+    readonly model?: string;
+    readonly prompt: string;
+    readonly sessionId?: string;
+    readonly permission?: WorkflowPermissionMode;
+}) => ReadonlyArray<string>;
 export declare const runOpenCodeWorkflowTask: (task: AnyWorkflowTask, options: OpenCodeWorkflowWorkerOptions) => Promise<WorkflowTaskExecution>;

package/types/workflow-output-schema.d.ts

@@ -0,0 +1,7 @@
+import { Schema } from "effect";
+export type WorkflowJsonSchema = Record<string, unknown>;
+export declare class WorkflowOutputSchemaError extends Error {
+    readonly name = "WorkflowOutputSchemaError";
+}
+export declare const workflowJsonSchemaFromEffectSchema: (schema: Schema.Schema.AnyNoContext) => WorkflowJsonSchema;
+export declare const tryWorkflowJsonSchemaFromEffectSchema: (schema: Schema.Schema.AnyNoContext) => WorkflowJsonSchema | undefined;

package/types/workflow-permissions.d.ts

@@ -0,0 +1,10 @@
+import type { WorkflowPermissionMode } from "./workflows.js";
+export declare const WORKFLOW_PERMISSION_MODES: readonly ["legacy", "permissive", "restricted", "interactive", "sandbox-read-only", "sandbox-workspace-write", "full-access"];
+export declare const isWorkflowPermissionMode: (value: string) => value is WorkflowPermissionMode;
+export declare const assertNeverWorkflowPermissionMode: (worker: string, mode: never) => never;
+export declare class WorkflowPermissionError extends Error {
+    readonly worker: string;
+    readonly mode: string;
+    readonly name = "WorkflowPermissionError";
+    constructor(worker: string, mode: string, message: string);
+}

package/types/workflow-runner.d.ts

@@ -1,5 +1,6 @@
 import { type AnyWorkflowDefinition, type AnyWorkflowTask, type WorkflowRuntimeOptions } from "./workflows.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>;
@@ -20,41 +21,36 @@ export interface WorkflowRunResult {
     readonly tasks: ReadonlyArray<WorkflowRunTaskResult>;
     readonly output?: unknown;
 }
-export declare class WorkflowTaskDecodeError extends Error {
-    readonly taskId: string;
-    readonly cause: unknown;
-    readonly name = "WorkflowTaskDecodeError";
-    constructor(taskId: string, cause: unknown);
-}
-export declare class WorkflowRunStoppedError extends Error {
-    readonly runId: string;
-    readonly name = "WorkflowRunStoppedError";
-    constructor(runId: string);
-}
-export declare class WorkflowTaskEscalatedError extends Error {
-    readonly taskId: string;
-    readonly criterion: string;
-    readonly feedback?: string | undefined;
-    readonly name = "WorkflowTaskEscalatedError";
-    constructor(taskId: string, criterion: string, feedback?: string | undefined);
-}
+export { WorkflowRunStoppedError, WorkflowTaskDecodeError, WorkflowTaskEscalatedError, type WorkflowRuntimeError, } from "./workflow-errors.js";
 export type WorkflowTaskRepairMode = "native-continuation" | "fresh-executor-invocation" | "none";
-export interface WorkflowTaskRepairContext {
+export type WorkflowTaskRepairFallbackReason = "adapter-does-not-support-continuation" | "executor-does-not-advertise-continuation" | "missing-session-id";
+interface WorkflowTaskRepairContextBase {
     readonly attempt: number;
     readonly criterion: string;
     readonly repairPrompt: string;
-    readonly mode: Exclude<WorkflowTaskRepairMode, "none">;
     readonly previousMetadata?: Record<string, unknown>;
-    readonly fallbackReason?: "adapter-does-not-support-continuation" | "executor-does-not-advertise-continuation" | "missing-session-id";
-    readonly continuation?: {
-        readonly adapter: string;
-        readonly sessionId: string;
-    };
 }
+export type WorkflowTaskRepairContext = WorkflowTaskRepairContextBase & ({
+    readonly mode: "native-continuation";
+    readonly continuation: WorkflowStableSession;
+    readonly fallbackReason?: never;
+} | {
+    readonly mode: "fresh-executor-invocation";
+    readonly fallbackReason: WorkflowTaskRepairFallbackReason;
+    readonly continuation?: never;
+});
 export interface WorkflowTaskExecutionContext {
     readonly abortSignal?: AbortSignal;
     readonly repair?: WorkflowTaskRepairContext;
 }
+export interface WorkflowTaskExecutionContextWithoutRepair {
+    readonly abortSignal?: AbortSignal;
+}
+export type WorkflowTaskRepairLoopOption<Worker extends string> = Worker extends WorkflowRepairLoopContinuationWorkerId ? {
+    readonly repair?: WorkflowTaskRepairContext;
+} : {
+    readonly repair?: never;
+};
 export type WorkflowTaskExecutor = (task: AnyWorkflowTask, context?: WorkflowTaskExecutionContext) => Promise<unknown | WorkflowTaskExecution>;
 export declare const DEFAULT_WORKFLOW_TASK_CONCURRENCY = 8;
 export declare const runWorkflow: (workflow: AnyWorkflowDefinition, options: {

package/types/workflow-session.d.ts

@@ -0,0 +1,126 @@
+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 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 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"]>;
+    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"]>;
+    workflowWorker: typeof Schema.Boolean;
+    stableSessionIds: Schema.Literal<[true]>;
+    exactSameSessionContinuation: Schema.Literal<[true]>;
+    sessionIdField: Schema.Literal<["sessionId"]>;
+    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"]>;
+    workflowWorker: typeof Schema.Boolean;
+    stableSessionIds: Schema.Literal<[false]>;
+    exactSameSessionContinuation: Schema.Literal<[false]>;
+    sessionIdField: Schema.Literal<["sessionId"]>;
+    reason: typeof Schema.NonEmptyTrimmedString;
+}>]>;
+export type WorkflowHarnessContinuationSupport = typeof WorkflowHarnessContinuationSupportSchema.Type;
+export declare const workflowContinuationAdapterByWorker: {
+    readonly "amp-code": "amp-code";
+    readonly "antigravity-cli": "antigravity-cli";
+    readonly "claude-code": "claude-code";
+    readonly "codex-cli": "codex-cli";
+    readonly grok: "grok-cli";
+    readonly hermes: "hermes";
+    readonly "kimi-code": "kimi-code";
+    readonly opencode: "opencode-cli";
+};
+export type WorkflowRepairLoopContinuationWorkerId = keyof typeof workflowContinuationAdapterByWorker;
+export type WorkflowRepairLoopContinuationCapability = "stable-session-repair-loop" | "no-repair-loop-continuation";
+export type WorkflowRepairLoopContinuationCapabilityForWorker<Worker extends string> = Worker extends WorkflowRepairLoopContinuationWorkerId ? "stable-session-repair-loop" : "no-repair-loop-continuation";
+export declare const workflowHarnessContinuationSupport: {
+    readonly "amp-code": {
+        readonly adapter: "amp-code";
+        readonly workflowWorker: true;
+        readonly stableSessionIds: true;
+        readonly exactSameSessionContinuation: true;
+        readonly sessionIdField: "sessionId";
+        readonly continueCommand: "amp threads continue <sessionId> --execute <prompt>";
+        readonly capture: "stream-json session_id, local thread metadata, or threads list/search recovery";
+    };
+    readonly "antigravity-cli": {
+        readonly adapter: "antigravity-cli";
+        readonly workflowWorker: true;
+        readonly stableSessionIds: true;
+        readonly exactSameSessionContinuation: true;
+        readonly sessionIdField: "sessionId";
+        readonly continueCommand: "agy --conversation <sessionId> --print <prompt>";
+        readonly capture: "conversation id from agy print metadata, cache, database, or log recovery";
+    };
+    readonly "claude-code": {
+        readonly adapter: "claude-code";
+        readonly workflowWorker: true;
+        readonly stableSessionIds: true;
+        readonly exactSameSessionContinuation: true;
+        readonly sessionIdField: "sessionId";
+        readonly continueCommand: "claude --resume <sessionId> --print <prompt>";
+        readonly capture: "stream-json session_id";
+    };
+    readonly "codex-cli": {
+        readonly adapter: "codex-cli";
+        readonly workflowWorker: true;
+        readonly stableSessionIds: true;
+        readonly exactSameSessionContinuation: true;
+        readonly sessionIdField: "sessionId";
+        readonly continueCommand: "codex exec resume <sessionId> <prompt>";
+        readonly capture: "session_meta payload id, rollout JSONL, app-server metadata, or session index recovery";
+    };
+    readonly "grok-cli": {
+        readonly adapter: "grok-cli";
+        readonly workflowWorker: true;
+        readonly stableSessionIds: true;
+        readonly exactSameSessionContinuation: true;
+        readonly sessionIdField: "sessionId";
+        readonly continueCommand: "grok -r <sessionId> <prompt>";
+        readonly capture: "json sessionId, sessions list/search, or session export recovery";
+    };
+    readonly hermes: {
+        readonly adapter: "hermes";
+        readonly workflowWorker: true;
+        readonly stableSessionIds: true;
+        readonly exactSameSessionContinuation: true;
+        readonly sessionIdField: "sessionId";
+        readonly continueCommand: "hermes chat --resume <sessionId> --query <prompt>";
+        readonly capture: "chat stderr session_id";
+    };
+    readonly "kimi-code": {
+        readonly adapter: "kimi-code";
+        readonly workflowWorker: true;
+        readonly stableSessionIds: true;
+        readonly exactSameSessionContinuation: true;
+        readonly sessionIdField: "sessionId";
+        readonly continueCommand: "kimi --session <sessionId> --prompt <prompt>";
+        readonly capture: "stream-json session.resume_hint.session_id or session index recovery";
+    };
+    readonly "opencode-cli": {
+        readonly adapter: "opencode-cli";
+        readonly workflowWorker: true;
+        readonly stableSessionIds: true;
+        readonly exactSameSessionContinuation: true;
+        readonly sessionIdField: "sessionId";
+        readonly continueCommand: "opencode run -s <sessionId> <prompt>";
+        readonly capture: "json step_start sessionID, session list, export, database, or log recovery";
+    };
+};
+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;
+export declare const normalizeWorkflowSessionMetadata: (metadata: Record<string, unknown> | undefined) => Record<string, unknown> | undefined;
+export declare const stableSessionIdFromRecordKeys: (value: unknown, keys: ReadonlyArray<string>) => StableSessionId | undefined;
+export declare const stableSessionIdFromJsonLines: (text: string, keys?: ReadonlyArray<string>) => StableSessionId | undefined;
+export declare const stableSessionIdFromRegex: (text: string, patterns: ReadonlyArray<RegExp>) => StableSessionId | undefined;

package/types/workflow-store.d.ts

@@ -1,5 +1,5 @@
 import { Database } from "bun:sqlite";
-import type { AnyWorkflowTask, WorkflowJudgeVerdict, WorkflowRuntimeOptions } from "./workflows.js";
+import { type AnyWorkflowTask, type WorkflowJudgeVerdict, type WorkflowRuntimeOptions } from "./workflows.js";
 export interface WorkflowTaskIdentity {
     readonly workflow: string;
     readonly taskId: string;
@@ -45,6 +45,7 @@ export interface WorkflowJudgeRecord {
 export type WorkflowRunTaskStatus = "completed" | "failed" | "escalated";
 export interface WorkflowRunTaskRecord {
     readonly runId: string;
+    readonly ordinal: number;
     readonly taskId: string;
     readonly cacheKey: string;
     readonly status: WorkflowRunTaskStatus;
@@ -59,6 +60,7 @@ export interface WorkflowRunTaskRecord {
 export type WorkflowRunTaskProgressStatus = "running" | "completed" | "failed" | "escalated";
 export type WorkflowRunTaskCacheLookup = "hit" | "miss" | "skipped";
 export interface WorkflowRunTaskProgress {
+    readonly ordinal?: number;
     readonly taskId: string;
     readonly status: WorkflowRunTaskProgressStatus;
     readonly cacheKey?: string;
@@ -75,6 +77,7 @@ export interface WorkflowRunTaskProgress {
 export type WorkflowRunTaskExecutionSource = "cached" | "fresh" | "unknown";
 export type WorkflowRunTaskEvidenceSource = "this-run" | "prior-cache-record" | "run-events" | "unknown";
 export interface WorkflowRunTaskCompactSummary {
+    readonly ordinal?: number;
     readonly taskId: string;
     readonly status: WorkflowRunTaskProgressStatus;
     readonly execution: WorkflowRunTaskExecutionSource;
@@ -95,6 +98,63 @@ export interface WorkflowRunTaskCompactSummary {
     readonly lastEventType?: string;
     readonly lastEventAt?: string;
 }
+export interface WorkflowRunSnapshot {
+    readonly runId: string;
+    readonly workflowFile: string;
+    readonly options?: Record<string, unknown>;
+    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;
+    readonly cacheKey?: string;
+    readonly prompt?: string;
+    readonly output?: unknown;
+    readonly metadata?: Record<string, unknown>;
+    readonly badges: ReadonlyArray<WorkflowCacheBadge>;
+    readonly snapshot?: WorkflowRunTaskSnapshot;
+}
+export interface WorkflowMonitorRun {
+    readonly run: WorkflowRunRecord;
+    readonly snapshot?: WorkflowRunSnapshot;
+    readonly totals: WorkflowRunCompactSummary["totals"];
+    readonly cacheBadges: ReadonlyArray<WorkflowCacheBadge>;
+}
+export interface WorkflowMonitorRunDetail extends WorkflowMonitorRun {
+    readonly tasks: ReadonlyArray<WorkflowMonitorTask>;
+    readonly events: ReadonlyArray<WorkflowEventRecord>;
+    readonly canUpdate: boolean;
+}
+export interface WorkflowMonitorState {
+    readonly runs: ReadonlyArray<WorkflowMonitorRun>;
+    readonly selectedRun: WorkflowMonitorRunDetail | null;
+}
 export interface WorkflowRunCompactSummary {
     readonly kind: "workflow-execution-evidence";
     readonly semanticCorrectness: "not-evaluated";
@@ -129,6 +189,13 @@ export interface WorkflowEventRecord {
 }
 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 class WorkflowStore {
     private readonly db;
     constructor(db: Database);
@@ -158,6 +225,14 @@ export declare class WorkflowStore {
         readonly agentManifestHash?: string;
     }): WorkflowCacheRecord[];
     createRun(workflow: string, runId?: string): string;
+    recordRunSnapshot(input: {
+        readonly runId: string;
+        readonly workflowFile: string;
+        readonly options?: Record<string, unknown>;
+    }): void;
+    getRunSnapshot(runId: string): WorkflowRunSnapshot | null;
+    recordRunTaskSnapshot(input: Omit<WorkflowRunTaskSnapshot, "createdAt">): void;
+    listRunTaskSnapshots(runId: string): WorkflowRunTaskSnapshot[];
     setRunHandoffToken(runId: string, token: string): void;
     consumeRunHandoffToken(runId: string, token: string): boolean;
     markRunRunnerStarted(runId: string, runnerPid: number): void;
@@ -201,6 +276,8 @@ export declare class WorkflowStore {
     listRunTasks(runId: string): WorkflowRunTaskRecord[];
     summarizeRunTasks(runId: string): WorkflowRunTaskProgress[];
     compactRunSummary(runId: string): WorkflowRunCompactSummary | null;
+    workflowMonitorState(selectedRunId?: string): WorkflowMonitorState;
+    workflowMonitorRunDetail(runId: string): WorkflowMonitorRunDetail | null;
     recordCompleted(input: {
         readonly identity: WorkflowTaskIdentity;
         readonly agent: {

package/types/workflow-tsconfig.d.ts

@@ -37,6 +37,14 @@ export interface WorkflowTypeDirs {
  * when the corresponding type surface cannot be located.
  */
 export declare const resolveWorkflowTypeDirs: () => WorkflowTypeDirs;
+/** Generated workflow ref modules under ~/.prism/state/projects/<key>/generated/. */
+export declare const WORKFLOW_REFS_MODULES: readonly ["agents", "models", "skills", "traits", "orbits", "tools"];
+export type WorkflowRefsModule = (typeof WORKFLOW_REFS_MODULES)[number];
+/**
+ * Build path mappings for every generated `prism/refs` module. `prism/refs`
+ * itself resolves to `agents.ts` because that is the primary import surface.
+ */
+export declare const buildWorkflowRefsPaths: (refsDir: string) => Record<string, string[]>;
 /**
  * Build the `compilerOptions.paths` map for typechecking a workflow file from
  * the resolved type dirs and (optionally) the project-keyed generated refs.
@@ -47,8 +55,8 @@ export declare const resolveWorkflowTypeDirs: () => WorkflowTypeDirs;
  */
 export declare const buildWorkflowPaths: (options: {
     readonly typeDirs: WorkflowTypeDirs;
-    /** Absolute path to the generated refs file (~/.../generated/agents.ts). */
-    readonly refsFile?: string;
+    /** Absolute path to the generated refs directory (~/.../generated/). */
+    readonly refsDir?: string;
 }) => Record<string, string[]>;
 export interface WorkflowTsconfigOptions {
     /**

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

@@ -5,6 +5,10 @@ export interface WorkflowWorkerProcessOptions {
     readonly abortSignal?: AbortSignal;
     readonly processTimeoutMs?: number;
     readonly env?: Record<string, string>;
+    readonly earlyExitPatterns?: ReadonlyArray<{
+        readonly name: string;
+        readonly pattern: RegExp;
+    }>;
 }
 export interface WorkflowWorkerProcessResult {
     readonly exitCode: number | null;
@@ -13,6 +17,7 @@ export interface WorkflowWorkerProcessResult {
     readonly durationMs: number;
     readonly timedOut: boolean;
     readonly aborted: boolean;
+    readonly earlyExit?: string;
 }
 export declare const parsePositiveInteger: (value: string | undefined) => number | undefined;
 export declare const workflowWorkerProcessExcerpt: (stdout: string, stderr: string) => string;

package/types/workflow-workers.d.ts

@@ -1,16 +1,25 @@
-import type { AnyWorkflowTask } from "./workflows.js";
-import type { WorkflowTaskExecution, WorkflowTaskExecutionContext, WorkflowTaskExecutor } from "./workflow-runner.js";
-export interface WorkflowWorkerAdapterOptions {
+import { type AnyWorkflowTask, type WorkflowPermissionMode, type WorkflowWorkerId } from "./workflows.js";
+import type { WorkflowTaskExecution, WorkflowTaskExecutionContext, WorkflowTaskExecutionContextWithoutRepair, WorkflowTaskExecutor } from "./workflow-runner.js";
+import { type WorkflowRepairLoopContinuationCapability, type WorkflowRepairLoopContinuationCapabilityForWorker } from "./workflow-session.js";
+export { WorkflowPermissionError } from "./workflow-permissions.js";
+export interface WorkflowWorkerAdapterOptionsBase {
     readonly cwd: string;
     readonly model?: string;
     readonly profile?: string;
+    readonly resolvedPermission: WorkflowPermissionMode;
+    readonly restrictedTools?: readonly string[];
+    readonly processTimeoutMs?: number;
     readonly abortSignal?: AbortSignal;
-    readonly context?: WorkflowTaskExecutionContext;
 }
-export interface WorkflowWorkerAdapter {
-    readonly id: string;
-    readonly runTask: (task: AnyWorkflowTask, options: WorkflowWorkerAdapterOptions) => Promise<WorkflowTaskExecution>;
-    readonly continueTask?: (task: AnyWorkflowTask, options: WorkflowWorkerAdapterOptions) => Promise<WorkflowTaskExecution>;
+export type WorkflowWorkerAdapterOptionsForCapability<Capability extends WorkflowRepairLoopContinuationCapability> = WorkflowWorkerAdapterOptionsBase & (Capability extends "stable-session-repair-loop" ? {
+    readonly context?: WorkflowTaskExecutionContext;
+} : {
+    readonly context?: WorkflowTaskExecutionContextWithoutRepair;
+});
+export type WorkflowWorkerAdapterOptions<Worker extends WorkflowWorkerId = WorkflowWorkerId> = WorkflowWorkerAdapterOptionsForCapability<WorkflowRepairLoopContinuationCapabilityForWorker<Worker>>;
+export interface WorkflowWorkerAdapter<Worker extends WorkflowWorkerId = WorkflowWorkerId> {
+    readonly id: Worker;
+    readonly runTask: (task: AnyWorkflowTask, options: WorkflowWorkerAdapterOptions<Worker>) => Promise<WorkflowTaskExecution>;
 }
 export declare class UnsupportedWorkflowWorkerError extends Error {
     readonly worker: string;
@@ -18,10 +27,17 @@ export declare class UnsupportedWorkflowWorkerError extends Error {
     readonly name = "UnsupportedWorkflowWorkerError";
     constructor(worker: string, supportedWorkers: ReadonlyArray<string>);
 }
+export declare class WorkflowWorkerContinuationError extends Error {
+    readonly name = "WorkflowWorkerContinuationError";
+}
 export declare const supportedWorkflowWorkers: () => ReadonlyArray<string>;
-export declare const getWorkflowWorkerAdapter: (worker: string) => WorkflowWorkerAdapter;
+export declare function getWorkflowWorkerAdapter<Worker extends WorkflowWorkerId>(worker: Worker): WorkflowWorkerAdapter<Worker>;
+export declare function getWorkflowWorkerAdapter(worker: string): WorkflowWorkerAdapter;
+export declare const resolveWorkflowTaskPermission: (task: AnyWorkflowTask, fallbackPermission?: WorkflowPermissionMode) => WorkflowPermissionMode;
 export declare const createWorkflowWorkerExecutor: (input: {
     readonly worker?: string;
     readonly cwd: string;
     readonly model?: string;
+    readonly fallbackPermission?: WorkflowPermissionMode;
+    readonly taskTimeoutMs?: number;
 }) => WorkflowTaskExecutor;

package/types/workflows.d.ts

@@ -1,8 +1,14 @@
 import { Effect, Schema } from "effect";
+import type { Either } from "effect/Either";
+import type { ParseError } from "effect/ParseResult";
+import type { WorkflowRuntimeError } from "./workflow-errors.js";
+export type { WorkflowRuntimeError } from "./workflow-errors.js";
 export interface WorkflowModelRef {
     readonly modelspace?: string;
     readonly profile?: string;
+    readonly targets?: Readonly<Record<string, WorkflowModelTarget>>;
 }
+export type WorkflowModelTarget = Readonly<Record<string, unknown>>;
 export interface WorkflowModelspaceRef {
     readonly kind: "modelspace-ref";
     readonly plugin: string;
@@ -13,6 +19,7 @@ export interface WorkflowModelProfileRef {
     readonly plugin: string;
     readonly modelspace: string;
     readonly profile: string;
+    readonly targets?: Readonly<Record<string, WorkflowModelTarget>>;
 }
 export interface WorkflowManagedSkillRef {
     readonly kind: "managed-skill-ref";
@@ -36,12 +43,35 @@ export interface WorkflowAgentRef {
     readonly installs: ReadonlyArray<string>;
 }
 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 interface WorkflowTaskWorkerOptions {
-    readonly worker?: WorkflowWorkerId;
-    readonly model?: string;
+export type WorkflowPermissionMode = "legacy" | "permissive" | "restricted" | "interactive" | "sandbox-read-only" | "sandbox-workspace-write" | "full-access";
+export type AntigravityWorkflowPermissionMode = Extract<WorkflowPermissionMode, "legacy" | "permissive" | "full-access">;
+type WorkflowTaskWorkerOptionsBase = {
+    readonly model?: string | WorkflowModelProfileRef;
+    readonly modelResolver?: (models: WorkflowResolvedModelTarget) => string;
     readonly profile?: string;
-}
+    readonly restrictedTools?: ReadonlyArray<string>;
+    readonly processTimeoutMs?: number;
+};
+export type WorkflowTaskWorkerOptions = (WorkflowTaskWorkerOptionsBase & {
+    readonly worker?: Exclude<WorkflowWorkerId, "antigravity-cli">;
+    readonly permission?: WorkflowPermissionMode;
+}) | (WorkflowTaskWorkerOptionsBase & {
+    readonly worker: "antigravity-cli";
+    readonly permission?: AntigravityWorkflowPermissionMode;
+});
+export type WorkflowResolvedModelEntry = Readonly<{
+    readonly model: string;
+}>;
+export type WorkflowResolvedModelTarget = Readonly<Record<string, WorkflowResolvedModelEntry | WorkflowResolvedModelEntry[]>>;
+export declare class WorkflowModelResolutionError extends Error {
+    readonly name = "WorkflowModelResolutionError";
+}
+export declare const resolveWorkflowTaskModel: (task: AnyWorkflowTask, options?: {
+    readonly worker?: string;
+    readonly fallbackModel?: string;
+}) => string | undefined;
 export interface WorkflowFinishCriterionContext<Output> {
     readonly output: Output;
     readonly rawOutput: unknown;
@@ -50,7 +80,7 @@ export interface WorkflowFinishCriterionContext<Output> {
 export interface WorkflowDeterministicFinishCriterion<Output> {
     readonly kind?: "deterministic";
     readonly name: string;
-    readonly check: (context: WorkflowFinishCriterionContext<Output>) => Effect.Effect<void, unknown>;
+    readonly check: (context: WorkflowFinishCriterionContext<Output>) => Effect.Effect<void, WorkflowFinishCriterionError>;
     readonly repairPrompt?: (error: unknown, context: WorkflowFinishCriterionContext<Output>) => string;
 }
 export type WorkflowJudgeVerdict = {
@@ -93,7 +123,7 @@ export interface WorkflowJudgeFinishCriterion<Output, Evidence = unknown> {
     readonly name: string;
     readonly goal?: string | ((context: Omit<WorkflowJudgeEvidenceSelectionContext<Output>, "goal">) => string);
     readonly selectEvidence?: (context: WorkflowJudgeEvidenceSelectionContext<Output>) => Evidence;
-    readonly evaluate: (context: WorkflowJudgeCriterionContext<Output, Evidence>) => Effect.Effect<WorkflowJudgeVerdict, unknown>;
+    readonly evaluate: (context: WorkflowJudgeCriterionContext<Output, Evidence>) => Effect.Effect<WorkflowJudgeVerdict, WorkflowFinishCriterionError>;
 }
 export type WorkflowFinishCriterion<Output> = WorkflowDeterministicFinishCriterion<Output> | WorkflowJudgeFinishCriterion<Output>;
 export interface WorkflowFinishOptions<Output> {
@@ -105,6 +135,7 @@ export interface WorkflowTaskDefinition<Id extends string, Agent extends Workflo
     readonly agent: Agent;
     readonly prompt: string;
     readonly output: Output;
+    readonly phase?: string;
     readonly cacheKey?: string;
     readonly worker?: WorkflowTaskWorkerOptions;
     readonly finish?: WorkflowFinishOptions<Schema.Schema.Type<Output>>;
@@ -120,17 +151,18 @@ export interface WorkflowDefinition<Name extends string, Tasks extends ReadonlyA
     readonly tasks: Tasks;
 }
 export interface WorkflowRuntime {
-    runTask: <Task extends AnyWorkflowTask>(task: Task) => Effect.Effect<WorkflowTaskOutput<Task>, unknown>;
+    runTask: <Task extends AnyWorkflowTask>(task: Task) => Effect.Effect<WorkflowTaskOutput<Task>, WorkflowRuntimeError>;
 }
 export interface WorkflowRuntimeOptions {
     readonly fallbackWorker?: string;
     readonly fallbackModel?: string;
+    readonly fallbackPermission?: WorkflowPermissionMode;
 }
-export interface DynamicWorkflowDefinition<Name extends string> {
+export interface DynamicWorkflowDefinition<Name extends string, Result = unknown, Err = WorkflowRuntimeError> {
     readonly kind: "workflow";
     readonly name: Name;
     readonly tasks: readonly [];
-    readonly run: (runtime: WorkflowRuntime) => Effect.Effect<unknown, unknown>;
+    readonly run: (runtime: WorkflowRuntime) => Effect.Effect<Result, Err, never>;
 }
 export type AnyWorkflowDefinition = WorkflowDefinition<string, ReadonlyArray<AnyWorkflowTask>> | DynamicWorkflowDefinition<string>;
 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>;
@@ -138,8 +170,8 @@ export declare function defineWorkflow<const Name extends string, const Tasks ex
     readonly name: Name;
     readonly tasks: Tasks;
 }): WorkflowDefinition<Name, Tasks>;
-export declare function defineWorkflow<const Name extends string>(definition: {
+export declare function defineWorkflow<const Name extends string, Result, Err = WorkflowRuntimeError>(definition: {
     readonly name: Name;
-    readonly run: (runtime: WorkflowRuntime) => Effect.Effect<unknown, unknown>;
-}): DynamicWorkflowDefinition<Name>;
-export declare const decodeTaskOutput: <Task extends AnyWorkflowTask>(task: Task, value: unknown) => import("effect/Either").Either<any, import("effect/ParseResult").ParseError>;
+    readonly run: (runtime: WorkflowRuntime) => Effect.Effect<Result, Err, never>;
+}): DynamicWorkflowDefinition<Name, Result, Err>;
+export declare const decodeTaskOutput: <Task extends AnyWorkflowTask>(task: Task, value: unknown) => Either<Schema.Schema.Type<Task["output"]>, ParseError>;