@skastr0/prism-darwin-x64 0.1.0 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skastr0/prism-darwin-x64",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "description": "Prism standalone CLI binary for macOS x64.",
   "license": "MIT",
@@ -16,6 +16,13 @@
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.29.0",
+    "@opencode-ai/plugin": "^1.15.13",
+    "effect": "^3.21.1",
+    "typescript": "^5.8.3",
+    "zod": "4.4.3"
+  },
   "os": [
     "darwin"
   ],
@@ -24,6 +31,7 @@
   ],
   "files": [
     "bin",
+    "types",
     "LICENSE"
   ]
 }

package/types/compile/bundle-utils.d.ts

@@ -0,0 +1,16 @@
+export declare const NODE_BUILTIN_EXTERNALS: string[];
+export declare const BARE_IMPORT_PATTERN: RegExp;
+export declare const RELATIVE_IMPORT_PATTERN: RegExp;
+export declare const collectRelativeImportSpecifiers: (source: string) => string[];
+export declare const packageNameFromSpecifier: (specifier: string) => string;
+export declare const relativeModulePath: (fromFile: string, toFileWithoutExtension: string) => string;
+export declare const resolveImportedSourcePath: (sourcePath: string, source: string) => string;
+export declare const stripToolAuthoringHelpers: (source: string) => string;
+export declare const rewriteGeneratedPluginBundleImports: (source: string, currentGeneratedPath: string) => string;
+export declare const resolveTsImportCandidate: (absoluteWithoutQuery: string, fileExists: (path: string) => Promise<boolean>) => Promise<string | undefined>;
+export declare const rewriteBareImportsForBundle: (source: string, replacements: ReadonlyMap<string, string>) => string;
+export declare const rewriteBareEffectImportsForBundle: (source: string) => string;
+export declare const rewriteBarePluginDependencyImportsForBundle: (options: {
+    readonly source: string;
+    readonly pluginRoot?: string;
+}) => Promise<string>;

package/types/compile/cache.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Content-addressable cache for compiled agents.
+ *
+ * Cache key: hash(normalized source fingerprint + target + scope + compiler semantics)
+ * Cache value: serialized ComposedAgent + primary output hashes.
+ */
+import type { ComposedAgent } from "./compose.js";
+import type { Agent } from "./sources.js";
+import type { PluginRegistry } from "./registry.js";
+interface CacheContext {
+    readonly target: string;
+    readonly scope: string;
+}
+export declare const CACHE_FORMAT_VERSION = 3;
+/**
+ * Bump this whenever compile/lowering semantics change without a corresponding
+ * source DSL change. This prevents stale composed agents from surviving compiler
+ * fixes such as generated tool naming or permission-lowering changes.
+ */
+export declare const COMPILER_SEMANTICS_VERSION = "2026-06-12-compose-manifest-metadata-v1";
+export interface CacheInputFile {
+    readonly plugin: string;
+    readonly path: string;
+    readonly contentHash: string;
+}
+export interface AgentCacheDescriptor {
+    readonly key: string;
+    readonly sourceHash: string;
+    readonly contextHash: string;
+    readonly inputs: ReadonlyArray<CacheInputFile>;
+}
+export interface CacheEntry {
+    readonly key: string;
+    readonly sourceHash: string;
+    readonly contextHash: string;
+    readonly composed: ComposedAgent;
+    readonly outputs: Record<string, string>;
+    readonly timestamp: string;
+}
+export declare const computeCacheKey: (agentSource: string, options: CacheContext) => string;
+export declare const computeContentHash: (content: string) => string;
+export declare const computeStableHash: (value: unknown) => string;
+export declare const computeContextHash: (options: CacheContext) => string;
+export declare const computeAgentCacheDescriptor: (agent: Agent, registry: PluginRegistry, options: CacheContext) => Promise<AgentCacheDescriptor>;
+export declare const getCacheDir: (pluginPath: string) => string;
+export declare const readCacheEntry: (cacheDir: string, key: string) => Promise<CacheEntry | null>;
+export declare const writeCacheEntry: (cacheDir: string, entry: CacheEntry) => Promise<void>;
+export declare const cleanCache: (cacheDir: string) => Promise<void>;
+export {};

package/types/compile/compile-manifest.d.ts

