@skastr0/prism-linux-x64 0.7.1 → 0.8.0

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

@@ -0,0 +1,26 @@
+import type { AnyWorkflowWorkerTask, WorkflowPermissionMode } from "./workflows.js";
+import type { WorkflowTaskExecution, WorkflowTaskProgressReporter, WorkflowTaskRepairLoopOption } from "./workflow-runner.js";
+export type OpenCodeWorkflowWorkerOptions = {
+    readonly cwd: string;
+    readonly bin?: string;
+    readonly model?: string;
+    readonly resolvedPermission: WorkflowPermissionMode;
+    readonly abortSignal?: AbortSignal;
+    readonly reportProgress?: WorkflowTaskProgressReporter;
+} & WorkflowTaskRepairLoopOption<"opencode">;
+export declare class OpenCodeWorkflowWorkerError extends Error {
+    readonly name = "OpenCodeWorkflowWorkerError";
+    readonly metadata?: Record<string, unknown>;
+    constructor(message: string, metadata?: Record<string, unknown>);
+}
+/**
+ * OpenCode v2 `run` has no `--dir` (the process cwd is the project) and uses
+ * `--auto` instead of `--dangerously-skip-permissions`.
+ */
+export declare const buildOpenCodeArgs: (input: {
+    readonly model?: string;
+    readonly prompt: string;
+    readonly sessionId?: string;
+    readonly permission?: WorkflowPermissionMode;
+}) => ReadonlyArray<string>;
+export declare const runOpenCodeWorkflowTask: (task: AnyWorkflowWorkerTask, options: OpenCodeWorkflowWorkerOptions) => Promise<WorkflowTaskExecution>;

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

@@ -0,0 +1,6 @@
+import type { Schema } from "effect";
+import { WorkflowOutputSchemaError, type JsonSchema as WorkflowJsonSchema } from "./ast-to-json-schema.js";
+export { WorkflowOutputSchemaError };
+export type { WorkflowJsonSchema };
+export declare const workflowJsonSchemaFromEffectSchema: (schema: Schema.Top) => WorkflowJsonSchema;
+export declare const tryWorkflowJsonSchemaFromEffectSchema: (schema: Schema.Top) => WorkflowJsonSchema | undefined;

package/types/workflow-permissions.d.ts

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

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

@@ -0,0 +1,28 @@
+export interface WorkflowProcessGuardRequest {
+    readonly cwd: string;
+    readonly command: string;
+    readonly args: ReadonlyArray<string>;
+}
+export declare class WorkflowProcessGuardError extends Error {
+    readonly name = "WorkflowProcessGuardError";
+}
+export declare const encodeWorkflowProcessGuardRequest: (request: WorkflowProcessGuardRequest) => ReadonlyArray<string>;
+export declare const decodeWorkflowProcessGuardRequest: (encodedCwd: string, encodedCommand: string, encodedArgs: ReadonlyArray<string>) => WorkflowProcessGuardRequest;
+export declare const workflowProcessGroupExists: (pid: number) => boolean;
+export declare const waitForWorkflowProcessGroupAbsence: (pid: number, timeoutMs: number) => Promise<boolean>;
+export interface WorkflowProcessGroupTerminationResult {
+    readonly escalated: boolean;
+    readonly alreadyAbsent: boolean;
+}
+export interface WorkflowProcessGroupTerminationOptions {
+    readonly termGraceMs?: number;
+    readonly killConfirmationMs?: number;
+    readonly onEscalated?: () => void;
+}
+export declare const terminateWorkflowProcessGroup: (pid: number, options?: WorkflowProcessGroupTerminationOptions) => Promise<WorkflowProcessGroupTerminationResult>;
+/**
+ * Own a detached workload process group for exactly as long as the caller keeps
+ * this guard's stdin open. Every shutdown cause shares the same bounded group
+ * termination and direct-child reap operation.
+ */
+export declare const runWorkflowProcessGuard: (request: WorkflowProcessGuardRequest) => Promise<number>;

