@skastr0/prism-linux-x64 0.5.1 → 0.8.0

package/types/services/jev.d.ts

@@ -0,0 +1,131 @@
+/**
+ * JevClient — the Effect service behind first-class Jev (TypeSafe System One)
+ * decisions in Prism workflows and Prism tools (GLYPH-JEV-03).
+ *
+ * One implementation serves both surfaces: the workflow runner's native Jev
+ * executor (src/workflow-jev.ts) and the compiled `jev/systemone_ask` tool
+ * (~/prism-plugins/jev) call this service; nothing else knows the SDK exists.
+ *
+ * Design contract:
+ * - Credentials and endpoints are captured once, when the layer is built.
+ *   `JevClientLive` reads TYPESAFE_API_KEY / TYPESAFE_BASE_URL /
+ *   TYPESAFE_DEFAULT_MODEL; `JevClientWith` takes explicit options and never
+ *   consults the environment.
+ * - The TypeSafeClient is constructed lazily on the first live call, because
+ *   its constructor throws when the API key is missing. Importing this module,
+ *   compiling plugins, validating workflows, and replaying cached outputs must
+ *   never require credentials.
+ * - The SDK owns transport retry (408/429/5xx, backoff, Retry-After). Prism
+ *   adds no second retry layer; `timeoutMs` is per HTTP attempt, matching the
+ *   SDK.
+ * - SDK logging is forced off: SDK debug logs can include request/response
+ *   bodies, i.e. workflow state. Prism telemetry is the bounded channel.
+ * - `APIUserAbortError` maps to Effect interruption (the only abort source is
+ *   the Effect-provided signal); every other SDK error maps to a tagged
+ *   `JevError.kind`. Raw SDK errors are never rethrown or serialized — they
+ *   can carry response bodies.
+ * - Pre-flight budget guard: requests estimated above
+ *   `JEV_TOKEN_REQUEST_TARGET` fail `kind: "request"` with a chunking hint
+ *   instead of a raw API 400 — agent callers can act on that message.
+ */
+import { Context, Effect, Layer, Schema } from "effect";
+import { type Fetch as SdkFetch, type RetryPolicy as SdkRetryPolicy } from "@typesafe-ai/sdk";
+import { type JevAnswers, type JevQuestions, type JevRequest, type JevResult, type JevUsage } from "../jev.js";
+export declare const JEV_ERROR_KINDS: readonly ["configuration", "request", "authentication", "permission", "rate-limit", "timeout", "connection", "http", "protocol"];
+/**
+ * - `configuration`: missing/invalid client configuration (missing API key).
+ * - `request`: the request itself was rejected — local validation, the
+ *   pre-flight token-budget guard, or API 400/422.
+ * - `authentication` / `permission`: API 401/403.
+ * - `rate-limit`: API 429 (carries `retryAfterMs` when the server sent one).
+ * - `timeout` / `connection`: transport failures after SDK retries exhaust.
+ * - `http`: any other non-2xx API error, including exhausted 5xx.
+ * - `protocol`: a nominally successful response failed the request-correlated
+ *   result contract (malformed envelope, answer/key mismatch). Terminal and
+ *   never repairable by re-asking the model.
+ */
+export type JevErrorKind = (typeof JEV_ERROR_KINDS)[number];
+declare const JevError_base: Schema.Class<JevError, Schema.TaggedStruct<"JevError", {
+    readonly kind: Schema.Literals<readonly ["configuration", "request", "authentication", "permission", "rate-limit", "timeout", "connection", "http", "protocol"]>;
+    readonly message: Schema.String;
+    readonly status: Schema.optionalKey<Schema.Number>;
+    readonly retryAfterMs: Schema.optionalKey<Schema.Number>;
+    readonly sdkErrorName: Schema.optionalKey<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+export declare class JevError extends JevError_base {
+}
+/** Replacement text for a scrubbed credential. */
+export declare const JEV_REDACTED_SECRET = "[redacted]";
+/**
+ * Redact exact occurrences of each known secret from outward diagnostic text.
+ * SDK error messages carry server-provided text verbatim (`APIError.describe`
+ * copies the response body's error/message/detail), and an upstream
+ * diagnostic can echo the Authorization header back — so every JevError that
+ * leaves the service boundary is scrubbed with the configured credential.
+ * Secrets shorter than 8 characters are skipped: redacting a tiny needle
+ * would mangle prose, and real credentials are never that short.
+ */
+export declare const redactJevSecrets: (text: string, secrets: ReadonlyArray<string | undefined>) => string;
+/** Non-secret resolved configuration, safe for identity hashing and logs. */
+export interface JevPublicConfig {
+    readonly baseURL: string;
+    readonly defaultModel: string;
+}
+export interface JevCallOptions {
+    /** Per-HTTP-attempt timeout override, passed through to the SDK. */
+    readonly timeoutMs?: number;
+}
+export interface JevClientShape {
+    readonly config: JevPublicConfig;
+    readonly systemOne: <const Q extends JevQuestions>(request: JevRequest<Q>, options?: JevCallOptions) => Effect.Effect<JevResult<Q>, JevError>;
+}
+/**
+ * Resolve the non-secret Jev configuration (base URL + default model) without
+ * touching the API key. Identity hashing, workflow snapshots, and the CLI use
+ * this so a jev task's cache identity is computable without credentials.
+ */
+export type JevEnvLike = {
+    readonly TYPESAFE_BASE_URL?: string | undefined;
+    readonly TYPESAFE_DEFAULT_MODEL?: string | undefined;
+    readonly [key: string]: string | undefined;
+};
+export declare const resolveJevPublicConfig: (env?: JevEnvLike) => JevPublicConfig;
+declare const JevClient_base: Context.ServiceClass<JevClient, "prism/JevClient", JevClientShape>;
+export declare class JevClient extends JevClient_base {
+}
+export type JevClientService = JevClient["Service"];
+export interface JevClientOptions {
+    readonly apiKey?: string;
+    readonly baseURL?: string;
+    readonly defaultModel?: string;
+    readonly fetch?: SdkFetch;
+    /** SDK retry override (transport-level only). */
+    readonly retry?: Partial<SdkRetryPolicy>;
+    /** SDK per-attempt timeout override in milliseconds. */
+    readonly timeoutMs?: number;
+}
+/**
+ * Live layer: captures the TYPESAFE_* environment once at build; the API key
+ * is only required when a live call is made.
+ */
+export declare const JevClientLive: Layer.Layer<JevClient>;
+/**
+ * Explicit-config layer; never reads environment variables. Missing optional
+ * settings fall back to documented non-secret defaults.
+ */
+export declare const JevClientWith: (options: JevClientOptions) => Layer.Layer<JevClient>;
+export interface JevClientTestOptions {
+    readonly model?: string;
+    readonly usage?: JevUsage;
+    /** Override the public config observed by identity/telemetry code. */
+    readonly config?: JevPublicConfig;
+}
+/**
+ * Stub layer for tests: answers a registered questions contract from memory.
+ * The registered answers are validated at construction against the real
+ * result codec, so a malformed stub fails the test that wrote it, not the
+ * system under test. Calls with a different questions map fail
+ * `kind: "request"`. Never touches network or environment.
+ */
+export declare const JevClientTest: <const Q extends JevQuestions>(questions: Q, answers: JevAnswers<Q>, options?: JevClientTestOptions) => Layer.Layer<JevClient>;
+export {};

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" | "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,15 +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";