@skastr0/prism-linux-x64 0.5.1 → 0.8.0

package/types/jev.d.ts

@@ -0,0 +1,254 @@
+/**
+ * Jev (TypeSafe System One) vocabulary for Prism: question constructors,
+ * request validation/normalization, and request-correlated result codecs.
+ *
+ * This module is pure: no services, no environment access, no network. The
+ * wire contract is verified against `@typesafe-ai/sdk` v0.6.0 (`src/types.ts`)
+ * — these types are readonly mirrors of that contract, not a second
+ * interpretation of System One.
+ *
+ * Terminology follows the SDK and docs.typesafe.ai verbatim:
+ * - A *state* is the content evaluated (`EntryType`): string, JSON object,
+ *   JSON array, or null — never a bare boolean/number at the top level.
+ * - *Questions* are named, independent judgments over one shared state:
+ *   `choice` (which option), `score` (which rubric level), `noul`
+ *   (probability of yes). All questions in one request see the same state and
+ *   are evaluated independently — batching many questions per request is the
+ *   platform idiom (docs: 13 questions in one call = 12.2x cheaper, 10x
+ *   faster, byte-identical answers).
+ * - Answers are typed per question and constrained to the supplied criteria:
+ *   choice `{choice, confidence, probabilities}`, score `{score, confidence,
+ *   legend, probabilities}`, noul `{noul}`. Noul has no separate confidence.
+ *
+ * The request's token budget (~32k tokens, state and questions share it) is
+ * enforced pre-flight by the service layer in `src/services/jev.ts`; this
+ * module owns the estimator so tool handlers and workflows share one oracle.
+ */
+import { Schema } from "effect";
+/** Any JSON value. Readonly because decoded workflow data is readonly. */
+export type JevJson = null | boolean | number | string | readonly JevJson[] | {
+    readonly [key: string]: JevJson;
+};
+/**
+ * A System One entry: text, a JSON object or array, or null. Bare booleans
+ * and numbers are excluded at the top level, matching the SDK's `EntryType`.
+ */
+export type JevEntry = null | string | readonly JevJson[] | {
+    readonly [key: string]: JevJson;
+};
+/** Choice labels mapped to descriptions (`null` leaves a label undescribed). */
+export type JevChoiceCriteria = Readonly<Record<string, JevEntry>>;
+/** An ordered rubric with at least two levels. */
+export type JevScoreCriteria = readonly [JevEntry, JevEntry, ...JevEntry[]];
+/** A question that selects between named alternatives. */
+export interface JevChoiceQuestion<Criteria extends JevChoiceCriteria = JevChoiceCriteria> {
+    readonly type: "choice";
+    readonly instructions?: JevEntry;
+    readonly criteria: Criteria;
+}
+/** A question that assigns an ordered-rubric score. */
+export interface JevScoreQuestion<Criteria extends JevScoreCriteria = JevScoreCriteria> {
+    readonly type: "score";
+    readonly instructions?: JevEntry;
+    readonly criteria: Criteria;
+}
+/** A yes/no question answered as a probability of yes. */
+export interface JevNoulQuestion {
+    readonly type: "noul";
+    readonly instructions?: JevEntry;
+    readonly criteria?: {
+        readonly true?: JevEntry;
+        readonly false?: JevEntry;
+    } | null;
+}
+export type JevQuestion = JevChoiceQuestion | JevScoreQuestion | JevNoulQuestion;
+/** Questions keyed by the author-chosen IDs identifying their answers. */
+export type JevQuestions = Readonly<Record<string, JevQuestion>>;
+/** Rubric index keys for a concrete score criteria tuple. */
+export type JevScoreKey<C extends JevScoreCriteria> = number extends C["length"] ? number : Extract<keyof C, `${number}`>;
+/** The answer type for a question, preserving its criteria keys. */
+export type JevResultFor<Q extends JevQuestion> = Q extends JevChoiceQuestion<infer C> ? {
+    readonly type: "choice";
+    readonly choice: `${keyof C & (string | number)}`;
+    readonly confidence: number;
+    readonly probabilities: {
+        readonly [K in keyof C]: number;
+    };
+} : Q extends JevScoreQuestion<infer C> ? {
+    readonly type: "score";
+    readonly score: number;
+    readonly confidence: number;
+    readonly legend: {
+        readonly [K in JevScoreKey<C>]: C[K];
+    };
+    readonly probabilities: {
+        readonly [K in JevScoreKey<C>]: number;
+    };
+} : Q extends JevNoulQuestion ? {
+    readonly type: "noul";
+    readonly noul: number;
+} : never;
+/** Answers keyed by question ID, typed per question. */
+export type JevAnswers<Q extends JevQuestions> = {
+    readonly [K in keyof Q]: JevResultFor<Q[K]>;
+};
+/** Token usage for a request. */
+export interface JevUsage {
+    readonly input_tokens: number;
+    readonly output_tokens: number;
+}
+/** The full System One result: answers with model and usage metadata. */
+export interface JevResult<Q extends JevQuestions> {
+    readonly model: string;
+    readonly answers: JevAnswers<Q>;
+    readonly usage: JevUsage;
+}
+/** State and named questions for one System One call. */
+export interface JevRequest<Q extends JevQuestions = JevQuestions> {
+    readonly state: JevEntry;
+    readonly questions: Q;
+    readonly model?: string;
+}
+export declare class JevRequestValidationError extends Error {
+    readonly reason: string;
+    readonly path?: string | undefined;
+    readonly name = "JevRequestValidationError";
+    constructor(reason: string, path?: string | undefined);
+}
+/**
+ * Validate a System One entry (state, instructions, criterion description),
+ * returning a deep-frozen deep copy. Mirrors the SDK's `EntryType`: string,
+ * plain JSON object/array, or null.
+ */
+export declare const normalizeJevEntry: (value: unknown, path?: string) => JevEntry;
+/**
+ * Validate a questions map and return a deep-frozen deep copy with the same
+ * static type. At least one question is required.
+ */
+export declare const normalizeJevQuestions: <const Q extends JevQuestions>(questions: Q) => Q;
+/**
+ * Validate and freeze a full request (state + questions + optional model).
+ * Unexpected top-level fields are rejected rather than silently dropped so
+ * worker-task fields (prompt/worker/finish) can never leak into a Jev call.
+ */
+export declare const normalizeJevRequest: <const Q extends JevQuestions>(request: JevRequest<Q>) => JevRequest<Q>;
+/** Decode an unknown value (e.g. tool CLI input) into a normalized request. */
+export declare const parseJevRequest: (input: unknown) => JevRequest<JevQuestions>;
+/**
+ * Documented per-request token budget shared by state and questions
+ * (docs.typesafe.ai: "around 32,000 tokens").
+ */
+export declare const JEV_TOKEN_BUDGET = 32000;
+/**
+ * Soft target Prism enforces pre-flight. Below the hard budget so a request
+ * that passes locally still fits after SDK serialization differences.
+ */
+export declare const JEV_TOKEN_REQUEST_TARGET = 28000;
+/**
+ * Rough request token estimate: JSON payload characters / 4, the standard
+ * heuristic. Used only for pre-flight guidance, never as billing data.
+ */
+export declare const estimateJevRequestTokens: (request: JevRequest<JevQuestions>) => number;
+export declare function choice<const C extends JevChoiceCriteria>(definition: Omit<JevChoiceQuestion<C>, "type">): JevChoiceQuestion<C>;
+export declare function score<const C extends JevScoreCriteria>(definition: Omit<JevScoreQuestion<C>, "type">): JevScoreQuestion<C>;
+export declare function noul(definition?: Omit<JevNoulQuestion, "type">): JevNoulQuestion;
+/**
+ * Result contract version, folded into workflow identity hashing so a change
+ * in these codecs invalidates cached outputs deliberately rather than
+ * silently.
+ */
+export declare const JEV_RESULT_CONTRACT_VERSION: 1;
+/** A service-free codec for the full request-correlated System One result. */
+export type JevResultCodec<Q extends JevQuestions> = Schema.Codec<JevResult<Q>, JevResult<Q>, never, never>;
+/**
+ * Derive the result codec for a questions map. Answer keys, choice labels,
+ * probability keys, and score legends all come from the request, so a
+ * response disagreeing with its own questions fails decode.
+ *
+ * Localized assertion: the struct is built from runtime key maps whose key
+ * sets provably equal `keyof Q` / the criteria keys (same construction loop
+ * as `normalizeJevQuestions`), but TypeScript cannot see through
+ * `Object.fromEntries`; the cast maps the runtime struct onto
+ * `JevResultCodec<Q>`. Covered by runtime decode tests and dsl-type tests.
+ */
+export declare const jevResultSchema: <const Q extends JevQuestions>(questions: Q) => JevResultCodec<Q>;
+export declare const JEV_PROBE_MODEL = "jev-probe";
+/**
+ * A deterministic, schema-valid System One result used by workflow validation
+ * probes, where no live API call is made: every answer selects the first
+ * declared criterion (score index 0, noul 0) with a concentrated probability
+ * distribution, so branch-sensitive `run:` graphs walk the same stable path on
+ * every probe. Always decodes against `jevResultSchema(questions)`. This is a
+ * witness, not a simulation of what System One would answer.
+ */
+export declare const jevProbeResult: <const Q extends JevQuestions>(questions: Q) => JevResult<Q>;
+export declare const JevQuestionPresentation: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"choice">;
+    readonly instructions: Schema.optionalKey<Schema.Unknown>;
+    readonly criteria: Schema.$Record<Schema.String, Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"score">;
+    readonly instructions: Schema.optionalKey<Schema.Unknown>;
+    readonly criteria: Schema.$Array<Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"noul">;
+    readonly instructions: Schema.optionalKey<Schema.Unknown>;
+    readonly criteria: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+        readonly true: Schema.optionalKey<Schema.Unknown>;
+        readonly false: Schema.optionalKey<Schema.Unknown>;
+    }>>>;
+}>]>;
+export declare const JevSystemOneInputSchema: Schema.Struct<{
+    readonly state: Schema.Unknown;
+    readonly questions: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"choice">;
+        readonly instructions: Schema.optionalKey<Schema.Unknown>;
+        readonly criteria: Schema.$Record<Schema.String, Schema.Unknown>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"score">;
+        readonly instructions: Schema.optionalKey<Schema.Unknown>;
+        readonly criteria: Schema.$Array<Schema.Unknown>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"noul">;
+        readonly instructions: Schema.optionalKey<Schema.Unknown>;
+        readonly criteria: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+            readonly true: Schema.optionalKey<Schema.Unknown>;
+            readonly false: Schema.optionalKey<Schema.Unknown>;
+        }>>>;
+    }>]>>;
+    readonly model: Schema.optionalKey<Schema.String>;
+}>;
+/**
+ * Jev decode boundaries fail on excess properties rather than stripping
+ * them: a misspelled question field (`instruction` vs `instructions`) must
+ * not silently vanish from the request, and an answer with extra IDs or
+ * probability labels is not a response to the request that was sent. The
+ * presentation/result schemas below describe Records partly (probability
+ * maps are `Record(String, Number)`), so only struct-level strictness takes
+ * effect — the request-correlated literal keys do the rest.
+ */
+export declare const JEV_STRICT_PARSE_OPTIONS: {
+    onExcessProperty: "error";
+};
+export declare const JevSystemOneResultSchema: Schema.Struct<{
+    readonly model: Schema.String;
+    readonly answers: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"choice">;
+        readonly choice: Schema.String;
+        readonly confidence: Schema.Number;
+        readonly probabilities: Schema.$Record<Schema.String, Schema.Number>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"score">;
+        readonly score: Schema.Number;
+        readonly confidence: Schema.Number;
+        readonly legend: Schema.$Record<Schema.String, Schema.Unknown>;
+        readonly probabilities: Schema.$Record<Schema.String, Schema.Number>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"noul">;
+        readonly noul: Schema.Number;
+    }>]>>;
+    readonly usage: Schema.Struct<{
+        readonly input_tokens: Schema.Number;
+        readonly output_tokens: Schema.Number;
+    }>;
+}>;

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: {
@@ -363,10 +328,54 @@ export declare const LOWERER_CAPABILITIES: {
         };
         readonly notes: readonly ["The active Kimi Code target uses ~/.kimi-code exclusively.", "Kimi Code plugins are user-scoped in official docs; Prism keeps project scope unsupported for this lowerer.", "Current Moonshot-hosted Kimi Code CLI docs also document project-local .kimi-code/skills and .kimi-code/mcp.json, but Prism does not mix those direct project surfaces with generated user-scoped plugin bundles yet.", "Kimi Code subagents are runtime dispatches, so Prism compiled agents lower as role skills rather than native subagent definitions."];
     };