package/types/workflow-session.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-export declare const WorkflowContinuationAdapterIdSchema: Schema.Literals<readonly ["amp-code", "antigravity-cli", "claude-code", "codex-cli", "cursor", "devin", "grok-cli", "hermes", "kimi-code", "opencode-cli", "opencode2-cli", "omp-cli"]>;
+export declare const WorkflowContinuationAdapterIdSchema: Schema.Literals<readonly ["amp-code", "amp-orb", "amp-runner", "antigravity-cli", "claude-code", "codex-cli", "cursor", "devin", "grok-cli", "hermes", "kimi-code", "opencode-cli", "omp-cli"]>;
 export type WorkflowContinuationAdapterId = typeof WorkflowContinuationAdapterIdSchema.Type;
 /**
  * Workflow workers that can continue a session.
@@ -13,12 +13,12 @@ export type WorkflowContinuationWorkerId = typeof WorkflowContinuationWorkerIdSc
 export declare const StableSessionIdSchema: Schema.brand<Schema.NonEmptyString, "StableSessionId">;
 export type StableSessionId = typeof StableSessionIdSchema.Type;
 export declare const WorkflowStableSessionSchema: Schema.Struct<{
-    readonly adapter: Schema.Literals<readonly ["amp-code", "antigravity-cli", "claude-code", "codex-cli", "cursor", "devin", "grok-cli", "hermes", "kimi-code", "opencode-cli", "opencode2-cli", "omp-cli"]>;
+    readonly adapter: Schema.Literals<readonly ["amp-code", "amp-orb", "amp-runner", "antigravity-cli", "claude-code", "codex-cli", "cursor", "devin", "grok-cli", "hermes", "kimi-code", "opencode-cli", "omp-cli"]>;
     readonly sessionId: Schema.brand<Schema.NonEmptyString, "StableSessionId">;
 }>;
 export type WorkflowStableSession = typeof WorkflowStableSessionSchema.Type;
 export declare const WorkflowHarnessContinuationSupportSchema: Schema.Union<readonly [Schema.Struct<{
-    readonly adapter: Schema.Literals<readonly ["amp-code", "antigravity-cli", "claude-code", "codex-cli", "cursor", "devin", "grok-cli", "hermes", "kimi-code", "opencode-cli", "opencode2-cli", "omp-cli"]>;
+    readonly adapter: Schema.Literals<readonly ["amp-code", "amp-orb", "amp-runner", "antigravity-cli", "claude-code", "codex-cli", "cursor", "devin", "grok-cli", "hermes", "kimi-code", "opencode-cli", "omp-cli"]>;
     readonly workflowWorker: Schema.Boolean;
     readonly stableSessionIds: Schema.Literal<true>;
     readonly exactSameSessionContinuation: Schema.Literal<true>;
@@ -26,7 +26,7 @@ export declare const WorkflowHarnessContinuationSupportSchema: Schema.Union<read
     readonly continueCommand: Schema.NonEmptyString;
     readonly capture: Schema.NonEmptyString;
 }>, Schema.Struct<{
-    readonly adapter: Schema.Literals<readonly ["amp-code", "antigravity-cli", "claude-code", "codex-cli", "cursor", "devin", "grok-cli", "hermes", "kimi-code", "opencode-cli", "opencode2-cli", "omp-cli"]>;
+    readonly adapter: Schema.Literals<readonly ["amp-code", "amp-orb", "amp-runner", "antigravity-cli", "claude-code", "codex-cli", "cursor", "devin", "grok-cli", "hermes", "kimi-code", "opencode-cli", "omp-cli"]>;
     readonly workflowWorker: Schema.Boolean;
     readonly stableSessionIds: Schema.Literal<false>;
     readonly exactSameSessionContinuation: Schema.Literal<false>;
@@ -36,6 +36,8 @@ export declare const WorkflowHarnessContinuationSupportSchema: Schema.Union<read
 export type WorkflowHarnessContinuationSupport = typeof WorkflowHarnessContinuationSupportSchema.Type;
 export declare const workflowContinuationAdapterByWorker: {
     readonly "amp-code": "amp-code";
+    readonly "amp-orb": "amp-orb";
+    readonly "amp-runner": "amp-runner";
     readonly "antigravity-cli": "antigravity-cli";
     readonly "claude-code": "claude-code";
     readonly "codex-cli": "codex-cli";
@@ -45,7 +47,6 @@ export declare const workflowContinuationAdapterByWorker: {
     readonly hermes: "hermes";
     readonly "kimi-code": "kimi-code";
     readonly opencode: "opencode-cli";
-    readonly opencode2: "opencode2-cli";
     readonly omp: "omp-cli";
 };
 export type WorkflowRepairLoopContinuationWorkerId = keyof typeof workflowContinuationAdapterByWorker;
@@ -61,6 +62,24 @@ export declare const workflowHarnessContinuationSupport: {
         readonly continueCommand: "amp threads continue <sessionId> --execute <prompt>";
         readonly capture: "stream-json session_id, local thread metadata, or threads list/search recovery";
     };
+    readonly "amp-orb": {
+        readonly adapter: "amp-orb";
+        readonly workflowWorker: true;
+        readonly stableSessionIds: true;
+        readonly exactSameSessionContinuation: true;
+        readonly sessionIdField: "sessionId";
+        readonly continueCommand: "amp threads continue <sessionId> --orb-execute --execute <prompt> --stream-json";
+        readonly capture: "stream-json session_id (the orb thread id); never list readback";
+    };
+    readonly "amp-runner": {
+        readonly adapter: "amp-runner";
+        readonly workflowWorker: true;
+        readonly stableSessionIds: true;
+        readonly exactSameSessionContinuation: true;
+        readonly sessionIdField: "sessionId";
+        readonly continueCommand: "amp threads continue <sessionId> --orb-execute --execute <prompt> --stream-json";
+        readonly capture: "stream-json session_id (the runner thread id); never list readback";
+    };
     readonly "antigravity-cli": {
         readonly adapter: "antigravity-cli";
         readonly workflowWorker: true;
@@ -142,15 +161,6 @@ export declare const workflowHarnessContinuationSupport: {
         readonly continueCommand: "opencode run -s <sessionId> <prompt>";
         readonly capture: "json step_start sessionID, session list, export, database, or log recovery";
     };
-    readonly "opencode2-cli": {
-        readonly adapter: "opencode2-cli";
-        readonly workflowWorker: true;
-        readonly stableSessionIds: true;
-        readonly exactSameSessionContinuation: true;
-        readonly sessionIdField: "sessionId";
-        readonly continueCommand: "opencode2 run -s <sessionId> <prompt>";
-        readonly capture: "json step_start sessionID, session list, export, database, or log recovery";
-    };
     readonly "omp-cli": {
         readonly adapter: "omp-cli";
         readonly workflowWorker: true;

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

@@ -0,0 +1,40 @@
+import { parsePositiveInteger } from "./workflow-harness-detection.js";
+export { parsePositiveInteger };
+export interface WorkflowWorkerProcessOptions {
+    readonly command: string;
+    readonly args: ReadonlyArray<string>;
+    readonly cwd: string;
+    readonly abortSignal?: AbortSignal;
+    readonly env?: Record<string, string>;
+    readonly onOutputActivity?: (stream: WorkflowWorkerOutputStream) => void;
+    readonly earlyExitPatterns?: ReadonlyArray<{
+        readonly name: string;
+        readonly pattern: RegExp;
+    }>;
+}
+export type WorkflowWorkerOutputStream = "stdout" | "stderr";
+export interface WorkflowWorkerProcessResult {
+    readonly exitCode: number | null;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly durationMs: number;
+    readonly aborted: boolean;
+    readonly earlyExit?: string;
+}
+/**
+ * Worker output is captured in full, without a byte ceiling. Harness workers are
+ * long-running agents whose event streams routinely reach tens or hundreds of
+ * megabytes; a size cap turned normal agent verbosity into a task failure and
+ * forced callers to guess a number they cannot know in advance. Runaway workers
+ * are bounded by run control (`workflow runs stop`), the opt-in inactivity
+ * watchdog, and cost budgets \u2014 not by truncating their output.
+ */
+export declare class WorkflowWorkerOutputCapture {
+    private readonly streams;
+    private totalBytes;
+    append(source: WorkflowWorkerOutputStream, text: string, byteLength?: number): void;
+    output(source: WorkflowWorkerOutputStream): string;
+    bytes(): number;
+}
+export declare const workflowWorkerProcessExcerpt: (stdout: string, stderr: string) => string;
+export declare const runWorkflowWorkerProcess: (options: WorkflowWorkerProcessOptions) => Promise<WorkflowWorkerProcessResult>;

