@skastr0/prism-linux-x64 0.7.1 → 0.8.1

package/bin/prism

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/bin/prism
-size: 128292992 bytes
-sha256: 356a51f5881c6ee77ad7ecf65ab7a10736348bd226d9a3e9f5196a40054e2680
+size: 115074528 bytes
+sha256: 9dca62447917d30c6045228e8145896b5d36675267bce927d8edd350ec691f3d

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skastr0/prism-linux-x64",
-  "version": "0.7.1",
+  "version": "0.8.1",
   "type": "module",
   "description": "Prism standalone CLI binary for Linux x64.",
   "license": "MIT",
@@ -18,7 +18,7 @@
   },
   "dependencies": {
     "@opencode-ai/plugin": "^1.15.13",
-    "@skastr0/prism-sdk": "0.7.1",
+    "@skastr0/prism-sdk": "0.8.1",
     "effect": "4.0.0-rc.115",
     "typescript": "^5.8.3",
     "zod": "4.4.3"

package/types/amp-projects.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Amp orb projects, discovered by `prism workflow refresh-harness-types` from
+ * `amp projects list --json` and used to type and validate `worker.project`
+ * on `amp-orb` tasks and named workers.
+ *
+ * `amp --project` documents three identifier forms (namespace/name,
+ * owner/repo, repository URL); each project contributes every form it has.
+ * Project ids and `@namespace/name` also resolve through `amp projects get`,
+ * but `--project` does not document them, so they are not admitted.
+ */
+export interface AmpProject {
+    readonly id: string;
+    readonly namespace: string;
+    readonly name: string;
+    readonly repositoryURL?: string;
+    readonly remoteURLs?: readonly string[];
+}
+export interface DiscoveredAmpProjects {
+    readonly projects: readonly AmpProject[];
+    readonly source: "command" | "empty";
+    readonly error?: string;
+}
+/** Parse `amp projects list --json`: an array of `{ id, namespace, name, repositoryURL, remoteURLs }`. */
+export declare const parseAmpProjectsList: (stdout: string) => {
+    readonly projects: AmpProject[];
+    readonly error?: string;
+};
+/** The canonical `--project` form. */
+export declare const ampProjectCanonicalRef: (project: AmpProject) => string;
+/** Every documented `--project` form for one project: namespace/name, owner/repo, and repository URLs. */
+export declare const ampProjectRefs: (project: AmpProject) => readonly string[];
+/** Sorted union of every admitted `worker.project` value. Empty when discovery found none. */
+export declare const ampOrbProjectRefs: (discovered: DiscoveredAmpProjects | undefined) => readonly string[];
+/**
+ * Fail closed on an `amp-orb` project that the snapshot does not list.
+ * No snapshot, or a snapshot without projects, leaves `project` a free string
+ * (the same fallback as every other discovered union).
+ */
+export declare const validateAmpOrbProject: (project: string, discovered: DiscoveredAmpProjects | undefined) => string | undefined;

package/types/amp-runners.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Amp runners, discovered on demand by
+ * `prism workflow refresh-harness-types --discover-amp-runners` and used to
+ * type and validate `worker.runnerId` / `worker.runnerDir` on `amp-runner`
+ * tasks and named workers.
+ *
+ * Amp exposes no account-wide runner CLI command or REST route; the surface is
+ * the `list_runners` platform tool inside an Amp thread (the same data the
+ * ampcode.com thread composer's location picker shows). Discovery therefore
+ * spends one small `amp -x --stream-json` turn and parses the list_runners
+ * TOOL RESULT from the transcript — never the assistant's echoed text, which
+ * can reformat or truncate the JSON.
+ *
+ * An old entry is valid: there are no staleness warnings, and Amp re-validates
+ * `--executor runner:<id>` against live runners at spawn time.
+ */
+export declare const AMP_RUNNERS_REFRESH_COMMAND = "prism workflow refresh-harness-types --discover-amp-runners";
+export interface AmpRunnerDirectory {
+    readonly path: string;
+    readonly repositoryURL?: string;
+    readonly canCreateWorktree?: boolean;
+}
+export interface AmpRunner {
+    readonly runnerId: string;
+    readonly name: string;
+    readonly hostname?: string;
+    readonly workingDirectory?: string;
+    readonly repositoryURL?: string;
+    /** The runner's own last-seen timestamp from Amp, as reported. */
+    readonly lastSeenAt: string;
+    readonly capabilities: readonly string[];
+    readonly directories: readonly AmpRunnerDirectory[];
+}
+export interface DiscoveredAmpRunners {
+    readonly runners: readonly AmpRunner[];
+    readonly source: "command" | "empty";
+    /** When the one-shot capture ran (distinct from each runner's lastSeenAt). */
+    readonly capturedAt?: string;
+    readonly error?: string;
+}
+/** `list_runners` prompt: call the tool, then print its raw JSON and nothing else. */
+export declare const AMP_RUNNERS_PROMPT = "Call the list_runners tool with no arguments. Then output exactly the JSON object it returned, with text(JSON.stringify(result)), and nothing else. Do not summarize, reformat, or omit any fields.";
+/**
+ * Sentinel the discovery runner emits when the amp turn itself failed, so the
+ * reason survives the fail-soft string-only command contract.
+ */
+export declare const AMP_TURN_ERROR_PREFIX = "AMP_TURN_ERROR:";
+/**
+ * Parse the `amp -x <prompt> --stream-json` transcript: the list_runners tool
+ * result only. Required fields fail closed through the Effect Schema decode;
+ * upstream extras are ignored. Returns the discovery thread id so the caller
+ * can delete it.
+ */
+export declare const parseAmpRunnersStreamJson: (stdout: string) => {
+    readonly runners: AmpRunner[];
+    readonly sessionId?: string;
+    readonly error?: string;
+};
+/** Sorted runner ids in the snapshot. Empty when discovery found none. */
+export declare const ampRunnerIds: (discovered: DiscoveredAmpRunners | undefined) => readonly string[];
+/** Sorted unique directories one runner serves. */
+export declare const ampRunnerServedDirs: (runner: AmpRunner) => readonly string[];
+/** One runner's directories, normalized and deduped (the snapshot's canonical form). */
+export declare const ampRunnerNormalizedDirs: (runner: AmpRunner) => readonly AmpRunnerDirectory[];
+/**
+ * Fail closed on an `amp-runner` target the snapshot does not know: an unknown
+ * runnerId, or a runnerDir that runner does not serve. No snapshot, or one
+ * without runners, leaves both a free string (the same fallback as every other
+ * discovered union). `runnerDir` is optional: the runner's start directory.
+ */
+export declare const validateAmpRunnerTarget: (runnerId: string, runnerDir: string | undefined, discovered: DiscoveredAmpRunners | undefined) => string | undefined;

package/types/ast-to-json-schema.d.ts

@@ -0,0 +1,46 @@
+import { Schema, SchemaAST } from "effect";
+export type JsonSchema = Record<string, unknown>;
+export type AstToJsonSchemaOptions = {
+    readonly errorPrefix?: string;
+    /** Kimi and some MCP clients reject JSON Schema `const`; `enum` is the safe default. */
+    readonly literalRepresentation?: "enum" | "const";
+    readonly unknownKeywordSchema?: JsonSchema;
+    /**
+     * When true, a node's checks (refinements) are ignored and an encoding
+     * (transformation) is followed to its encoded side, so the JSON Schema
+     * describes the wire shape. This is the MCP / Zod / OpenCode schema-bridge
+     * stance. Workflow output schemas keep the default (reject), because their
+     * decoded value must equal its JSON representation.
+     */
+    readonly allowChecksAndEncodings?: boolean;
+    /**
+     * When true, map Effect `Schema.Record` (index signatures on the object node)
+     * to JSON Schema `{ type: "object", additionalProperties: ... }`. Workflow
+     * output schemas keep the default (reject).
+     */
+    readonly allowIndexSignatures?: boolean;
+    /**
+     * When true, render general (non-literal) unions as `anyOf` member schemas —
+     * `oneOf` when the union AST declares that mode — instead of failing closed.
+     * Tool/MCP input surfaces enable this; workflow output schemas keep the
+     * default (reject) so worker output contracts stay strict.
+     */
+    readonly allowGeneralUnions?: boolean;
+};
+export declare class WorkflowOutputSchemaError extends Error {
+    readonly name = "WorkflowOutputSchemaError";
+}
+export declare const astToJsonSchema: (ast: SchemaAST.AST, options?: AstToJsonSchemaOptions, fieldPath?: string) => JsonSchema;
+export declare const jsonSchemaFromEffectSchema: (schema: Schema.Top, options?: AstToJsonSchemaOptions) => JsonSchema;
+export declare const WORKFLOW_AST_TO_JSON_SCHEMA_OPTIONS: {
+    readonly errorPrefix: "workflow output schema";
+    readonly literalRepresentation: "enum";
+};
+export declare const MCP_AST_TO_JSON_SCHEMA_OPTIONS: {
+    readonly errorPrefix: "mcp-schema-bridge";
+    readonly literalRepresentation: "enum";
+    readonly unknownKeywordSchema: {};
+    readonly allowChecksAndEncodings: true;
+    readonly allowIndexSignatures: true;
+    readonly allowGeneralUnions: true;
+};

package/types/fs.d.ts

@@ -22,9 +22,9 @@ export declare function readFile(path: string): Promise<string>;
  */
 export declare function readJson<T>(path: string): Promise<T>;
 /**
- * Write string content to file
+ * Write content to a file atomically, preserving exact bytes for binary assets.
  */
-export declare function writeFile(path: string, content: string, options?: {
+export declare function writeFile(path: string, content: string | Uint8Array, options?: {
     readonly mode?: number;
 }): Promise<void>;
 export declare function chmodFile(path: string, mode: number): Promise<void>;

package/types/harness-types-discover.d.ts

@@ -3,6 +3,8 @@
  * Cache reads and CLI lists never throw; empty means "leave this worker as string".
  */
 import { type DiscoveredHarnessModels, type HarnessModelOption, type RefreshHarnessTypesResult } from "./harness-types.js";
+import { type DiscoveredAmpProjects } from "./amp-projects.js";
+import { type DiscoveredAmpRunners } from "./amp-runners.js";
 export type HarnessTypesReadText = (path: string) => string | undefined;
 export type HarnessTypesCommandRunner = (command: string, args: readonly string[]) => Promise<string>;
 export interface DiscoverHarnessTypesOptions {
@@ -10,6 +12,14 @@ export interface DiscoverHarnessTypesOptions {
     readonly env?: Readonly<Record<string, string | undefined>>;
     readonly readText?: HarnessTypesReadText;
     readonly runCommand?: HarnessTypesCommandRunner;
+    /**
+     * Also snapshot the account-wide Amp runners with a one-shot `amp -x` turn
+     * whose only job is calling the `list_runners` platform tool. Opt-in: the
+     * turn creates a small Amp thread (cheapest mode, deleted afterwards).
+     * A plain refresh never runs it and preserves a previously captured
+     * runner snapshot.
+     */
+    readonly discoverAmpRunners?: boolean;
 }
 export declare const parseClaudeModelCache: (raw: string) => {
     readonly models: HarnessModelOption[];
@@ -61,5 +71,29 @@ export declare const parseAmpAgentOptions: (raw: string) => {
     readonly error?: string;
 };
 export declare const discoverWorkflowHarnessModels: (options?: DiscoverHarnessTypesOptions) => Promise<readonly DiscoveredHarnessModels[]>;
+/** Amp orb projects from `amp projects list --json`. Fail-soft like model discovery. */
+export declare const discoverAmpProjects: (options?: DiscoverHarnessTypesOptions) => Promise<DiscoveredAmpProjects>;
+/**
+ * Runner discovery turns can take a couple of minutes (an agent turn, not a
+ * CLI list), so they get their own runner with a longer timeout than the
+ * 8s `defaultRunCommand`. On failure the reason is surfaced through the
+ * `AMP_TURN_ERROR:` sentinel; the untruncated partial stdout is appended on
+ * its own line so the init line's session id survives for thread cleanup.
+ */
+export declare const defaultAmpTurnRunner: HarnessTypesCommandRunner;
+/**
+ * Snapshot the account-wide Amp runners: one `amp -x --stream-json` turn in
+ * the cheapest mode whose only job is calling `list_runners`, parsed from the
+ * tool result. Fail-soft: a failed capture records the reason and no runners,
+ * but still deletes any thread the turn created (its partial stdout carries
+ * the session id even when the turn times out). The reason is also returned
+ * so the caller can surface it when the capture was explicitly requested.
+ */
+export declare const discoverAmpRunners: (options?: DiscoverHarnessTypesOptions) => Promise<{
+    readonly discovered: DiscoveredAmpRunners;
+    readonly failedExplicit?: string;
+}>;
+/** Previously captured runner snapshot, preserved by a plain refresh. */
+export declare const previousAmpRunners: (prismHome: string) => DiscoveredAmpRunners | undefined;
 export declare const refreshHarnessTypes: (prismHome: string, options?: DiscoverHarnessTypesOptions) => Promise<RefreshHarnessTypesResult>;
 export declare const renderHarnessTypesRefreshHuman: (result: RefreshHarnessTypesResult) => string;

package/types/harness-types.d.ts

@@ -5,6 +5,8 @@
  * `<PRISM_HOME>/state/harness-types/`. Not project-keyed — harnesses are
  * installed on the machine, not per repo.
  */
+import { type DiscoveredAmpProjects } from "./amp-projects.js";
+import { type DiscoveredAmpRunners } from "./amp-runners.js";
 import type { WorkflowWorkerId } from "./workflows.js";
 export declare const HARNESS_TYPES_DIRNAME = "harness-types";
 export declare const HARNESS_MODELS_FILENAME = "harness-models.ts";
@@ -31,11 +33,21 @@ export interface DiscoveredHarnessModels {
 export interface HarnessTypesSnapshot {
     readonly generatedAt: string;
     readonly harnesses: readonly DiscoveredHarnessModels[];
+    /** `amp projects list --json`: types and validates `amp-orb` `worker.project`. */
+    readonly ampProjects?: DiscoveredAmpProjects;
+    /** `list_runners` (one-shot Amp turn): types and validates `amp-runner` `worker.runnerId`/`runnerDir`. */
+    readonly ampRunners?: DiscoveredAmpRunners;
 }
 export interface RefreshHarnessTypesResult {
     readonly modelsPath: string;
     readonly discoveredPath: string;
     readonly snapshot: HarnessTypesSnapshot;
+    /**
+     * Set only when the explicit `--discover-amp-runners` capture failed: the
+     * reason plus what was kept. The refresh itself still succeeded; the CLI
+     * surfaces this as a non-zero exit so the failure is never silent.
+     */
+    readonly ampRunnersCaptureError?: string;
 }
 /**
  * Render the generated `prism/harnesses` module. A worker appears only

package/types/index.d.ts

@@ -99,6 +99,16 @@ export type SopSource = SopDefinition;
 export interface ModelTargetDefinition {
     readonly model: string;
     readonly variant?: string;
+    readonly effort?: string;
+    readonly provider?: string;
+    readonly temperature?: number;
+    readonly top_p?: number;
+}
+export interface ReasoningEffortModelTargetDefinition {
+    readonly model: string;
+    readonly effort?: string;
+    readonly variant?: never;
+    readonly provider?: string;
     readonly temperature?: number;
     readonly top_p?: number;
 }
@@ -107,9 +117,17 @@ export interface ModelPoolTargetDefinition {
     readonly models: readonly ModelTargetDefinition[];
 }
 export type ModelTargetBlockDefinition = ModelTargetDefinition | ModelPoolTargetDefinition | Readonly<Record<string, unknown>>;
+export type ReasoningEffortModelTargetBlockDefinition = ReasoningEffortModelTargetDefinition | {
+    readonly strategy: "any-of" | "round-robin" | "ordered";
+    readonly models: readonly ReasoningEffortModelTargetDefinition[];
+};
+export type ModelProfileTargets = Readonly<Record<string, ModelTargetBlockDefinition>> & {
+    readonly "codex-cli"?: ReasoningEffortModelTargetBlockDefinition;
+    readonly omp?: ReasoningEffortModelTargetBlockDefinition;
+};
 export interface ModelProfileDefinition {
     readonly description?: string;
-    readonly targets: Readonly<Record<string, ModelTargetBlockDefinition>>;
+    readonly targets: ModelProfileTargets;
 }
 export interface ModelspaceDefinition {
     readonly name: string;

package/types/lowerer-capabilities.d.ts

@@ -3,6 +3,14 @@ export type GeneratedCanonicalToolSupport = "executable" | "unsupported";
 export type SkillPermissionSupport = "supported" | "unsupported";
 export type CompileSurfaceSupport = "supported" | "unsupported";
 export type AgentModelBindingSupport = "consumed" | "ignored";
+export type WorkflowEffortCapability = {
+    readonly kind: "fixed";
+    readonly control: string;
+    readonly values: readonly string[];
+} | {
+    readonly kind: "catalog";
+    readonly control: string;
+};
 export interface CompileTargetCapabilities {
     readonly agents: CompileSurfaceSupport;
     readonly agentModelBindings: AgentModelBindingSupport;
@@ -31,6 +39,8 @@ export interface LowererCapabilityProfile {
      * ids elsewhere.
      */
     readonly workflowWorker: boolean;
+    /** Per-task reasoning control; null means the worker has no direct effort input. */
+    readonly workflowEffort: WorkflowEffortCapability | null;
     readonly compile: CompileTargetCapabilities;
     readonly surfaces: Record<LowererSurfaceId, LowererSurfaceCapability>;
     readonly notes?: readonly string[];
@@ -40,6 +50,11 @@ export declare const LOWERER_CAPABILITIES: {
         readonly harness: "claude-code";
         readonly family: "coding-harness";
         readonly workflowWorker: true;
+        readonly workflowEffort: {
+            readonly kind: "fixed";
+            readonly control: "--effort";
+            readonly values: readonly ["low", "medium", "high", "xhigh", "max"];
+        };
         readonly compile: CompileTargetCapabilities;
         readonly surfaces: {
             readonly pluginBundle: {
@@ -84,6 +99,7 @@ export declare const LOWERER_CAPABILITIES: {
         readonly harness: "opencode";
         readonly family: "coding-harness";
         readonly workflowWorker: true;
+        readonly workflowEffort: null;
         readonly compile: CompileTargetCapabilities;
         readonly surfaces: {
             readonly pluginBundle: {
@@ -128,80 +144,15 @@ export declare const LOWERER_CAPABILITIES: {
             };
         };
     };
-    readonly opencode2: {
-        readonly harness: "opencode2";
-        readonly family: "coding-harness";
-        readonly workflowWorker: true;
-        readonly compile: CompileTargetCapabilities;
-        readonly surfaces: {
-            readonly pluginBundle: {
-                readonly kind: "native-plugin-api";
-                readonly path: "<opencode-root>/plugins/prism-generated-<plugin>/";
-                readonly summary: "Compile emits an OpenCode plugin using @opencode-ai/plugin APIs (shared home with OpenCode 1.x).";
-            };
-            readonly rules: {
-                readonly kind: "direct-file";
-                readonly path: "<opencode-root>/AGENTS.md";
-                readonly summary: "Install appends managed sections to the native instructions file.";
-            };
-            readonly commands: {
-                readonly kind: "direct-file";
-                readonly path: "<opencode-root>/commands/";
-                readonly summary: "Install writes markdown command files.";
-            };
-            readonly agents: {
-                readonly kind: "markdown-file";
-                readonly path: "<opencode-root>/agents/";
-                readonly summary: "Compile writes OpenCode agent markdown files.";
-            };
-            readonly skills: {
-                readonly kind: "markdown-file";
-                readonly path: "<opencode-root>/skills/";
-                readonly summary: "Install and compile write Agent Skill folders.";
-            };
-            readonly generatedTools: {
-                readonly kind: "native-plugin-api";
-                readonly path: "<generated-plugin>/dist/server.mjs";
-                readonly summary: "Canonical tools lower to OpenCode plugin tools.";
-            };
-            readonly hooks: {
-                readonly kind: "native-plugin-api";
-                readonly path: "<generated-plugin>/dist/server.mjs";
-                readonly summary: "Hooks lower through the OpenCode plugin API.";
-            };
-            readonly agentConfig: {
-                readonly kind: "config-patch";
-                readonly path: "<opencode-root>/opencode.json#agent.<name>";
-                readonly summary: "Compile patches compiler-owned agent keys and plugin entries.";
-            };
-        };
-        readonly notes: readonly ["OpenCode 2 shares ~/.config/opencode/ with OpenCode 1.x until they consolidate.", "Detected by the `opencode2` binary on PATH, not by the shared config root.", "coding-harness targets opencode2, not opencode. `--harness opencode` remains for V1.", "Workflow worker is `opencode2` only (PRISM_WORKFLOW_OPENCODE2_BIN). Never falls back to `opencode`."];
-    };
-    readonly openclaw: {
-        readonly harness: "openclaw";
-        readonly family: "claw-harness";
-        readonly workflowWorker: false;
-        readonly compile: CompileTargetCapabilities;
-        readonly surfaces: {
-            readonly pluginBundle: LowererSurfaceCapability;
-            readonly rules: LowererSurfaceCapability;
-            readonly commands: LowererSurfaceCapability;
-            readonly agents: LowererSurfaceCapability;
-            readonly skills: {
-                readonly kind: "direct-file";
-                readonly path: "<openclaw-root>/skills/";
-                readonly summary: "Install writes Agent Skill folders only.";
-            };
-            readonly generatedTools: LowererSurfaceCapability;
-            readonly hooks: LowererSurfaceCapability;
-            readonly agentConfig: LowererSurfaceCapability;
-        };
-        readonly notes: readonly ["OpenClaw remains Prism skills-only for now."];
-    };
     readonly hermes: {
         readonly harness: "hermes";
         readonly family: "claw-harness";
         readonly workflowWorker: true;
+        readonly workflowEffort: {
+            readonly kind: "fixed";
+            readonly control: "--reasoning";
+            readonly values: readonly ["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"];
+        };
         readonly compile: CompileTargetCapabilities;
         readonly surfaces: {
             readonly pluginBundle: LowererSurfaceCapability;
@@ -230,6 +181,10 @@ export declare const LOWERER_CAPABILITIES: {
         readonly harness: "codex-cli";
         readonly family: "coding-harness";
         readonly workflowWorker: true;
+        readonly workflowEffort: {
+            readonly kind: "catalog";
+            readonly control: "--config model_reasoning_effort";
+        };
         readonly compile: CompileTargetCapabilities;
         readonly surfaces: {
             readonly pluginBundle: LowererSurfaceCapability;
@@ -274,6 +229,11 @@ export declare const LOWERER_CAPABILITIES: {
         readonly harness: "antigravity-cli";
         readonly family: "coding-harness";
         readonly workflowWorker: true;
+        readonly workflowEffort: {
+            readonly kind: "fixed";
+            readonly control: "--effort";
+            readonly values: readonly ["low", "medium", "high"];
+        };
         readonly compile: CompileTargetCapabilities;
         readonly surfaces: {
             readonly pluginBundle: {
@@ -318,6 +278,11 @@ export declare const LOWERER_CAPABILITIES: {
         readonly harness: "kimi-code";
         readonly family: "coding-harness";
         readonly workflowWorker: true;
+        readonly workflowEffort: {
+            readonly kind: "fixed";
+            readonly control: "env KIMI_MODEL_THINKING_EFFORT";
+            readonly values: readonly ["low", "medium", "high", "xhigh", "max"];
+        };
         readonly compile: CompileTargetCapabilities;
         readonly surfaces: {
             readonly pluginBundle: {
@@ -366,7 +331,8 @@ export declare const LOWERER_CAPABILITIES: {
     readonly "amp-orb": {
         readonly harness: "amp-orb";
         readonly family: "coding-harness";
-        readonly workflowWorker: false;
+        readonly workflowWorker: true;
+        readonly workflowEffort: null;
         readonly compile: CompileTargetCapabilities;
         readonly surfaces: {
             readonly pluginBundle: LowererSurfaceCapability;
@@ -382,12 +348,34 @@ export declare const LOWERER_CAPABILITIES: {
             readonly hooks: LowererSurfaceCapability;
             readonly agentConfig: LowererSurfaceCapability;
         };
-        readonly notes: readonly ["amp-orb is a hosted skills checkout, not a second root for amp-code.", "Family is coding-harness so the type fits. It is not a member of the coding-harness preset and not a workflow worker.", "Publication (clone, commit, push, reload) is outside this target."];
+        readonly notes: readonly ["amp-orb names Amp's hosted orb executor. Install surface: hosted skills checkout (skills only, not a second amp-code root).", "Workflow surface: project-bound orb threads via `amp --orb-execute --stream-json`.", "Family is coding-harness so the type fits. It is not a member of the coding-harness preset.", "Publication (clone, commit, push, reload) is outside this target."];
+    };
+    readonly "amp-runner": {
+        readonly harness: "amp-runner";
+        readonly family: "coding-harness";
+        readonly workflowWorker: true;
+        readonly workflowEffort: null;
+        readonly compile: CompileTargetCapabilities;
+        readonly surfaces: {
+            readonly pluginBundle: LowererSurfaceCapability;
+            readonly rules: LowererSurfaceCapability;
+            readonly commands: LowererSurfaceCapability;
+            readonly agents: LowererSurfaceCapability;
+            readonly skills: LowererSurfaceCapability;
+            readonly generatedTools: LowererSurfaceCapability;
+            readonly hooks: LowererSurfaceCapability;
+            readonly agentConfig: LowererSurfaceCapability;
+        };
+        readonly notes: readonly ["amp-runner names Amp executing on an operator-declared `amp --no-tui --runner-id <id>` runner. Workflow-worker only.", "Not a member of the coding-harness preset, --all, or installed-harness auto-detect: it has no install surface."];
     };
     readonly "amp-code": {
         readonly harness: "amp-code";
         readonly family: "coding-harness";
         readonly workflowWorker: true;
+        readonly workflowEffort: {
+            readonly kind: "catalog";
+            readonly control: "plugin-mode.reasoningEffort";
+        };
         readonly compile: CompileTargetCapabilities;
         readonly surfaces: {
             readonly pluginBundle: {
@@ -433,6 +421,7 @@ export declare const LOWERER_CAPABILITIES: {
         readonly harness: "cursor";
         readonly family: "coding-harness";
         readonly workflowWorker: true;
+        readonly workflowEffort: null;
         readonly compile: CompileTargetCapabilities;
         readonly surfaces: {
             readonly pluginBundle: {
@@ -474,58 +463,11 @@ export declare const LOWERER_CAPABILITIES: {
         };
         readonly notes: readonly ["Compiled Cursor agents are plugin subagents under plugins/local/prism-generated-<plugin>/agents/. The Agent CLI has no --agent selector, so the workflow worker still prompt-injects identity.", "Cursor plugin hooks are Claude-shaped command scripts: hooks/hooks.json plus hooks/*.mjs, loaded from the generated plugin and --plugin-dir. Do not whole-file own ~/.cursor/hooks.json.", "Workflow worker dispatches `agent --print --output-format stream-json --trust`; default model composer-2.5-fast; resume via --resume.", "Cursor command artifacts install through the same local plugin bundle so Prism uses Cursor's native command discovery instead of direct command files.", "Cursor Agent Skills stay install-phase direct under .cursor/skills and ~/.cursor/skills. Concrete sop skills bundle into the generated plugin.", "Per-agent skill permission visibility remains unsupported. Canonical tools stay CLI-only (`prism tools invoke`); no mcp.json patch is emitted."];
     };
-    readonly "factory-droid": {
-        readonly harness: "factory-droid";
-        readonly family: "coding-harness";
-        readonly workflowWorker: false;
-        readonly compile: CompileTargetCapabilities;
-        readonly surfaces: {
-            readonly pluginBundle: {
-                readonly kind: "native-plugin-bundle";
-                readonly path: "<factory-root>/plugins/prism-generated-<plugin>/";
-                readonly summary: "Compile emits Factory plugin bundles with .factory-plugin/plugin.json.";
-            };
-            readonly rules: {
-                readonly kind: "direct-file";
-                readonly path: "<factory-root>/AGENTS.md or rules/";
-                readonly summary: "Install writes Factory instruction/rule files.";
-            };
-            readonly commands: {
-                readonly kind: "direct-file";
-                readonly path: "<factory-root>/commands/";
-                readonly summary: "Install writes Factory command markdown files.";
-            };
-            readonly agents: {
-                readonly kind: "native-plugin-bundle";
-                readonly path: "<generated-plugin>/droids/";
-                readonly summary: "Compile writes generated droids inside the Factory plugin bundle.";
-            };
-            readonly skills: {
-                readonly kind: "native-plugin-bundle";
-                readonly path: "<generated-plugin>/skills/";
-                readonly summary: "Compiled bundles own targeted skills; skills-only plugins still install direct skills.";
-            };
-            readonly generatedTools: {
-                readonly kind: "direct-file";
-                readonly path: "<prism-home>/runtime/tools/<plugin>/runtime.mjs";
-                readonly summary: "Canonical tools lower to the CLI runtime; agents invoke via `prism tools invoke`.";
-            };
-            readonly hooks: {
-                readonly kind: "native-plugin-bundle";
-                readonly path: "<generated-plugin>/hooks/hooks.json";
-                readonly summary: "Hooks are bundled in Factory plugin format.";
-            };
-            readonly agentConfig: {
-                readonly kind: "native-plugin-bundle";
-                readonly path: "<generated-plugin>/droids/";
-                readonly summary: "Droid settings live in generated frontmatter.";
-            };
-        };
-    };
     readonly pi: {
         readonly harness: "pi";
         readonly family: "coding-harness";
         readonly workflowWorker: false;
+        readonly workflowEffort: null;
         readonly compile: CompileTargetCapabilities;
         readonly surfaces: {
             readonly pluginBundle: {
@@ -575,6 +517,11 @@ export declare const LOWERER_CAPABILITIES: {
         readonly harness: "omp";
         readonly family: "coding-harness";
         readonly workflowWorker: true;
+        readonly workflowEffort: {
+            readonly kind: "fixed";
+            readonly control: "--thinking";
+            readonly values: readonly ["off", "minimal", "low", "medium", "high", "xhigh", "max", "auto"];
+        };
         readonly compile: CompileTargetCapabilities;
         readonly surfaces: {
             readonly pluginBundle: {
@@ -624,6 +571,10 @@ export declare const LOWERER_CAPABILITIES: {
         readonly harness: "grok";
         readonly family: "coding-harness";
         readonly workflowWorker: true;
+        readonly workflowEffort: {
+            readonly kind: "catalog";
+            readonly control: "--reasoning-effort";
+        };
         readonly compile: CompileTargetCapabilities;
         readonly surfaces: {
             readonly pluginBundle: {
@@ -668,6 +619,7 @@ export declare const LOWERER_CAPABILITIES: {
         readonly harness: "devin";
         readonly family: "coding-harness";
         readonly workflowWorker: true;
+        readonly workflowEffort: null;
         readonly compile: {
             readonly agents: "unsupported";
             readonly agentModelBindings: "ignored";
@@ -701,6 +653,12 @@ export declare const LOWERER_CAPABILITIES: {
     };
 };
 export declare const getCompileTargetCapabilities: (harness: string) => CompileTargetCapabilities;
+/**
+ * Whether a harness has any install/compile surface Prism can write. A harness
+ * without one (workflow-worker-only, e.g. amp-runner) is never an implicit
+ * install target: not in `--all`, not in installed-harness auto-detect.
+ */
+export declare const harnessHasInstallSurface: (harness: HarnessId) => boolean;
 /**
  * Harness ids flagged `workflowWorker: true` above — computed at the type
  * level from the literal `as const` table, so it narrows exactly (no wider
@@ -711,5 +669,12 @@ export declare const getCompileTargetCapabilities: (harness: string) => CompileT
 export type WorkflowWorkerHarnessId = {
     [K in HarnessId]: (typeof LOWERER_CAPABILITIES)[K]["workflowWorker"] extends true ? K : never;
 }[HarnessId];
+/** Workflow effort capability ids, derived from the same harness registry. */
+export type WorkflowEffortWorkerHarnessId = {
+    [K in WorkflowWorkerHarnessId]: NonNullable<(typeof LOWERER_CAPABILITIES)[K]["workflowEffort"]> extends never ? never : K;
+}[WorkflowWorkerHarnessId];
+export type WorkflowEffortCapabilityFor<Harness extends HarnessId> = (typeof LOWERER_CAPABILITIES)[Harness]["workflowEffort"];
 /** Harness ids that can be dispatched as Prism Workflows workers, derived from the `workflowWorker` bit. */
 export declare const workflowWorkerHarnessIds: () => readonly WorkflowWorkerHarnessId[];
+/** Harness ids with a verified per-task effort control, derived from the registry. */
+export declare const workflowEffortWorkerHarnessIds: () => readonly WorkflowEffortWorkerHarnessId[];