@skastr0/prism-linux-x64 0.5.1 → 0.8.0

package/bin/prism

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/bin/prism
-size: 128325760 bytes
-sha256: 5f5152c8f1bce96f150449ead8e4b466138ad4a6d56c411b3829a841451bdd16
+size: 115074528 bytes
+sha256: 00dc6342ae9e2c0fb5d1d11346f145a35c572b36a5e0dc98800e1a0576f82b69

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skastr0/prism-linux-x64",
-  "version": "0.5.1",
+  "version": "0.8.0",
   "type": "module",
   "description": "Prism standalone CLI binary for Linux x64.",
   "license": "MIT",
@@ -18,8 +18,8 @@
   },
   "dependencies": {
     "@opencode-ai/plugin": "^1.15.13",
-    "@skastr0/prism-sdk": "0.5.1",
-    "effect": "^3.21.1",
+    "@skastr0/prism-sdk": "0.8.0",
+    "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/compile/errors.d.ts

@@ -8,105 +8,83 @@
  */
 import { Schema } from "effect";
 import type { PluginManifestError } from "../errors.js";
-declare const SourceParseError_base: Schema.TaggedErrorClass<SourceParseError, "SourceParseError", {
-    readonly _tag: Schema.tag<"SourceParseError">;
-} & {
-    sourcePath: typeof Schema.String;
-    kind: Schema.Literal<["identity", "personality", "agent", "modelspace", "skillspace", "sop", "tool", "hook"]>;
-    message: typeof Schema.String;
-}>;
+declare const SourceParseError_base: Schema.Class<SourceParseError, Schema.TaggedStruct<"SourceParseError", {
+    readonly sourcePath: Schema.String;
+    readonly kind: Schema.Literals<readonly ["identity", "personality", "agent", "modelspace", "skillspace", "sop", "tool", "hook"]>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
 export declare class SourceParseError extends SourceParseError_base {
 }
-declare const UnknownReferenceError_base: Schema.TaggedErrorClass<UnknownReferenceError, "UnknownReferenceError", {
-    readonly _tag: Schema.tag<"UnknownReferenceError">;
-} & {
-    agentName: typeof Schema.String;
-    sourcePath: typeof Schema.String;
-    field: Schema.Literal<["identity", "personality", "model", "skill", "phase.agent"]>;
-    referenceName: typeof Schema.String;
-}>;
+declare const UnknownReferenceError_base: Schema.Class<UnknownReferenceError, Schema.TaggedStruct<"UnknownReferenceError", {
+    readonly agentName: Schema.String;
+    readonly sourcePath: Schema.String;
+    readonly field: Schema.Literals<readonly ["identity", "personality", "model", "skill", "phase.agent"]>;
+    readonly referenceName: Schema.String;
+}>, import("effect/Cause").YieldableError>;
 export declare class UnknownReferenceError extends UnknownReferenceError_base {
 }
-declare const UnknownDependencyError_base: Schema.TaggedErrorClass<UnknownDependencyError, "UnknownDependencyError", {
-    readonly _tag: Schema.tag<"UnknownDependencyError">;
-} & {
-    sourcePath: typeof Schema.String;
-    referenceName: typeof Schema.String;
-    depPrefix: typeof Schema.String;
-    declaredDeps: Schema.Array$<typeof Schema.String>;
-}>;
+declare const UnknownDependencyError_base: Schema.Class<UnknownDependencyError, Schema.TaggedStruct<"UnknownDependencyError", {
+    readonly sourcePath: Schema.String;
+    readonly referenceName: Schema.String;
+    readonly depPrefix: Schema.String;
+    readonly declaredDeps: Schema.$Array<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
 export declare class UnknownDependencyError extends UnknownDependencyError_base {
 }
-declare const DependencyCycleError_base: Schema.TaggedErrorClass<DependencyCycleError, "DependencyCycleError", {
-    readonly _tag: Schema.tag<"DependencyCycleError">;
-} & {
-    cycle: Schema.Array$<typeof Schema.String>;
-}>;
+declare const DependencyCycleError_base: Schema.Class<DependencyCycleError, Schema.TaggedStruct<"DependencyCycleError", {
+    readonly cycle: Schema.$Array<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
 export declare class DependencyCycleError extends DependencyCycleError_base {
 }
-declare const UnknownTargetError_base: Schema.TaggedErrorClass<UnknownTargetError, "UnknownTargetError", {
-    readonly _tag: Schema.tag<"UnknownTargetError">;
-} & {
-    target: typeof Schema.String;
-    supportedTargets: Schema.Array$<typeof Schema.String>;
-}>;
+declare const UnknownTargetError_base: Schema.Class<UnknownTargetError, Schema.TaggedStruct<"UnknownTargetError", {
+    readonly target: Schema.String;
+    readonly supportedTargets: Schema.$Array<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
 export declare class UnknownTargetError extends UnknownTargetError_base {
 }
-declare const InvalidTargetScopeError_base: Schema.TaggedErrorClass<InvalidTargetScopeError, "InvalidTargetScopeError", {
-    readonly _tag: Schema.tag<"InvalidTargetScopeError">;
-} & {
-    target: typeof Schema.String;
-    scope: typeof Schema.String;
-    message: typeof Schema.String;
-}>;
+declare const InvalidTargetScopeError_base: Schema.Class<InvalidTargetScopeError, Schema.TaggedStruct<"InvalidTargetScopeError", {
+    readonly target: Schema.String;
+    readonly scope: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
 export declare class InvalidTargetScopeError extends InvalidTargetScopeError_base {
 }
-declare const UnsupportedTargetCapabilityError_base: Schema.TaggedErrorClass<UnsupportedTargetCapabilityError, "UnsupportedTargetCapabilityError", {
-    readonly _tag: Schema.tag<"UnsupportedTargetCapabilityError">;
-} & {
-    target: typeof Schema.String;
-    capability: Schema.Literal<["compiled-agents", "hooks"]>;
-    message: typeof Schema.String;
-}>;
+declare const UnsupportedTargetCapabilityError_base: Schema.Class<UnsupportedTargetCapabilityError, Schema.TaggedStruct<"UnsupportedTargetCapabilityError", {
+    readonly target: Schema.String;
+    readonly capability: Schema.Literals<readonly ["compiled-agents", "hooks"]>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
 export declare class UnsupportedTargetCapabilityError extends UnsupportedTargetCapabilityError_base {
 }
-declare const AgentValidationError_base: Schema.TaggedErrorClass<AgentValidationError, "AgentValidationError", {
-    readonly _tag: Schema.tag<"AgentValidationError">;
-} & {
-    sourcePath: typeof Schema.String;
-    agentName: typeof Schema.String;
-    field: typeof Schema.String;
-    message: typeof Schema.String;
-}>;
+declare const AgentValidationError_base: Schema.Class<AgentValidationError, Schema.TaggedStruct<"AgentValidationError", {
+    readonly sourcePath: Schema.String;
+    readonly agentName: Schema.String;
+    readonly field: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
 export declare class AgentValidationError extends AgentValidationError_base {
 }
-declare const DuplicateNameError_base: Schema.TaggedErrorClass<DuplicateNameError, "DuplicateNameError", {
-    readonly _tag: Schema.tag<"DuplicateNameError">;
-} & {
-    kind: Schema.Literal<["identity", "personality", "agent", "modelspace", "skillspace", "sop", "tool", "hook"]>;
-    name: typeof Schema.String;
-    firstPath: typeof Schema.String;
-    secondPath: typeof Schema.String;
-}>;
+declare const DuplicateNameError_base: Schema.Class<DuplicateNameError, Schema.TaggedStruct<"DuplicateNameError", {
+    readonly kind: Schema.Literals<readonly ["identity", "personality", "agent", "modelspace", "skillspace", "sop", "tool", "hook"]>;
+    readonly name: Schema.String;
+    readonly firstPath: Schema.String;
+    readonly secondPath: Schema.String;
+}>, import("effect/Cause").YieldableError>;
 export declare class DuplicateNameError extends DuplicateNameError_base {
 }
-declare const AgentNameMismatchError_base: Schema.TaggedErrorClass<AgentNameMismatchError, "AgentNameMismatchError", {
-    readonly _tag: Schema.tag<"AgentNameMismatchError">;
-} & {
-    sourcePath: typeof Schema.String;
-    fileStem: typeof Schema.String;
-    agentName: typeof Schema.String;
-}>;
+declare const AgentNameMismatchError_base: Schema.Class<AgentNameMismatchError, Schema.TaggedStruct<"AgentNameMismatchError", {
+    readonly sourcePath: Schema.String;
+    readonly fileStem: Schema.String;
+    readonly agentName: Schema.String;
+}>, import("effect/Cause").YieldableError>;
 export declare class AgentNameMismatchError extends AgentNameMismatchError_base {
 }
-declare const MissingTargetResolutionError_base: Schema.TaggedErrorClass<MissingTargetResolutionError, "MissingTargetResolutionError", {
-    readonly _tag: Schema.tag<"MissingTargetResolutionError">;
-} & {
-    agentName: typeof Schema.String;
-    referenceKind: Schema.Literal<["model-profile", "skill"]>;
-    referenceName: typeof Schema.String;
-    target: typeof Schema.String;
-}>;
+declare const MissingTargetResolutionError_base: Schema.Class<MissingTargetResolutionError, Schema.TaggedStruct<"MissingTargetResolutionError", {
+    readonly agentName: Schema.String;
+    readonly referenceKind: Schema.Literals<readonly ["model-profile", "skill"]>;
+    readonly referenceName: Schema.String;
+    readonly target: Schema.String;
+}>, import("effect/Cause").YieldableError>;
 export declare class MissingTargetResolutionError extends MissingTargetResolutionError_base {
 }
 export type CompileError = SourceParseError | UnknownReferenceError | AgentValidationError | UnknownTargetError | InvalidTargetScopeError | UnsupportedTargetCapabilityError | DuplicateNameError | AgentNameMismatchError | MissingTargetResolutionError | UnknownDependencyError | DependencyCycleError | PluginManifestError;

package/types/compile/runtime/schema-bridge.d.ts

@@ -5,16 +5,18 @@
  *
  * Supports the bounded schema feature set used in contracts:
  *
- *   - StringKeyword, NumberKeyword, BooleanKeyword, UnknownKeyword
- *   - Literal (single) and Union of Literals (enum)
- *   - TupleType with rest (arrays)
- *   - TypeLiteral (nested structs)
- *   - Refinement and Transformation (unwrapped; brands preserved via description)
- *   - optional fields
+ *   - String, Number, Boolean, Null
+ *   - Unknown, Any (rendered honestly as z.unknown(): any JSON value)
+ *   - Literal (single), Union of Literals (enum), and general unions (z.union)
+ *   - Arrays with a single rest element (arrays)
+ *   - Objects (nested structs), including optional fields
+ *   - Records (`Schema.Record`) including mixed struct+index objects (catchall)
+ *   - checks (refinements) and encodings (transformations) are rendered as
+ *     their wire shape
+ *   - nominal brands add no runtime validation and are not emitted
  *
- * Annotations flow through: a field's Schema.annotations({ description }) is
- * emitted as .describe(...) on the tool schema node so the LLM sees the
- * contract's own documentation.
+ * A field's Schema.annotate({ description }) is emitted as .describe(...) on the
+ * tool schema node so the LLM sees the contract's own documentation.
  */
 import { tool } from "@opencode-ai/plugin";
 import { Schema } from "effect";
@@ -51,11 +53,12 @@ export interface ToolRuntimeContext {
  * Convert a top-level Schema.Struct to the args record opencode expects.
  * Throws at plugin load time if the top-level schema is not a struct.
  */
-export declare const toolArgsFromSchema: (schema: Schema.Schema.Any) => Record<string, ZodNode>;
+export declare const toolArgsFromSchema: (schema: Schema.Top) => Record<string, ZodNode>;
 /**
  * Decode raw tool-call args against the contract's Input schema. Throws a
  * clear error if decoding fails; the error propagates back to the LLM as the
- * tool call's failure message.
+ * tool call's failure message. Strict on excess properties: a misspelled
+ * field is a typo to surface, not noise to strip.
  */
-export declare const decodeInput: <A, I, R>(schema: Schema.Schema<A, I, R>, raw: unknown) => A;
+export declare const decodeInput: <S extends Schema.Codec<unknown, unknown, never, never>>(schema: S, raw: unknown) => S["Type"];
 export {};

package/types/errors.d.ts

@@ -16,15 +16,13 @@
  */
 import { Schema } from "effect";
 import { type CompileError } from "./compile/errors.js";
-declare const PluginManifestError_base: Schema.TaggedErrorClass<PluginManifestError, "PluginManifestError", {
-    readonly _tag: Schema.tag<"PluginManifestError">;
-} & {
-    pluginPath: typeof Schema.String;
-    manifestPath: typeof Schema.String;
-    pluginLabel: typeof Schema.String;
-    summary: typeof Schema.String;
-    details: Schema.Array$<typeof Schema.String>;
-}>;
+declare const PluginManifestError_base: Schema.Class<PluginManifestError, Schema.TaggedStruct<"PluginManifestError", {
+    readonly pluginPath: Schema.String;
+    readonly manifestPath: Schema.String;
+    readonly pluginLabel: Schema.String;
+    readonly summary: Schema.String;
+    readonly details: Schema.$Array<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
 export declare class PluginManifestError extends PluginManifestError_base {
     /**
      * Build a manifest error from just a plugin path + summary, deriving the
@@ -35,39 +33,31 @@ export declare class PluginManifestError extends PluginManifestError_base {
     }): PluginManifestError;
     get message(): string;
 }
-declare const PrismConfigError_base: Schema.TaggedErrorClass<PrismConfigError, "PrismConfigError", {
-    readonly _tag: Schema.tag<"PrismConfigError">;
-} & {
-    message: typeof Schema.String;
-}>;
+declare const PrismConfigError_base: Schema.Class<PrismConfigError, Schema.TaggedStruct<"PrismConfigError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
 export declare class PrismConfigError extends PrismConfigError_base {
 }
-declare const BundleBuildError_base: Schema.TaggedErrorClass<BundleBuildError, "BundleBuildError", {
-    readonly _tag: Schema.tag<"BundleBuildError">;
-} & {
-    bundleKind: typeof Schema.String;
-    diagnostics: typeof Schema.String;
-}>;
+declare const BundleBuildError_base: Schema.Class<BundleBuildError, Schema.TaggedStruct<"BundleBuildError", {
+    readonly bundleKind: Schema.String;
+    readonly diagnostics: Schema.String;
+}>, import("effect/Cause").YieldableError>;
 export declare class BundleBuildError extends BundleBuildError_base {
     get message(): string;
 }
-declare const BlockedTargetError_base: Schema.TaggedErrorClass<BlockedTargetError, "BlockedTargetError", {
-    readonly _tag: Schema.tag<"BlockedTargetError">;
-} & {
-    targetPath: typeof Schema.String;
-    plugin: typeof Schema.String;
-    hint: typeof Schema.String;
-}>;
+declare const BlockedTargetError_base: Schema.Class<BlockedTargetError, Schema.TaggedStruct<"BlockedTargetError", {
+    readonly targetPath: Schema.String;
+    readonly plugin: Schema.String;
+    readonly hint: Schema.String;
+}>, import("effect/Cause").YieldableError>;
 export declare class BlockedTargetError extends BlockedTargetError_base {
     get message(): string;
 }
-declare const PathConflictError_base: Schema.TaggedErrorClass<PathConflictError, "PathConflictError", {
-    readonly _tag: Schema.tag<"PathConflictError">;
-} & {
-    targetPath: typeof Schema.String;
-    firstPlugin: typeof Schema.String;
-    secondPlugin: typeof Schema.String;
-}>;
+declare const PathConflictError_base: Schema.Class<PathConflictError, Schema.TaggedStruct<"PathConflictError", {
+    readonly targetPath: Schema.String;
+    readonly firstPlugin: Schema.String;
+    readonly secondPlugin: Schema.String;
+}>, import("effect/Cause").YieldableError>;
 export declare class PathConflictError extends PathConflictError_base {
     get message(): string;
 }

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

@@ -10,6 +10,7 @@
  *
  * These helpers are identity constructors for authoring ergonomics.
  */
+export * from "./jev.js";
 export * from "./workflow-errors.js";
 export * from "./workflow-harness-detection.js";
 export * from "./workflows.js";
@@ -43,7 +44,7 @@ export interface SkillspaceRefDefinition {
 export type AgentRefInput = string | AgentRefDefinition;
 export type ModelProfileRefInput = string | ModelProfileRefDefinition;
 export type SkillRefInput = SkillRefDefinition | SkillspaceRefDefinition;
-export type EffectSchemaValue = import("effect").Schema.Schema.AnyNoContext;
+export type EffectSchemaValue = import("effect").Schema.Top;
 export interface AgentDefinition {
     readonly name: string;
     readonly description: string;
@@ -98,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;
 }
@@ -106,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;