@skastr0/prism-linux-x64 0.7.1 → 0.8.0

package/types/types.d.ts

@@ -1,7 +1,7 @@
 /**
  * Core types for prism - the unified plugin distribution system
  */
-export type HarnessId = "claude-code" | "opencode" | "opencode2" | "openclaw" | "hermes" | "codex-cli" | "antigravity-cli" | "kimi-code" | "amp-code" | "amp-orb" | "cursor" | "factory-droid" | "pi" | "omp" | "grok" | "devin";
+export type HarnessId = "claude-code" | "opencode" | "hermes" | "codex-cli" | "antigravity-cli" | "kimi-code" | "amp-code" | "amp-orb" | "amp-runner" | "cursor" | "pi" | "omp" | "grok" | "devin";
 export declare const HARNESS_SCOPES: readonly ["global", "project"];
 export type HarnessScope = (typeof HARNESS_SCOPES)[number];
 export interface HarnessConfig {
@@ -120,15 +120,6 @@ export interface CursorFrontmatter {
     globs?: string[];
     alwaysApply?: boolean;
 }
-export interface FactoryDroidFrontmatter {
-    description?: string;
-    model?: string | "inherit";
-    reasoningEffort?: "low" | "medium" | "high";
-    tools?: string | string[];
-    "user-invocable"?: boolean;
-    "disable-model-invocation"?: boolean;
-    "argument-hint"?: string;
-}
 export interface CodexCliFrontmatter {
     description?: string;
     model?: string;
@@ -139,16 +130,14 @@ export interface UnifiedFrontmatter {
     description?: string;
     "claude-code"?: ClaudeCodeFrontmatter;
     opencode?: OpenCodeAgentFrontmatter;
-    opencode2?: OpenCodeAgentFrontmatter;
-    openclaw?: Record<string, unknown>;
     hermes?: Record<string, unknown>;
     "codex-cli"?: CodexCliFrontmatter;
     "antigravity-cli"?: Record<string, unknown>;
     "kimi-code"?: Record<string, unknown>;
     "amp-code"?: Record<string, unknown>;
     "amp-orb"?: Record<string, unknown>;
+    "amp-runner"?: Record<string, unknown>;
     cursor?: CursorFrontmatter;
-    "factory-droid"?: FactoryDroidFrontmatter;
     pi?: Record<string, unknown>;
     omp?: Record<string, unknown>;
     grok?: Record<string, unknown>;

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

@@ -0,0 +1,69 @@
+import { type AmpOrbSize, type AmpRemoteWorkflowWorkerId, type AmpThreadVisibility, type AnyWorkflowWorkerTask, type WorkflowPermissionMode } from "./workflows.js";
+import { type AmpCatalogPinPlan } from "./workflow-amp-worker.js";
+import type { WorkflowTaskExecution, WorkflowTaskProgressReporter, WorkflowTaskRepairLoopOption } from "./workflow-runner.js";
+export interface AmpOrbTarget {
+    readonly worker: "amp-orb";
+    readonly project: string;
+    readonly size?: AmpOrbSize;
+    readonly visibility?: AmpThreadVisibility;
+    readonly labels?: ReadonlyArray<string>;
+}
+export interface AmpRunnerTarget {
+    readonly worker: "amp-runner";
+    readonly runnerId: string;
+    readonly runnerDir?: string;
+    readonly labels?: ReadonlyArray<string>;
+}
+export type AmpRemoteTarget = AmpOrbTarget | AmpRunnerTarget;
+export type AmpRemoteWorkflowWorkerOptions<W extends AmpRemoteWorkflowWorkerId = AmpRemoteWorkflowWorkerId> = {
+    readonly cwd: string;
+    readonly bin?: string;
+    readonly model?: string;
+    readonly resolvedPermission: WorkflowPermissionMode;
+    readonly abortSignal?: AbortSignal;
+    readonly reportProgress?: WorkflowTaskProgressReporter;
+} & WorkflowTaskRepairLoopOption<W>;
+/** Remote executors accept only `legacy`: no per-invocation override reaches the remote amp process. */
+export declare const assertAmpRemotePermission: (worker: AmpRemoteWorkflowWorkerId, mode: WorkflowPermissionMode) => void;
+/**
+ * Read the remote target from the task's own worker options. The DSL types make
+ * these fields required; this check covers untyped workflow files and a
+ * CLI-only `--worker amp-orb` fallback, which carries no target.
+ */
+export declare const ampRemoteTargetOf: (worker: AmpRemoteWorkflowWorkerId, task: AnyWorkflowWorkerTask) => AmpRemoteTarget;
+/**
+ * The Prism catalog-pin plugin is written under the local cwd. It exists for
+ * the remote executor only when a runner serves exactly that directory.
+ */
+export declare const resolveAmpRemotePinPlan: (input: {
+    readonly target: AmpRemoteTarget;
+    readonly cwd: string;
+    readonly mode?: string;
+    readonly catalogModel?: string;
+    readonly effort?: string;
+}) => AmpCatalogPinPlan;
+/** New orb thread, attached until the turn ends. */
+export declare const buildAmpOrbArgs: (input: {
+    readonly target: AmpOrbTarget;
+    readonly prompt: string;
+    readonly title?: string;
+    readonly mode?: string;
+}) => ReadonlyArray<string>;
+/** New runner thread, attached until the turn ends. */
+export declare const buildAmpRunnerArgs: (input: {
+    readonly target: AmpRunnerTarget;
+    readonly prompt: string;
+    readonly title?: string;
+    readonly mode?: string;
+    readonly pluginReadyTimeout?: boolean;
+}) => ReadonlyArray<string>;
+/**
+ * Same-thread repair. `--orb-execute` sends the message to the thread's own
+ * remote executor (orb or runner); `--executor`/`--runner-dir` do not apply.
+ */
+export declare const buildAmpRemoteContinueArgs: (input: {
+    readonly sessionId: string;
+    readonly prompt: string;
+}) => ReadonlyArray<string>;
+export declare const runAmpOrbWorkflowTask: (task: AnyWorkflowWorkerTask, options: AmpRemoteWorkflowWorkerOptions<"amp-orb">) => Promise<WorkflowTaskExecution>;
+export declare const runAmpRunnerWorkflowTask: (task: AnyWorkflowWorkerTask, options: AmpRemoteWorkflowWorkerOptions<"amp-runner">) => Promise<WorkflowTaskExecution>;

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

@@ -0,0 +1,89 @@
+import type { HarnessTypesSnapshot } from "./harness-types.js";
+import type { AnyWorkflowWorkerTask, WorkflowPermissionMode } from "./workflows.js";
+import type { WorkflowTaskExecution, WorkflowTaskProgressReporter, WorkflowTaskRepairLoopOption } from "./workflow-runner.js";
+export declare const AMP_WORKFLOW_DIAL_MODES: readonly ["low", "medium", "high", "ultra"];
+export type AmpWorkflowDialMode = (typeof AMP_WORKFLOW_DIAL_MODES)[number];
+export declare const AMP_WORKFLOW_CATALOG_PIN_MODE = "prism-pin";
+export declare const AMP_WORKFLOW_CATALOG_PIN_FILENAME = "prism-workflow-catalog-pin.ts";
+export type AmpWorkflowWorkerOptions = {
+    readonly cwd: string;
+    readonly bin?: string;
+    readonly model?: string;
+    readonly catalogModel?: string;
+    readonly effort?: string;
+    readonly resolvedPermission: WorkflowPermissionMode;
+    readonly abortSignal?: AbortSignal;
+    readonly reportProgress?: WorkflowTaskProgressReporter;
+} & WorkflowTaskRepairLoopOption<"amp-code">;
+export declare class AmpWorkflowWorkerError extends Error {
+    readonly name = "AmpWorkflowWorkerError";
+    readonly metadata?: Record<string, unknown>;
+    constructor(message: string, metadata?: Record<string, unknown>);
+}
+export declare const assertAmpWorkflowMode: (mode: string | undefined) => string | undefined;
+export declare const isAmpWorkflowDialMode: (mode: string | undefined) => mode is AmpWorkflowDialMode;
+export type AmpCatalogPinPlan = {
+    readonly kind: "mode";
+    readonly mode?: string;
+} | {
+    readonly kind: "pin";
+    readonly mode: typeof AMP_WORKFLOW_CATALOG_PIN_MODE;
+    readonly catalogModel?: string;
+    readonly effort?: string;
+    readonly extendsMode?: AmpWorkflowDialMode;
+};
+export declare const resolveAmpCatalogPinPlan: (input: {
+    readonly mode?: string;
+    readonly catalogModel?: string;
+    readonly effort?: string;
+}) => AmpCatalogPinPlan;
+export declare const ampCatalogPinPluginPath: (cwd: string) => string;
+/** Reuse a project plugin mode that already pins this catalog slug (and effort, if set). */
+export declare const findExistingAmpCatalogMode: (cwd: string, input: {
+    readonly catalogModel?: string;
+    readonly effort?: string;
+}) => Promise<string | undefined>;
+export declare const ampWorkerPins: (task: AnyWorkflowWorkerTask) => {
+    readonly catalogModel?: string;
+    readonly effort?: string;
+};
+/** Fail closed when a snapshot lists the catalog row and effort is not on that row. */
+export declare const validateAmpCatalogPins: (task: AnyWorkflowWorkerTask, snapshot: HarnessTypesSnapshot | undefined) => string | undefined;
+/** User-facing Amp pin fields. Never report the transport mode `prism-pin` as the model. */
+export declare const ampWorkflowHonestMetadata: (input: {
+    readonly pin: AmpCatalogPinPlan;
+    readonly authoredModel?: string;
+    readonly catalogModel?: string;
+    readonly effort?: string;
+}) => {
+    readonly model?: string;
+    readonly ampMode?: string;
+    readonly catalogModel?: string;
+    readonly effort?: string;
+};
+export declare const renderAmpCatalogPinPlugin: (input: {
+    readonly catalogModel?: string;
+    readonly effort?: string;
+    readonly extendsMode?: AmpWorkflowDialMode;
+}) => string;
+export declare const prepareAmpCatalogPin: (cwd: string, plan: AmpCatalogPinPlan) => Promise<{
+    readonly cleanup: () => Promise<void>;
+}>;
+export declare const assertAmpPermission: (mode: WorkflowPermissionMode) => void;
+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;
+    /** Wait for the catalog-pin plugin to register before execute starts. */
+    readonly pluginReadyTimeout?: boolean;
+}) => ReadonlyArray<string>;
+export declare const parseAmpStreamJsonResult: (stdout: string) => string | undefined;
+export declare const parseAmpStreamJsonError: (stdout: string) => string | undefined;
+export declare const ampSessionId: (stdout: string, stderr: string) => string | undefined;
+export declare const runAmpWorkflowTask: (task: AnyWorkflowWorkerTask, options: AmpWorkflowWorkerOptions) => Promise<WorkflowTaskExecution>;

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

@@ -0,0 +1,22 @@
+import { type WorkflowWorkerProcessOptions, type 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

@@ -0,0 +1,84 @@
+import type { AntigravityWorkflowPermissionMode, AnyWorkflowWorkerTask, WorkflowPermissionMode } from "./workflows.js";
+import type { WorkflowTaskExecution, WorkflowTaskProgressReporter, 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_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 effort?: string;
+    readonly resolvedPermission: AntigravityWorkflowPermissionMode;
+    readonly abortSignal?: AbortSignal;
+    readonly reportProgress?: WorkflowTaskProgressReporter;
+    /** Override the default retry budget. Mostly useful in tests. */
+    readonly maxAttempts?: number;
+    /** Override the default retry backoff. Mostly useful in tests. */
+    readonly backoffMs?: number;
+    /** Disable the executable capability probe. Tests with minimal fake binaries only. */
+    readonly preflight?: boolean;
+} & WorkflowTaskRepairLoopOption<"antigravity-cli">;
+export declare class AntigravityWorkflowWorkerError extends Error {
+    readonly name = "AntigravityWorkflowWorkerError";
+    readonly metadata?: Record<string, unknown>;
+    constructor(message: string, metadata?: Record<string, unknown>);
+}
+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 AgyEffortArgs = readonly ["--effort", AgyValue<"effort">];
+type AgyOptionalModelArgs = readonly [] | AgyModelArgs;
+type AgyOptionalEffortArgs = readonly [] | AgyEffortArgs;
+type AgyRequiredPrintArgs = readonly [
+    ...AgyPermissionArgs,
+    ...AgyTimeoutArgs,
+    ...AgyWorkspaceArgs,
+    ...AgyOptionalModelArgs,
+    ...AgyOptionalEffortArgs,
+    "--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 assertAntigravityWorkflowCapabilities: (helpText: 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 effort?: 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: AnyWorkflowWorkerTask, options: AntigravityWorkflowWorkerOptions) => Promise<WorkflowTaskExecution>;
+export {};

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

@@ -36,4 +36,6 @@ export interface WorkflowBunRuntime {
     spawn(options: WorkflowBunPipedSpawnOptions): WorkflowBunPipedSpawnedProcess;
 }
 export declare const workflowBunRuntime: (capability: string) => WorkflowBunRuntime;
+/** Parse harness-owned TOML from the Bun-only workflow runtime boundary. */
+export declare const parseWorkflowToml: (source: string, capability: string) => unknown;
 export {};

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

@@ -0,0 +1,36 @@
+import { type AnyWorkflowWorkerTask, type WorkflowPermissionMode, type WorkflowSessionPersistence } from "./workflows.js";
+import { type WorkflowJsonSchema } from "./workflow-output-schema.js";
+import type { WorkflowTaskExecution, WorkflowTaskProgressReporter, WorkflowTaskRepairLoopOption } from "./workflow-runner.js";
+export type ClaudeWorkflowWorkerOptions = {
+    readonly cwd: string;
+    readonly bin?: string;
+    readonly model?: string;
+    readonly effort?: string;
+    readonly sessionPersistence?: WorkflowSessionPersistence;
+    readonly resolvedPermission: WorkflowPermissionMode;
+    readonly restrictedTools?: readonly string[];
+    readonly abortSignal?: AbortSignal;
+    readonly reportProgress?: WorkflowTaskProgressReporter;
+} & WorkflowTaskRepairLoopOption<"claude-code">;
+export declare class ClaudeWorkflowWorkerError extends Error {
+    readonly name = "ClaudeWorkflowWorkerError";
+    readonly metadata?: Record<string, unknown>;
+    constructor(message: string, metadata?: Record<string, unknown>);
+}
+type ClaudeWorkflowSessionArgs = {
+    readonly sessionPersistence?: "persistent";
+    readonly resumeSessionId?: string;
+} | {
+    readonly sessionPersistence: "ephemeral";
+    readonly resumeSessionId?: never;
+};
+export declare const buildClaudeArgs: (input: {
+    readonly model?: string;
+    readonly effort?: string;
+    readonly prompt: string;
+    readonly outputSchema?: WorkflowJsonSchema;
+    readonly permission?: WorkflowPermissionMode;
+    readonly restrictedTools?: readonly string[];
+} & ClaudeWorkflowSessionArgs) => ReadonlyArray<string>;
+export declare const runClaudeWorkflowTask: (task: AnyWorkflowWorkerTask, options: ClaudeWorkflowWorkerOptions) => Promise<WorkflowTaskExecution>;
+export {};

package/types/workflow-cli-command.d.ts

@@ -0,0 +1 @@
+export declare const currentCliCommand: () => string[];

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

@@ -0,0 +1,36 @@
+import type { AnyWorkflowWorkerTask, WorkflowPermissionMode, WorkflowSessionPersistence } from "./workflows.js";
+import type { WorkflowTaskExecution, WorkflowTaskProgressReporter, WorkflowTaskRepairLoopOption } from "./workflow-runner.js";
+export type CodexWorkflowWorkerOptions = {
+    readonly cwd: string;
+    readonly bin?: string;
+    readonly model?: string;
+    readonly effort?: string;
+    readonly sessionPersistence?: WorkflowSessionPersistence;
+    readonly resolvedPermission: WorkflowPermissionMode;
+    readonly abortSignal?: AbortSignal;
+    readonly reportProgress?: WorkflowTaskProgressReporter;
+} & WorkflowTaskRepairLoopOption<"codex-cli">;
+export declare class CodexWorkflowWorkerError extends Error {
+    readonly name = "CodexWorkflowWorkerError";
+    readonly metadata?: Record<string, unknown>;
+    constructor(message: string, metadata?: Record<string, unknown>);
+}
+type CodexWorkflowSessionArgs = {
+    readonly sessionPersistence?: "persistent";
+    readonly resumeSessionId?: string;
+} | {
+    readonly sessionPersistence: "ephemeral";
+    readonly resumeSessionId?: never;
+};
+export declare const buildCodexArgs: (input: {
+    readonly cwd: string;
+    readonly model?: string;
+    readonly effort?: string;
+    readonly outputSchemaPath?: string;
+    readonly outputPath: string;
+    readonly prompt: string;
+    readonly permission?: WorkflowPermissionMode;
+} & CodexWorkflowSessionArgs) => ReadonlyArray<string>;
+export declare const codexSessionId: (stdout: string, stderr: string) => string | undefined;
+export declare const runCodexWorkflowTask: (task: AnyWorkflowWorkerTask, options: CodexWorkflowWorkerOptions) => Promise<WorkflowTaskExecution>;
+export {};

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

@@ -0,0 +1,24 @@
+import type { AnyWorkflowWorkerTask, WorkflowPermissionMode } from "./workflows.js";
+import type { WorkflowTaskExecution, WorkflowTaskProgressReporter, WorkflowTaskRepairLoopOption } from "./workflow-runner.js";
+export type CursorWorkflowWorkerOptions = {
+    readonly cwd: string;
+    readonly bin?: string;
+    readonly model?: string;
+    readonly resolvedPermission: WorkflowPermissionMode;
+    readonly abortSignal?: AbortSignal;
+    readonly reportProgress?: WorkflowTaskProgressReporter;
+} & WorkflowTaskRepairLoopOption<"cursor">;
+export declare class CursorWorkflowWorkerError extends Error {
+    readonly name = "CursorWorkflowWorkerError";
+    readonly metadata?: Record<string, unknown>;
+    constructor(message: string, metadata?: Record<string, unknown>);
+}
+export declare const cursorSessionIdFromStream: (stdout: string) => string | undefined;
+export declare const buildCursorArgs: (input: {
+    readonly prompt: string;
+    readonly cwd: string;
+    readonly model?: string;
+    readonly resumeSessionId?: string;
+    readonly permission?: WorkflowPermissionMode;
+}) => ReadonlyArray<string>;
+export declare const runCursorWorkflowTask: (task: AnyWorkflowWorkerTask, options: CursorWorkflowWorkerOptions) => Promise<WorkflowTaskExecution>;

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

@@ -0,0 +1,25 @@
+import type { AnyWorkflowWorkerTask, WorkflowPermissionMode } from "./workflows.js";
+import type { WorkflowTaskExecution, WorkflowTaskProgressReporter, WorkflowTaskRepairLoopOption } from "./workflow-runner.js";
+export type DevinWorkflowWorkerOptions = {
+    readonly cwd: string;
+    readonly bin?: string;
+    readonly model?: string;
+    readonly resolvedPermission: WorkflowPermissionMode;
+    readonly abortSignal?: AbortSignal;
+    readonly reportProgress?: WorkflowTaskProgressReporter;
+} & WorkflowTaskRepairLoopOption<"devin">;
+export declare class DevinWorkflowWorkerError extends Error {
+    readonly name = "DevinWorkflowWorkerError";
+    readonly metadata?: Record<string, unknown>;
+    constructor(message: string, metadata?: Record<string, unknown>);
+}
+export declare const isDevinAuthOutput: (output: string) => boolean;
+export declare const mapDevinPermissionMode: (mode: WorkflowPermissionMode) => "auto" | "accept-edits" | "smart" | "dangerous" | undefined;
+export declare const buildDevinArgs: (input: {
+    readonly model?: string;
+    readonly permission?: WorkflowPermissionMode;
+    readonly sessionId?: string;
+    readonly promptFilePath: string;
+    readonly exportPath: string;
+}) => ReadonlyArray<string>;
+export declare const runDevinWorkflowTask: (task: AnyWorkflowWorkerTask, options: DevinWorkflowWorkerOptions) => Promise<WorkflowTaskExecution>;

package/types/workflow-effort.d.ts

@@ -0,0 +1,18 @@
+import type { HarnessTypesSnapshot } from "./harness-types.js";
+import type { HarnessId } from "./types.js";
+/**
+ * Values available to the authoring and named-worker contracts. Fixed CLI
+ * values come from the capability registry; catalog values come only from the
+ * installed per-model discovery snapshot.
+ */
+export declare const workflowEffortValues: (worker: HarnessId, snapshot?: HarnessTypesSnapshot) => readonly string[] | undefined;
+/** Validate one effective task effort against the capability and model cache. */
+export declare const validateWorkflowEffort: (input: {
+    readonly worker: HarnessId;
+    readonly effort?: string;
+    readonly model?: string;
+    readonly catalogModel?: string;
+    readonly snapshot?: HarnessTypesSnapshot;
+}) => string | undefined;
+/** Exact one-line migration diagnostic for legacy Codex/OMP modelspace entries. */
+export declare const legacyReasoningVariantError: (worker: string, target: unknown, location: string) => string | undefined;

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

@@ -0,0 +1,32 @@
+import type { AnyWorkflowWorkerTask, WorkflowPermissionMode } from "./workflows.js";
+import type { WorkflowTaskExecution, WorkflowTaskProgressReporter, WorkflowTaskRepairLoopOption } from "./workflow-runner.js";
+export type GrokWorkflowWorkerOptions = {
+    readonly cwd: string;
+    readonly bin?: string;
+    readonly model?: string;
+    readonly effort?: string;
+    readonly resolvedPermission: WorkflowPermissionMode;
+    readonly abortSignal?: AbortSignal;
+    readonly reportProgress?: WorkflowTaskProgressReporter;
+} & WorkflowTaskRepairLoopOption<"grok">;
+export declare class WorkflowWorkerError extends Error {
+    readonly name = "WorkflowWorkerError";
+    readonly metadata?: Record<string, unknown>;
+    constructor(message: string, metadata?: Record<string, unknown>);
+}
+export declare const isGrokAuthOutput: (output: string) => boolean;
+export declare const buildGrokArgs: (input: {
+    readonly cwd: string;
+    readonly model?: string;
+    readonly effort?: string;
+    readonly prompt: string;
+    readonly sessionId?: string;
+    readonly permission?: WorkflowPermissionMode;
+}) => ReadonlyArray<string>;
+interface GrokJsonRunOutput {
+    readonly sessionId?: string;
+    readonly text: string;
+}
+export declare const parseGrokJsonRunOutput: (stdout: string) => GrokJsonRunOutput;
+export declare const runGrokWorkflowTask: (task: AnyWorkflowWorkerTask, options: GrokWorkflowWorkerOptions) => Promise<WorkflowTaskExecution>;
+export { parseWorkflowWorkerJsonOutput, WorkflowOutputParseError } from "./workflow-worker-contract.js";

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

@@ -0,0 +1,28 @@
+import type { AnyWorkflowWorkerTask, WorkflowPermissionMode } from "./workflows.js";
+import type { WorkflowTaskExecution, WorkflowTaskProgressReporter, WorkflowTaskRepairLoopOption } from "./workflow-runner.js";
+export type HermesWorkflowWorkerOptions = {
+    readonly cwd: string;
+    readonly bin?: string;
+    readonly model?: string;
+    readonly provider?: string;
+    readonly profile?: string;
+    readonly effort?: string;
+    readonly resolvedPermission: WorkflowPermissionMode;
+    readonly abortSignal?: AbortSignal;
+    readonly reportProgress?: WorkflowTaskProgressReporter;
+} & WorkflowTaskRepairLoopOption<"hermes">;
+export declare class HermesWorkflowWorkerError extends Error {
+    readonly name = "HermesWorkflowWorkerError";
+    readonly metadata?: Record<string, unknown>;
+    constructor(message: string, metadata?: Record<string, unknown>);
+}
+export declare const buildHermesArgs: (input: {
+    readonly profile?: string;
+    readonly model?: string;
+    readonly provider?: string;
+    readonly effort?: string;
+    readonly prompt: string;
+    readonly resumeSessionId?: string;
+    readonly permission?: WorkflowPermissionMode;
+}) => ReadonlyArray<string>;
+export declare const runHermesWorkflowTask: (task: AnyWorkflowWorkerTask, options: HermesWorkflowWorkerOptions) => Promise<WorkflowTaskExecution>;

package/types/workflow-identity.d.ts

@@ -43,6 +43,7 @@ export interface WorkflowWorkerRunTaskSnapshot extends WorkflowRunTaskSnapshotBa
         readonly worker?: string;
         readonly model?: string;
         readonly profile?: string;
+        readonly effort?: string;
         readonly sessionPersistence?: WorkflowSessionPersistence;
     };
     readonly finishCriteria: ReadonlyArray<string>;

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

@@ -0,0 +1,17 @@
+export declare const kimiCodeHome: (home?: string) => string;
+export type KimiModelEffortSupport = {
+    readonly declared: false;
+} | {
+    readonly declared: true;
+    readonly efforts: readonly string[];
+} | {
+    readonly error: string;
+};
+/** Read one model's optional support_efforts entry from Kimi's config TOML. */
+export declare const parseKimiModelEffortSupport: (source: string, model: string, configPath?: string) => KimiModelEffortSupport;
+/** Validate Kimi's optional model-specific ladder after checking the fixed union. */
+export declare const validateKimiWorkflowEffort: (input: {
+    readonly model?: string;
+    readonly effort?: string;
+    readonly kimiHome?: string;
+}) => string | undefined;

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

@@ -0,0 +1,27 @@
+import type { AnyWorkflowWorkerTask, WorkflowPermissionMode } from "./workflows.js";
+import type { WorkflowTaskExecution, WorkflowTaskProgressReporter, WorkflowTaskRepairLoopOption } from "./workflow-runner.js";
+export type KimiWorkflowWorkerOptions = {
+    readonly cwd: string;
+    readonly bin?: string;
+    readonly model?: string;
+    readonly effort?: string;
+    readonly kimiHome?: string;
+    readonly resolvedPermission: WorkflowPermissionMode;
+    readonly abortSignal?: AbortSignal;
+    readonly reportProgress?: WorkflowTaskProgressReporter;
+} & WorkflowTaskRepairLoopOption<"kimi-code">;
+export declare class KimiWorkflowWorkerError extends Error {
+    readonly name = "KimiWorkflowWorkerError";
+    readonly metadata?: Record<string, unknown>;
+    constructor(message: string, metadata?: Record<string, unknown>);
+}
+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: AnyWorkflowWorkerTask, options: KimiWorkflowWorkerOptions) => Promise<WorkflowTaskExecution>;

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

@@ -0,0 +1,49 @@
+import type { AnyWorkflowWorkerTask, WorkflowPermissionMode, WorkflowSessionPersistence } from "./workflows.js";
+import type { WorkflowTaskExecution, WorkflowTaskProgressReporter, WorkflowTaskRepairLoopOption } from "./workflow-runner.js";
+export type OmpWorkflowWorkerOptions = {
+    readonly cwd: string;
+    readonly bin?: string;
+    readonly model?: string;
+    readonly provider?: string;
+    readonly profile?: string;
+    readonly effort?: string;
+    readonly sessionPersistence?: WorkflowSessionPersistence;
+    readonly resolvedPermission: WorkflowPermissionMode;
+    readonly restrictedTools?: readonly string[];
+    readonly abortSignal?: AbortSignal;
+    readonly reportProgress?: WorkflowTaskProgressReporter;
+} & WorkflowTaskRepairLoopOption<"omp">;
+export declare class OmpWorkflowWorkerError extends Error {
+    readonly name = "OmpWorkflowWorkerError";
+    readonly metadata?: Record<string, unknown>;
+    constructor(message: string, metadata?: Record<string, unknown>);
+}
+/** Console Go selectors 400 in workflow `--print` (no `x-opencode-session`). */
+export declare const OMP_CONSOLE_GO_PREFIX = "opencode-go/";
+export declare const ompConsoleGoPinError: (model: string) => string;
+export declare const assertOmpWorkflowModel: (model: string | undefined) => void;
+type OmpWorkflowSessionArgs = {
+    readonly sessionPersistence?: "persistent";
+    readonly sessionId?: string;
+} | {
+    readonly sessionPersistence: "ephemeral";
+    readonly sessionId?: never;
+};
+export declare const buildOmpArgs: (input: {
+    readonly cwd: string;
+    readonly model?: string;
+    readonly provider?: string;
+    readonly profile?: string;
+    readonly effort?: string;
+    readonly prompt: string;
+    readonly permission?: WorkflowPermissionMode;
+    readonly restrictedTools?: readonly string[];
+} & OmpWorkflowSessionArgs) => ReadonlyArray<string>;
+export interface OmpJsonStreamResult {
+    readonly sessionId?: string;
+    readonly text: string;
+    readonly error?: string;
+}
+export declare const parseOmpJsonStream: (stdout: string) => OmpJsonStreamResult;
+export declare const runOmpWorkflowTask: (task: AnyWorkflowWorkerTask, options: OmpWorkflowWorkerOptions) => Promise<WorkflowTaskExecution>;
+export {};