+    readonly "amp-orb": {
+        readonly harness: "amp-orb";
+        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: {
+                readonly kind: "direct-file";
+                readonly path: "<amp-orb-checkout>/<skill>/SKILL.md";
+                readonly summary: "Install writes flat text skill directories into an explicit hosted skills checkout.";
+            };
+            readonly generatedTools: LowererSurfaceCapability;
+            readonly hooks: LowererSurfaceCapability;
+            readonly agentConfig: LowererSurfaceCapability;
+        };
+        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: {
@@ -412,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: {
@@ -453,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: {
@@ -554,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: {
@@ -603,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: {
@@ -647,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";
@@ -680,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
@@ -690,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[];

package/types/prism-home.d.ts

@@ -1,7 +1,7 @@
 import { Schema } from "effect";
 export declare const PRISM_CONFIG_SCHEMA_VERSION = 1;
 export declare const DEFAULT_BACKUP_RETENTION_PER_TARGET = 3;
-export declare const BackupModeSchema: Schema.Literal<["always", "never"]>;
+export declare const BackupModeSchema: Schema.Literals<readonly ["always", "never"]>;
 export type BackupMode = typeof BackupModeSchema.Type;
 export interface PrismBackupConfig {
     readonly mode: BackupMode;
@@ -15,7 +15,7 @@ export interface PrismConfig {
  * Resolve the Prism home directory from an override or the environment.
  *
  * WS2+: new code must NOT call this from library modules — consume the
- * `PrismHome` Context.Tag from src/services/prism-env.ts instead; the env
+ * `PrismHome` service from src/services/prism-env.ts instead; the env
  * read happens exactly once at the CLI edge layer.
  */
 export declare const resolvePrismHome: (override?: string) => string;
@@ -27,8 +27,7 @@ export declare const prismBackupDir: (prismHome?: string) => string;
  * Workflows are ephemeral orchestration instruments that reference their
  * target repos by absolute path, so they belong in the home root, never
  * inside (or `git add`-ed into) the project they operate on — see the
- * "Where workflow files live" section of the prism workflow-authoring skill.
- * `prism workflow scaffold` writes here by default (PQ-176).
+ * "Author from the goal" section of the prism workflow-authoring skill.
  */
 export declare const prismWorkflowsSourceDir: (prismHome?: string) => string;
 export declare const defaultPrismConfig: () => PrismConfig;