package/types/workflow-workers.d.ts

@@ -0,0 +1,50 @@
+import { type AnyWorkflowWorkerTask, type WorkflowPermissionMode, type WorkflowWorkerId } from "./workflows.js";
+import type { WorkflowTaskExecution, WorkflowTaskExecutionContext, WorkflowTaskExecutionContextWithoutRepair, WorkflowWorkerTaskExecutor } from "./workflow-runner.js";
+import { type WorkflowRepairLoopContinuationCapability, type WorkflowRepairLoopContinuationCapabilityForWorker } from "./workflow-session.js";
+export { WorkflowPermissionError } from "./workflow-permissions.js";
+export interface WorkflowWorkerAdapterOptionsBase {
+    readonly cwd: string;
+    readonly model?: string;
+    readonly profile?: string;
+    readonly resolvedPermission: WorkflowPermissionMode;
+    readonly restrictedTools?: readonly string[];
+    readonly abortSignal?: AbortSignal;
+}
+export type WorkflowWorkerAdapterOptionsForCapability<Capability extends WorkflowRepairLoopContinuationCapability> = WorkflowWorkerAdapterOptionsBase & (Capability extends "stable-session-repair-loop" ? {
+    readonly context?: WorkflowTaskExecutionContext;
+} : {
+    readonly context?: WorkflowTaskExecutionContextWithoutRepair;
+});
+export type WorkflowWorkerAdapterOptions<Worker extends WorkflowWorkerId = WorkflowWorkerId> = WorkflowWorkerAdapterOptionsForCapability<WorkflowRepairLoopContinuationCapabilityForWorker<Worker>>;
+export interface WorkflowWorkerAdapter<Worker extends WorkflowWorkerId = WorkflowWorkerId> {
+    readonly id: Worker;
+    readonly runTask: (task: AnyWorkflowWorkerTask, options: WorkflowWorkerAdapterOptions<Worker>) => Promise<WorkflowTaskExecution>;
+}
+export declare class UnsupportedWorkflowWorkerError extends Error {
+    readonly worker: string;
+    readonly supportedWorkers: ReadonlyArray<string>;
+    readonly name = "UnsupportedWorkflowWorkerError";
+    constructor(worker: string, supportedWorkers: ReadonlyArray<string>);
+}
+export declare class WorkflowWorkerContinuationError extends Error {
+    readonly name = "WorkflowWorkerContinuationError";
+}
+export declare const supportedWorkflowWorkers: () => ReadonlyArray<string>;
+export declare function getWorkflowWorkerAdapter<Worker extends WorkflowWorkerId>(worker: Worker): WorkflowWorkerAdapter<Worker>;
+export declare function getWorkflowWorkerAdapter(worker: string): WorkflowWorkerAdapter;
+/**
+ * Per-worker default permission. Remote Amp executors (orb, runner) accept only
+ * `legacy` — no per-invocation override reaches the remote amp process — so an
+ * unconfigured remote task must default to `legacy`, not the local `permissive`
+ * default that dispatch would then reject.
+ */
+export declare const defaultWorkflowWorkerPermission: (worker?: string) => WorkflowPermissionMode;
+export declare const resolveWorkflowTaskPermission: (task: AnyWorkflowWorkerTask, fallbackPermission?: WorkflowPermissionMode) => WorkflowPermissionMode;
+/** Same argv interpreters run uses. Validate calls this so illegal pins fail before spend. */
+export declare const assertWorkflowWorkerPermission: (worker: string, mode: WorkflowPermissionMode, restrictedTools?: readonly string[]) => void;
+export declare const createWorkflowWorkerExecutor: (input: {
+    readonly worker?: string;
+    readonly cwd: string;
+    readonly model?: string;
+    readonly fallbackPermission?: WorkflowPermissionMode;
+}) => WorkflowWorkerTaskExecutor;