@@ -0,0 +1,48 @@
+import { type CompileManifest, type HarnessId, type HarnessScope } from "@skastr0/prism-core/compile-manifest";
+import type { AgentCacheDescriptor } from "./cache.js";
+import type { ComposedAgent } from "./compose.js";
+import { type PluginRegistry } from "./registry.js";
+export * from "@skastr0/prism-core/compile-manifest";
+/**
+ * The per-project compile manifest partition
+ * (~/.prism/state/projects/<key>/compile-manifest.json). The project key
+ * dimension fixes the clobbering bug: two projects with a same-named local
+ * plugin no longer stomp each other in a single flat global manifest.
+ */
+export declare const compileManifestPath: (prismHome: string, projectKey: string) => string;
+export declare const isCompileManifestHarnessId: (value: string) => value is HarnessId;
+export interface CompileManifestReadResult {
+    readonly manifest: CompileManifest;
+    readonly quarantinedPath?: string;
+}
+export declare const readCompileManifest: (prismHome: string, projectKey: string) => Promise<CompileManifestReadResult>;
+export declare const commitCompileManifest: (options: {
+    readonly prismHome: string;
+    readonly projectKey: string;
+    readonly manifest: CompileManifest;
+}) => Promise<void>;
+export declare const buildCompileManifestForTarget: (options: {
+    readonly base: CompileManifest;
+    readonly registry: PluginRegistry;
+    readonly target: HarnessId;
+    readonly scope: HarnessScope;
+    readonly composed: ReadonlyArray<ComposedAgent>;
+    readonly cacheDescriptors: ReadonlyMap<string, AgentCacheDescriptor>;
+    /** When provided, this compile pass is authoritative for the source plugin's orbit identities (from prepareTargetOrbits, non-templates only). Threaded only for orbit-targeting compiles to avoid clearing on other targets. Minimal {name} shape (no sourcePath/phases/body). */
+    readonly orbits?: ReadonlyArray<{
+        readonly name: string;
+    }>;
+}) => CompileManifest;
+export declare const updateCompileManifestForTarget: (options: {
+    readonly prismHome: string;
+    readonly projectKey: string;
+    readonly registry: PluginRegistry;
+    readonly target: HarnessId;
+    readonly scope: HarnessScope;
+    readonly composed: ReadonlyArray<ComposedAgent>;
+    readonly cacheDescriptors: ReadonlyMap<string, AgentCacheDescriptor>;
+    /** Forwarded from surfaces.orbits pass in compilePluginForTarget; undefined means non-authoritative for orbits (carry base). */
+    readonly orbits?: ReadonlyArray<{
+        readonly name: string;
+    }>;
+}) => Promise<void>;

package/types/compile/compose.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Compose phase: take a ResolvedAgent and produce a target-agnostic
+ * ComposedAgent for the lowerers.
+ */
+import type { NormalizedOrbitPhase as OrbitPhase } from "./sources.js";
+import type { ResolvedAgent, ResolvedContractBinding } from "./resolve.js";
+export interface ComposedAgentManifestMetadata {
+    readonly traits: ReadonlyArray<{
+        readonly id: string;
+        readonly ref: string;
+    }>;
+    readonly modelBindings: {
+        readonly modelspace?: string;
+        readonly profile?: string;
+    };
+}
+export interface ComposedAgent {
+    readonly name: string;
+    readonly description: string;
+    readonly body: string;
+    readonly color: string | undefined;
+    readonly model: Record<string, unknown> | undefined;
+    readonly targetOverride: Record<string, unknown>;
+    readonly skills: ReadonlyArray<string>;
+    readonly allowedSkills: ReadonlyArray<string>;
+    readonly toolBindings: ReadonlyArray<ResolvedContractBinding>;
+    readonly allowedTools: ReadonlyArray<string>;
+    readonly manifest?: ComposedAgentManifestMetadata;
+}
+export interface ComposedOrbitPhaseReference {
+    readonly label: string;
+    readonly detailLines: ReadonlyArray<string>;
+}
+export declare const composeAgent: (resolved: ResolvedAgent) => ComposedAgent;
+export declare const composeOrbitPhaseReference: (phase: OrbitPhase) => ComposedOrbitPhaseReference;

