@skastr0/prism-darwin-x64 0.1.2 → 0.2.0

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,13 +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

@@ -4,6 +4,11 @@ export interface WorkflowWorkerProcessOptions {
     readonly cwd: string;
     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;
@@ -12,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;