package/types/workflows.d.ts

@@ -1,4 +1,5 @@
 import { Effect, Result, Schema, type SchemaAST } from "effect";
+import { type WorkflowEffortCapabilityFor, type WorkflowEffortWorkerHarnessId, type WorkflowWorkerHarnessId } from "./lowerer-capabilities.js";
 import { type WorkflowRuntimeError } from "./workflow-errors.js";
 import { type WorkflowSchedule } from "./workflow-scheduler/schedule.js";
 import { type JevEntry, type JevQuestions, type JevRequest, type JevResult, type JevResultCodec } from "./jev.js";
@@ -57,7 +58,7 @@ export interface WorkflowValidationSummary {
  */
 export type WorkflowOutputSchema = Schema.Codec<unknown, unknown, never, never>;
 export type WorkflowFinishCriterionError = Error;
-export type WorkflowWorkerId = "amp-code" | "antigravity-cli" | "claude-code" | "codex-cli" | "cursor" | "devin" | "grok" | "hermes" | "kimi-code" | "opencode" | "opencode2" | "omp";
+export type WorkflowWorkerId = WorkflowWorkerHarnessId;
 /**
  * Per-harness model identifier map. Empty in core so `worker.model` stays
  * `string` until `prism workflow refresh-harness-types` augments keys with
@@ -73,14 +74,56 @@ export interface WorkflowHarnessModelMap {
 export interface WorkflowHarnessCatalogModelMap {
 }
 /**
- * Amp reasoning-effort ladders from the catalog. Empty in core; refresh
- * augments `"amp-code"` for `worker.effort`.
+ * Model-specific reasoning-effort ladders from installed CLI catalogs.
+ * Fixed CLI values come from `LOWERER_CAPABILITIES` and are not discovered.
+ * Refresh augments only catalog-backed workers.
  */
 export interface WorkflowHarnessEffortMap {
 }
+/**
+ * Discovered Amp orb projects (`amp projects list --json`). Empty in core;
+ * refresh augments `"amp-orb"` so `worker.project` narrows to known projects.
+ */
+export interface WorkflowHarnessProjectMap {
+}
+export type WorkflowHarnessProject<W extends WorkflowWorkerId> = W extends keyof WorkflowHarnessProjectMap ? WorkflowHarnessProjectMap[W] : string;
+/**
+ * Discovered Amp runners (`list_runners`, captured by
+ * `refresh-harness-types --discover-amp-runners`). Empty in core; refresh
+ * augments one key per runner whose value is the union of the directories
+ * that runner serves.
+ */
+export interface WorkflowHarnessRunnerDirMap {
+}
+/**
+ * The `amp-runner` target: with a runner snapshot, a discriminated union over
+ * the live runner ids so `runnerDir` follows the chosen id (a directory
+ * another runner serves is a type error); without one, both stay plain
+ * strings. `validate` enforces the pair again at load time.
+ */
+export type AmpRunnerTargetOptions = keyof WorkflowHarnessRunnerDirMap extends never ? {
+    /** Runner id from `amp --no-tui --runner-id <id>` (`--executor runner:<id>`). */
+    readonly runnerId: string;
+    /** Absolute directory the runner serves (`--runner-dir`); defaults to the runner's start directory. */
+    readonly runnerDir?: string;
+} : {
+    [R in keyof WorkflowHarnessRunnerDirMap]: {
+        readonly runnerId: R;
+        readonly runnerDir?: WorkflowHarnessRunnerDirMap[R];
+    };
+}[keyof WorkflowHarnessRunnerDirMap];
 export type WorkflowHarnessModel<W extends WorkflowWorkerId> = (W extends keyof WorkflowHarnessModelMap ? WorkflowHarnessModelMap[W] : string) | WorkflowModelProfileRef;
 export type WorkflowHarnessCatalogModel<W extends WorkflowWorkerId> = W extends keyof WorkflowHarnessCatalogModelMap ? WorkflowHarnessCatalogModelMap[W] : string;
-export type WorkflowHarnessEffort<W extends WorkflowWorkerId> = W extends keyof WorkflowHarnessEffortMap ? WorkflowHarnessEffortMap[W] : string;
+type WorkflowHarnessEffortForCapability<W extends WorkflowWorkerId, Capability> = Capability extends {
+    readonly kind: "fixed";
+    readonly values: readonly (infer Value extends string)[];
+} ? Value : Capability extends {
+    readonly kind: "catalog";
+} ? W extends keyof WorkflowHarnessEffortMap ? WorkflowHarnessEffortMap[W] : never : never;
+type WorkflowHarnessEffortForOne<W extends WorkflowWorkerId> = WorkflowHarnessEffortForCapability<W, NonNullable<WorkflowEffortCapabilityFor<W>>>;
+/** Harness-bound effort values; catalog-backed values require a refreshed type map. */
+export type WorkflowHarnessEffort<W extends WorkflowWorkerId> = W extends WorkflowWorkerId ? WorkflowHarnessEffortForOne<W> : never;
+export declare const workflowWorkerSupportsEffort: (worker: unknown) => worker is WorkflowEffortWorkerHarnessId;
 export type WorkflowPermissionMode = "legacy" | "permissive" | "restricted" | "interactive" | "sandbox-read-only" | "sandbox-workspace-write" | "full-access";
 /** Workers with no sandbox flag and no per-invocation allowlist. */
 export type WorkflowDialPermissionMode = Extract<WorkflowPermissionMode, "legacy" | "permissive" | "full-access">;
@@ -90,8 +133,31 @@ export type CodexWorkflowPermissionMode = Extract<WorkflowPermissionMode, "legac
 export type CursorWorkflowPermissionMode = Extract<WorkflowPermissionMode, "legacy" | "permissive" | "full-access" | "sandbox-workspace-write">;
 export type DevinWorkflowPermissionMode = Extract<WorkflowPermissionMode, "legacy" | "permissive" | "restricted" | "full-access">;
 export type OmpWorkflowPermissionMode = Extract<WorkflowPermissionMode, "legacy" | "permissive" | "restricted" | "full-access">;
-export type WorkflowWorkerPermissionMode<W extends WorkflowWorkerId> = W extends "claude-code" ? ClaudeWorkflowPermissionMode : W extends "codex-cli" ? CodexWorkflowPermissionMode : W extends "cursor" ? CursorWorkflowPermissionMode : W extends "devin" ? DevinWorkflowPermissionMode : W extends "omp" ? OmpWorkflowPermissionMode : WorkflowDialPermissionMode;
 export declare const WORKFLOW_SESSION_PERSISTENCE_WORKERS: readonly ["claude-code", "codex-cli", "omp"];
+/** Remote Amp executors: hosted orbs and operator-declared runners. */
+export type AmpRemoteWorkflowWorkerId = Extract<WorkflowWorkerId, "amp-orb" | "amp-runner">;
+/**
+ * Workers whose full options can be built from `{ worker, model, ... }` alone.
+ * TypeScript's smarter union checking (TS 3.5+) decomposes a wide `worker`
+ * discriminant across the options union, so a helper typed against the full
+ * {@link WorkflowWorkerId} that cannot supply remote workers' required fields
+ * (`project`, `runnerId`) would silently accept remote ids as invalid tasks.
+ * Loose helpers must narrow to this.
+ */
+export type WorkflowWorkerIdWithoutRequiredOptions = Exclude<WorkflowWorkerId, AmpRemoteWorkflowWorkerId>;
+/**
+ * Remote Amp executors (orb, runner) read tool permissions from the remote
+ * machine's Amp settings or the ampcode.com project; Prism has no
+ * per-invocation override that reaches them.
+ */
+export type AmpRemoteWorkflowPermissionMode = Extract<WorkflowPermissionMode, "legacy">;
+export type WorkflowWorkerPermissionMode<W extends WorkflowWorkerId> = W extends "claude-code" ? ClaudeWorkflowPermissionMode : W extends "codex-cli" ? CodexWorkflowPermissionMode : W extends "cursor" ? CursorWorkflowPermissionMode : W extends "devin" ? DevinWorkflowPermissionMode : W extends "omp" ? OmpWorkflowPermissionMode : W extends AmpRemoteWorkflowWorkerId ? AmpRemoteWorkflowPermissionMode : WorkflowDialPermissionMode;
+/** Documented orb sizes (https://ampcode.com/docs/orbs/sizes-and-costs); `a1.3xlarge` needs Gigawatt/Enterprise. */
+export declare const AMP_ORB_SIZES: readonly ["a1.tiny", "a1.small", "a1.medium", "a1.large", "a1.xxlarge", "a1.3xlarge"];
+export type AmpOrbSize = (typeof AMP_ORB_SIZES)[number];
+/** Amp thread visibility values (`--visibility`). */
+export declare const AMP_THREAD_VISIBILITIES: readonly ["private", "unlisted", "workspace", "group"];
+export type AmpThreadVisibility = (typeof AMP_THREAD_VISIBILITIES)[number];
 export type WorkflowSessionPersistenceWorkerId = typeof WORKFLOW_SESSION_PERSISTENCE_WORKERS[number];
 export type WorkflowSessionPersistence = "persistent" | "ephemeral";
 /** @deprecated Use WorkflowSessionPersistence. */
@@ -118,17 +184,46 @@ type WorkflowTaskWorkerOptionsFor<W extends WorkflowWorkerId> = WorkflowTaskWork
     readonly worker: W;
     readonly permission?: WorkflowWorkerPermissionMode<W>;
 } & (W extends "amp-code" ? {
-    readonly sessionPersistence?: never;
     readonly catalogModel?: WorkflowHarnessCatalogModel<"amp-code">;
-    readonly effort?: WorkflowHarnessEffort<"amp-code">;
-} : W extends WorkflowSessionPersistenceWorkerId ? {
+} : W extends "amp-runner" ? {
+    readonly catalogModel?: WorkflowHarnessCatalogModel<"amp-code">;
+} : {
+    readonly catalogModel?: never;
+}) & (W extends WorkflowEffortWorkerHarnessId ? {
+    readonly effort?: WorkflowHarnessEffort<W>;
+} : {
+    readonly effort?: never;
+}) & (W extends WorkflowSessionPersistenceWorkerId ? {
     readonly sessionPersistence?: WorkflowSessionPersistence;
 } : {
     readonly sessionPersistence?: never;
+}) & (W extends AmpRemoteWorkflowWorkerId ? {
+    readonly labels?: ReadonlyArray<string>;
+} : {
+    readonly labels?: never;
+}) & (W extends "amp-orb" ? {
+    /**
+     * Amp project for the orb (`--project`): namespace/name, owner/repo, or repository URL.
+     * Narrows to discovered projects after `prism workflow refresh-harness-types`.
+     */
+    readonly project: WorkflowHarnessProject<"amp-orb">;
+    /** `--orb-size`; defaults to the project's size. */
+    readonly size?: AmpOrbSize;
+    /** Thread visibility; defaults to Amp's own default. Cosmetic: not part of cache identity. */
+    readonly visibility?: AmpThreadVisibility;
+} : {
+    readonly project?: never;
+    readonly size?: never;
+    readonly visibility?: never;
+}) & (W extends "amp-runner" ? AmpRunnerTargetOptions : {
+    readonly runnerId?: never;
+    readonly runnerDir?: never;
 });
 export type WorkflowTaskWorkerOptions = (WorkflowTaskWorkerOptionsCommon & {
     readonly worker?: undefined;
     readonly permission?: WorkflowPermissionMode;
+    readonly catalogModel?: never;
+    readonly effort?: never;
     readonly sessionPersistence?: never;
 }) | {
     [W in WorkflowWorkerId]: WorkflowTaskWorkerOptionsFor<W>;
@@ -141,8 +236,10 @@ export interface WorkflowTaskModelResolution {
     readonly model: string;
     /** Harness-side inference provider (e.g. hermes `--provider xai-oauth`), from the modelspace target or harness default. */
     readonly provider?: string;
-    /** Harness-bound model variant, such as Codex reasoning effort. */
+    /** Model-selection variant, such as OpenCode's `provider/model#variant`. */
     readonly variant?: string;
+    /** Harness-bound reasoning effort from a modelspace target. */
+    readonly effort?: string;
     readonly source: WorkflowTaskModelResolutionSource;
 }
 /**
@@ -160,6 +257,11 @@ export declare const resolveWorkflowTaskModel: (task: AnyWorkflowWorkerTask, opt
     readonly worker?: string;
     readonly fallbackModel?: string;
 }) => string | undefined;
+/** Task-level effort is the explicit override; modelspace effort is the fallback. */
+export declare const resolveWorkflowTaskEffort: (task: AnyWorkflowWorkerTask, options?: {
+    readonly worker?: string;
+    readonly fallbackModel?: string;
+}) => string | undefined;
 export interface WorkflowFinishCriterionContext<Output> {
     readonly output: Output;
     readonly rawOutput: unknown;