package/types/compile/errors.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Typed compile errors for the structured compile-language pipeline.
+ *
+ * These tags are members of the `PrismError` union in src/errors.ts; the CLI
+ * edge renders them via `renderPrismError`/`renderPrismCause`. The canonical
+ * `PluginManifestError` lives in src/errors.ts (type-only import here keeps
+ * the modules cycle-free at runtime).
+ */
+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", "trait", "agent", "toolspace", "modelspace", "skillspace", "orbit", "tool", "hook"]>;
+    message: typeof Schema.String;
+}>;
+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", "trait", "tool", "tool-group", "skill", "orbit", "phase.orbit", "phase.agent"]>;
+    referenceName: typeof Schema.String;
+}>;
+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>;
+}>;
+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>;
+}>;
+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>;
+}>;
+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;
+}>;
+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", "generated-canonical-tools", "hooks", "skill-permissions"]>;
+    message: typeof Schema.String;
+}>;
+export declare class UnsupportedTargetCapabilityError extends UnsupportedTargetCapabilityError_base {
+}
+declare const OrbitValidationError_base: Schema.TaggedErrorClass<OrbitValidationError, "OrbitValidationError", {
+    readonly _tag: Schema.tag<"OrbitValidationError">;
+} & {
+    sourcePath: typeof Schema.String;
+    orbitName: typeof Schema.String;
+    field: typeof Schema.String;
+    message: typeof Schema.String;
+}>;
+export declare class OrbitValidationError extends OrbitValidationError_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;
+}>;
+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", "trait", "agent", "toolspace", "modelspace", "skillspace", "orbit", "tool", "hook"]>;
+    name: typeof Schema.String;
+    firstPath: typeof Schema.String;
+    secondPath: typeof Schema.String;
+}>;
+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;
+}>;
+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", "tool", "tool-group", "skill"]>;
+    referenceName: typeof Schema.String;
+    target: typeof Schema.String;
+}>;
+export declare class MissingTargetResolutionError extends MissingTargetResolutionError_base {
+}
+export type CompileError = SourceParseError | UnknownReferenceError | OrbitValidationError | AgentValidationError | UnknownTargetError | InvalidTargetScopeError | UnsupportedTargetCapabilityError | DuplicateNameError | AgentNameMismatchError | MissingTargetResolutionError | UnknownDependencyError | DependencyCycleError | PluginManifestError;
+export declare const formatCompileError: (error: CompileError) => string;
+export {};

package/types/compile/generated-plugin.d.ts

@@ -0,0 +1,8 @@
+import type { ResolvedContractBinding } from "./resolve.js";
+export declare const normalizeGeneratedPluginName: (pluginName: string) => string;
+export declare const sanitizeGeneratedToolSegment: (value: string, fallback: string) => string;
+export declare const generatedToolNamespace: (pluginName: string) => string;
+export declare const generatedOwnerToolName: (toolPluginName: string, toolName: string) => string;
+export declare const generatedSyntheticToolName: (sourcePluginName: string, contractName: string) => string;
+export declare const generatedToolNameForBinding: (sourcePluginName: string, binding: ResolvedContractBinding) => string;
+export declare const sourceIsInside: (sourcePath: string, root: string) => boolean;

package/types/compile/load.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Load phase: discover source files in a plugin and parse them into typed
+ * registry entries.
+ *
+ * Canonical structured artifacts are TypeScript-authored.
+ */
+import { Effect } from "effect";
+import { type CompileError } from "./errors.js";
+import { type PluginRegistry } from "./registry.js";
+export declare const getImportRuntimePaths: () => Promise<{
+    readonly authoring: string;
+    readonly effect: string;
+    readonly workflowDsl: string;
+}>;
+export interface PrepareImportWrapperOptions {
+    /** When true, resolve `prism`/`prism/refs` for workflow execution rather than plugin compilation. */
+    readonly workflow?: boolean;
+}
+export declare const prepareImportWrapper: (sourcePath: string, options?: PrepareImportWrapperOptions) => Promise<{
+    readonly specifier: string;
+    readonly cleanup: () => Promise<void>;
+}>;
+export declare const loadPlugin: (pluginPath: string) => Effect.Effect<PluginRegistry, CompileError>;

package/types/compile/paths.d.ts

@@ -0,0 +1,2 @@
+export declare const normalizeRelativePath: (from: string, to: string) => string;
+export declare const compareByStringKeys: <T>(first: (value: T) => string, second: (value: T) => string) => (left: T, right: T) => number;

package/types/compile/protocol-tools.d.ts

