@skastr0/prism-linux-arm64 0.1.2 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skastr0/prism-linux-arm64",
-  "version": "0.1.2",
+  "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/authoring-runtime.d.ts

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

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

@@ -1,8 +1,10 @@
 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;
 export declare const generatedOwnerToolName: (toolPluginName: string, toolName: string) => string;
 export declare const generatedSyntheticToolName: (sourcePluginName: string, contractName: string) => string;
+export declare const generatedPluginIdForOwner: (ownerPluginName: string) => string;
 export declare const generatedToolNameForBinding: (sourcePluginName: string, binding: ResolvedContractBinding) => string;
 export declare const sourceIsInside: (sourcePath: string, root: string) => boolean;

package/types/compile/load.d.ts

@@ -18,6 +18,35 @@ export interface PrepareImportWrapperOptions {
 }
 export declare const prepareImportWrapper: (sourcePath: string, options?: PrepareImportWrapperOptions) => Promise<{
     readonly specifier: string;
+    readonly transformedPath: string;
+    readonly cleanup: () => Promise<void>;
+}>;
+/**
+ * Prepare a plugin source file for bundling by `bun build`.
+ *
+ * Unlike `prepareImportWrapper`, which produces `file:///` specifiers suitable
+ * for runtime `import()`, this helper produces absolute POSIX paths so the
+ * bundler can resolve `prism`/`effect` imports without relying on ambient
+ * `node_modules`. The transformed plugin root is cached and cleaned up the
+ * same way as `prepareImportWrapper`.
+ */
+export declare const prepareBundleSource: (sourcePath: string) => Promise<{
+    readonly transformedPath: string;
+    readonly cleanup: () => Promise<void>;
+}>;
+/**
+ * Prepare a plugin source file for bundling into an executable hook wrapper.
+ *
+ * Unlike `prepareBundleSource`, which rewrites `prism` to the compile-time
+ * authoring runtime stub, this helper rewrites `prism` to the real Prism source
+ * entry so the bundled hook can execute. `effect` is rewritten to the same
+ * runtime Effect module used by the wrapper, preventing duplicate Effect
+ * instances. Absolute imports that point back at the local Prism source entry
+ * (common in test fixtures and local helper files) are normalized to bare
+ * `prism` first.
+ */
+export declare const prepareHookBundleSource: (sourcePath: string) => Promise<{
+    readonly transformedPath: string;
     readonly cleanup: () => Promise<void>;
 }>;
 export declare const loadPlugin: (pluginPath: string) => Effect.Effect<PluginRegistry, CompileError>;

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

@@ -38,7 +38,6 @@ export interface PluginRuntimeMcpHarnessConfig {
     transport?: PrismMcpTransport;
     host?: string;
     port?: number;
-    tokenEnv?: string;
     connectTimeoutMs?: number;
     toolTimeoutMs?: number;
 }
@@ -53,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";