@@ -0,0 +1,47 @@
+import { Contract, type NormalizedTraitBinding, type Trait } from "./sources.js";
+import type { PluginRegistry } from "./registry.js";
+export interface ProtocolSurfaceError {
+    readonly field: string;
+    readonly message: string;
+}
+export interface ToolPermissionBinding {
+    readonly kind: "permission";
+    readonly logicalName: string;
+    readonly contract?: undefined;
+    readonly toolPluginName: string;
+    readonly toolName: string;
+    readonly toolSourcePath: string;
+}
+export interface SyntheticToolBinding {
+    readonly kind: "synthetic";
+    readonly logicalName: string;
+    readonly contract: Contract;
+    readonly toolPluginName: string;
+    readonly toolName: string;
+    readonly toolSourcePath: string;
+}
+export type MaterializedTraitTool = ToolPermissionBinding | SyntheticToolBinding;
+export type MaterializedOrbitToolPermission = MaterializedTraitTool;
+export type TraitBindingValidationResult = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly error: ProtocolSurfaceError;
+};
+type MaterializeTraitToolsOptions = {
+    readonly agentName: string;
+    readonly ownerPluginName: string;
+    readonly canonicalTraitId: string;
+    readonly trait: Trait;
+    readonly binding: NormalizedTraitBinding;
+    readonly registry: PluginRegistry;
+    readonly refRegistry?: PluginRegistry;
+};
+export declare const validateTraitBindingSlots: (trait: Trait, binding: NormalizedTraitBinding) => TraitBindingValidationResult;
+export declare const materializeTraitTools: (options: MaterializeTraitToolsOptions) => ReadonlyArray<MaterializedTraitTool> | ProtocolSurfaceError;
+export declare const materializeOrbitToolPermission: (options: {
+    readonly logicalName: string;
+    readonly toolRef: string;
+    readonly registry: PluginRegistry;
+}) => MaterializedOrbitToolPermission | ProtocolSurfaceError;
+export {};

package/types/compile/refs.d.ts

@@ -0,0 +1,7 @@
+import { Effect } from "effect";
+import { parseNamedRef, parseSpaceItemRef, registryForRef } from "@skastr0/prism-core/refs";
+import { type CompileError } from "./errors.js";
+import type { PluginRegistry } from "./registry.js";
+export { parseNamedRef, parseSpaceItemRef, registryForRef };
+export type { ParsedNamedRef, ParsedSpaceItemRef } from "@skastr0/prism-core/refs";
+export declare const resolveRefToRegistry: (ref: string, currentRegistry: PluginRegistry, sourcePath: string) => Effect.Effect<PluginRegistry, CompileError>;

package/types/compile/registry.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Plugin-local registry of parsed compile-language sources.
+ *
+ * Each registry owns its own source maps plus dep registries keyed by the dep
+ * alias declared in plugin.json. Bare refs resolve locally; prefixed refs
+ * resolve through the dep map.
+ */
+import { Agent, CanonicalTool, Hook, Identity, Orbit, Modelspace, Personality, Skill, Skillspace, Toolspace, Trait } from "./sources.js";
+import type { PluginManifestTargets, PluginRuntimeConfig } from "../types.js";
+export interface PluginRegistry {
+    pluginPath: string;
+    pluginName: string;
+    pluginVersion: string;
+    dependencyPaths: Record<string, string>;
+    targets: PluginManifestTargets;
+    runtime: PluginRuntimeConfig;
+    identities: Map<string, Identity>;
+    personalities: Map<string, Personality>;
+    toolspaces: Map<string, Toolspace>;
+    modelspaces: Map<string, Modelspace>;
+    skillspaces: Map<string, Skillspace>;
+    skills: Map<string, Skill>;
+    traits: Map<string, Trait>;
+    tools: Map<string, CanonicalTool>;
+    hooks: Map<string, Hook>;
+    orbits: Map<string, Orbit>;
+    agents: Map<string, Agent>;
+    deps: Map<string, PluginRegistry>;
+}
+export declare const emptyRegistry: (pluginPath: string, pluginName: string, pluginVersion: string, dependencyPaths?: Record<string, string>, targets?: PluginManifestTargets, runtime?: PluginRuntimeConfig) => PluginRegistry;
+export declare const collectPluginRegistries: (registry: PluginRegistry) => Map<string, PluginRegistry>;
+export type Registry = PluginRegistry;

package/types/compile/resolve.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Resolve phase: materialize referenced parts for each agent and validate
+ * orbit wiring against the loaded registry graph.
+ */
+import { Effect } from "effect";
+import { Agent, Contract, Identity, Orbit, Personality, Trait, type NormalizedTraitBinding } from "./sources.js";
+import { type CompileError } from "./errors.js";
+import type { PluginRegistry } from "./registry.js";
+export interface ResolvedContractBinding {
+    readonly kind: "permission" | "synthetic";
+    readonly logicalName: string;
+    readonly contract?: Contract;
+    readonly toolPluginName: string;
+    readonly toolName: string;
+    readonly toolSourcePath: string;
+}
+export interface ResolvedToolReference {
+    readonly kind: "permission" | "synthetic";
+    readonly logicalName: string;
+    readonly contract?: Contract;
+    readonly toolPluginName: string;
+    readonly toolName: string;
+    readonly toolSourcePath: string;
+}
+export interface ResolvedTrait {
+    readonly ref: string;
+    readonly canonicalId: string;
+    readonly trait: Trait;
+    readonly owner: PluginRegistry;
+    readonly binding: NormalizedTraitBinding;
+}
+export interface ResolvedAgentCapabilities {
+    readonly agent: Agent;
+    readonly traits: ReadonlyArray<ResolvedTrait>;
+    readonly canonicalTraitIds: ReadonlyArray<string>;
+    readonly skills: ReadonlyArray<string>;
+    readonly toolRefs: ReadonlyArray<ResolvedToolReference>;
+    readonly access: {
+        readonly tools: ReadonlyArray<string>;
+        readonly toolGroups: ReadonlyArray<string>;
+        readonly skills: ReadonlyArray<string>;
+    };
+}
+export interface ResolvedAgent {
+    readonly agent: Agent;
+    readonly identity: Identity;
+    readonly personality: Personality | undefined;
+    readonly resolvedModel: Record<string, unknown> | undefined;
+    readonly traits: ReadonlyArray<ResolvedTrait>;
+    readonly canonicalTraitIds: ReadonlyArray<string>;
+    readonly skills: ReadonlyArray<string>;
+    readonly allowedSkills: ReadonlyArray<string>;
+    readonly toolBindings: ReadonlyArray<ResolvedContractBinding>;
+    readonly allowedTools: ReadonlyArray<string>;
+}
+type BindingMap = Readonly<Record<string, string>>;
+export declare const resolveAgentCapabilities: (agent: Agent, registry: PluginRegistry) => Effect.Effect<ResolvedAgentCapabilities, CompileError>;
+export declare const resolveAgent: (agent: Agent, registry: PluginRegistry, target: string) => Effect.Effect<ResolvedAgent, CompileError>;
+export declare const instantiateOrbit: (orbit: Orbit, bindings?: BindingMap) => Effect.Effect<Orbit, CompileError>;
+export declare const resolveOrbitSkillPermissions: (orbits: ReadonlyArray<Orbit>, registry: PluginRegistry) => ReadonlyMap<string, ReadonlyArray<string>>;
+export declare const resolveOrbitToolPermissions: (orbits: ReadonlyArray<Orbit>, registry: PluginRegistry) => Effect.Effect<ReadonlyMap<string, ReadonlyArray<ResolvedContractBinding>>, CompileError>;
+export declare const validateOrbit: (orbit: Orbit, registry: PluginRegistry) => Effect.Effect<void, CompileError>;
+export {};

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

@@ -0,0 +1,61 @@
+/**
+ * Schema bridge: converts Effect Schema → the record of tool.schema builders
+ * that opencode's `tool({ args })` expects. Ships verbatim into every
+ * generated plugin at src/runtime/schema-bridge.ts.
+ *
+ * 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
+ *
+ * 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.
+ */
+import { tool } from "@opencode-ai/plugin";
+import { Schema } from "effect";
+type ZodNode = Parameters<(typeof tool.schema)["array"]>[0] & {
+    describe(description: string): ZodNode;
+    optional(): ZodNode;
+};
+export interface ToolRuntimeCost {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+    estimatedCost?: number;
+    currency?: string;
+}
+/**
+ * Runtime context passed to synthetic contract handlers.
+ *
+ * The generated OpenCode adapter always provides `sessionID`, `agent`, and
+ * `timestamp`. Additional metadata stays optional so contract authors can
+ * tolerate harnesses that do not expose the richer fields yet.
+ */
+export interface ToolRuntimeContext {
+    sessionID: string;
+    agent: string;
+    timestamp: string;
+    sessionTitle?: string;
+    durationMs?: number;
+    cost?: ToolRuntimeCost;
+    workingDirectory?: string;
+    repoRoot?: string;
+    signal?: AbortSignal;
+}
+/**
+ * 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>;
+/**
+ * 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.
+ */
+export declare const decodeInput: <A, I, R>(schema: Schema.Schema<A, I, R>, raw: unknown) => A;
+export {};

package/types/compile/runtime-deps.d.ts

@@ -0,0 +1,6 @@
+export declare const effectBundleImportPath: () => string;
+export declare const mcpSdkMcpBundleImportPath: () => string;
+export declare const mcpSdkWebStandardHttpBundleImportPath: () => string;
+export declare const opencodePluginBundleImportPath: () => string;
+export declare const typescriptBundleImportPath: () => string;
+export declare const zodV4BundleImportPath: () => string;