@skastr0/prism-linux-x64 0.1.1 → 0.1.2

package/types/content-hash.d.ts

@@ -0,0 +1 @@
+export declare const computeContentHash: (content: string | Uint8Array) => string;

package/types/errors.d.ts

@@ -0,0 +1,107 @@
+/**
+ * PrismError — the single tagged-error vocabulary that survives the
+ * one-writer overhaul (docs/overhaul-one-writer-plan.md, WS2).
+ *
+ * Every failure Prism shows a human goes through this module:
+ *   - one `PrismError` union the CLI edge can exhaustively match,
+ *   - `renderPrismError` / `renderPrismCause` as the only renderers
+ *     (one-line headline, optional indented detail, a `hint:` line),
+ *   - never a stack trace.
+ *
+ * Compile-language errors keep living in `src/compile/errors.ts` (they are
+ * constructed throughout the compile pipeline); this module absorbs them into
+ * the union instead of duplicating them. New error families added by later
+ * workstreams (SnapshotDecodeError, RegionPatchError, BlockedTargetError,
+ * McpSupervisorError, TokenStoreError, …) join the union here.
+ */
+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>;
+}>;
+export declare class PluginManifestError extends PluginManifestError_base {
+    /**
+     * Build a manifest error from just a plugin path + summary, deriving the
+     * manifest path and plugin label.
+     */
+    static forPlugin(pluginPath: string, summary: string, details?: ReadonlyArray<string>, options?: {
+        readonly pluginName?: string;
+    }): PluginManifestError;
+    get message(): string;
+}
+declare const PrismConfigError_base: Schema.TaggedErrorClass<PrismConfigError, "PrismConfigError", {
+    readonly _tag: Schema.tag<"PrismConfigError">;
+} & {
+    message: typeof Schema.String;
+}>;
+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;
+}>;
+export declare class BundleBuildError extends BundleBuildError_base {
+    get message(): string;
+}
+declare const McpBundleMissingError_base: Schema.TaggedErrorClass<McpBundleMissingError, "McpBundleMissingError", {
+    readonly _tag: Schema.tag<"McpBundleMissingError">;
+} & {
+    pluginName: typeof Schema.String;
+    bundlePath: typeof Schema.String;
+}>;
+export declare class McpBundleMissingError extends McpBundleMissingError_base {
+    get hint(): string;
+    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;
+}>;
+export declare class BlockedTargetError extends BlockedTargetError_base {
+    get message(): string;
+}
+/**
+ * Every typed error Prism may surface to a human. `CompileError` (which
+ * includes `PluginManifestError`) is defined in src/compile/errors.ts.
+ */
+export type PrismError = CompileError | PrismConfigError | BundleBuildError | McpBundleMissingError | BlockedTargetError;
+export declare const PRISM_ERROR_TAGS: ReadonlySet<string>;
+export declare const isPrismError: (value: unknown) => value is PrismError;
+export interface PrismErrorRender {
+    /** One line; never multi-line, never a stack frame. */
+    readonly headline: string;
+    /** Optional extra lines, rendered indented under the headline. */
+    readonly detail?: ReadonlyArray<string>;
+    /** Remediation; rendered as a trailing `hint: …` line. */
+    readonly hint: string;
+    /** Filesystem path the error is about, when it has one. */
+    readonly path?: string;
+}
+export declare const describePrismError: (error: PrismError) => PrismErrorRender;
+/** Render a PrismError for humans: headline, indented detail, hint line. */
+export declare const renderPrismError: (error: PrismError) => string;
+export interface PrismCauseDescription {
+    readonly headline: string;
+    readonly detail?: ReadonlyArray<string>;
+    readonly hint?: string;
+    readonly path?: string;
+}
+/**
+ * Walk an Effect Cause (or any thrown value) and describe the first Prism
+ * error found. Unknown defects render name + message only — never `.stack`.
+ */
+export declare const describePrismCause: (cause: unknown) => PrismCauseDescription;
+/** Render a whole Cause for humans. The single edge renderer. */
+export declare const renderPrismCause: (cause: unknown) => string;
+export {};

package/types/fs.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Filesystem utilities using Bun APIs
+ */
+/**
+ * Expand ~ to home directory
+ */
+export declare function expandPath(path: string): string;
+/**
+ * Check if a path exists (file or directory)
+ */
+export declare function exists(path: string): Promise<boolean>;
+/**
+ * Check if path is a directory
+ */
+export declare function isDirectory(path: string): Promise<boolean>;
+/**
+ * Read file contents as string
+ */
+export declare function readFile(path: string): Promise<string>;
+/**
+ * Read and parse JSON file
+ */
+export declare function readJson<T>(path: string): Promise<T>;
+/**
+ * Write string content to file
+ */
+export declare function writeFile(path: string, content: string, options?: {
+    readonly mode?: number;
+}): Promise<void>;
+export declare function chmodFile(path: string, mode: number): Promise<void>;
+/**
+ * Copy a file from source to target
+ */
+export declare function copyFile(source: string, target: string): Promise<void>;
+export declare function pathContains(parentPath: string, childPath: string): boolean;
+export declare function realPathContainedBy(rootPath: string, candidatePath: string): Promise<string | null>;
+/**
+ * Append content to a file (creates if doesn't exist)
+ */
+export declare function appendFile(path: string, content: string): Promise<void>;
+/**
+ * Ensure directory exists (recursive mkdir)
+ */
+export declare function ensureDir(path: string): Promise<void>;
+/**
+ * List files in a directory (non-recursive)
+ */
+export declare function listDir(path: string): Promise<string[]>;
+/**
+ * List files in a directory recursively
+ */
+export declare function listDirRecursive(path: string): Promise<string[]>;
+/**
+ * Remove a file
+ */
+export declare function removeFile(path: string): Promise<void>;
+/**
+ * Remove a directory recursively
+ */
+export declare function removeDir(path: string): Promise<void>;

package/types/harnesses.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Harness registry - configurations for all supported AI coding harnesses
+ */
+import type { HarnessConfig, HarnessId, HarnessScope } from "./types.js";
+export declare const HARNESSES: Record<HarnessId, HarnessConfig>;
+export declare function getHarness(id: HarnessId): HarnessConfig;
+export declare function getAllHarnessIds(): HarnessId[];
+export declare function isValidHarnessId(id: string): id is HarnessId;
+export declare function resolveHarnessRoot(harness: HarnessConfig, scope: HarnessScope, projectPath?: string): string | null;
+export declare function harnessSupportsProjectScope(harness: HarnessConfig): boolean;

package/types/index.d.ts

@@ -0,0 +1,493 @@
+/**
+ * Public authoring API for structured compile-language artifacts.
+ *
+ * The canonical structured source model is TypeScript-first:
+ * - agents/*.agent.ts
+ * - traits/*.trait.ts
+ * - orbits/*.orbit.ts
+ * - toolspaces/*.toolspace.ts
+ * - modelspaces/*.modelspace.ts
+ * - skillspaces/*.skillspace.ts
+ * - hooks/*.hook.ts
+ *
+ * These helpers are identity constructors for authoring ergonomics.
+ */
+export * from "./workflows.js";
+export * from "./workflow-tsconfig.js";
+export * from "./workflow-antigravity-worker.js";
+export * from "./workflow-amp-worker.js";
+export * from "./workflow-claude-worker.js";
+export * from "./workflow-codex-worker.js";
+export * from "./workflow-loader.js";
+export * from "./workflow-opencode-worker.js";
+export * from "./workflow-runner.js";
+export * from "./workflow-store.js";
+export * from "./workflow-worker-contract.js";
+export * from "./workflow-worker-metadata.js";
+export * from "./workflow-workers.js";
+export interface NamedRefDefinition {
+    readonly plugin?: string;
+    readonly name: string;
+}
+export interface TraitRefDefinition extends NamedRefDefinition {
+    readonly kind: "trait-ref";
+}
+export interface AgentRefDefinition extends NamedRefDefinition {
+    readonly kind: "agent-ref";
+}
+export interface OrbitRefDefinition extends NamedRefDefinition {
+    readonly kind: "orbit-ref";
+}
+export interface ToolRefDefinition {
+    readonly kind: "tool-ref";
+    readonly plugin?: string;
+    readonly toolspace: string;
+    readonly name: string;
+}
+export interface ToolGroupRefDefinition {
+    readonly kind: "tool-group-ref";
+    readonly plugin?: string;
+    readonly toolspace: string;
+    readonly name: string;
+}
+export interface ModelProfileRefDefinition {
+    readonly kind: "model-profile-ref";
+    readonly plugin?: string;
+    readonly modelspace: string;
+    readonly name: string;
+}
+export interface SkillRefDefinition {
+    readonly kind: "skill-ref";
+    readonly plugin?: string;
+    readonly name: string;
+}
+export interface SkillspaceRefDefinition {
+    readonly kind: "skillspace-ref";
+    readonly plugin?: string;
+    readonly skillspace: string;
+    readonly name: string;
+}
+export type TraitRefInput = string | TraitRefDefinition;
+export type AgentRefInput = string | AgentRefDefinition;
+export type OrbitRefInput = string | OrbitRefDefinition;
+export type ToolRefInput = string | ToolRefDefinition;
+export type ToolGroupRefInput = string | ToolGroupRefDefinition;
+export type ModelProfileRefInput = string | ModelProfileRefDefinition;
+export type SkillRefInput = SkillRefDefinition | SkillspaceRefDefinition;
+export type EffectSchemaValue = import("effect").Schema.Schema.AnyNoContext;
+export interface AccessDefinition {
+    readonly tools?: ReadonlyArray<ToolRefInput>;
+    readonly toolGroups?: ReadonlyArray<ToolGroupRefInput>;
+    readonly skills?: ReadonlyArray<SkillRefInput>;
+}
+export interface AgentDefinition {
+    readonly name: string;
+    readonly description: string;
+    readonly identity: string;
+    readonly personality?: string;
+    readonly model?: ModelProfileRefInput;
+    readonly traits?: ReadonlyArray<TraitRefInput | TraitBindingSource>;
+    readonly access?: AccessDefinition;
+    readonly skills?: ReadonlyArray<SkillRefInput>;
+    readonly color?: string;
+    readonly targets?: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+}
+export type AgentSource = AgentDefinition;
+export interface CanonicalToolDefinition {
+    readonly name: string;
+    readonly description: string;
+    readonly input: EffectSchemaValue;
+    readonly output: EffectSchemaValue;
+    readonly slots?: Readonly<Record<string, ToolSlotDefinition>>;
+    readonly handle: (input: unknown, context: import("./compile/runtime/schema-bridge").ToolRuntimeContext) => Promise<unknown>;
+}
+export type ToolSource = CanonicalToolDefinition;
+export interface TraitDefinition {
+    readonly name: string;
+    readonly description?: string;
+    readonly instructions?: string | ReadonlyArray<string>;
+    readonly access?: AccessDefinition;
+    readonly tools?: Readonly<Record<string, TraitToolAttachmentDefinition>>;
+    readonly inject?: {
+        readonly skills?: ReadonlyArray<SkillRefInput>;
+    };
+    readonly require?: {
+        readonly tools?: ReadonlyArray<string>;
+        readonly skills?: ReadonlyArray<SkillRefInput>;
+    };
+}
+export type TraitSource = TraitDefinition;
+export interface TraitBindingDefinition {
+    readonly kind: "trait-binding";
+    readonly trait: TraitRefInput;
+    readonly tools?: Readonly<Record<string, TraitBindingToolDefinition>>;
+}
+export interface PlainTraitBindingDefinition {
+    readonly trait: TraitRefInput;
+    readonly tools?: Readonly<Record<string, TraitBindingToolDefinition>>;
+}
+export type TraitBindingSource = TraitBindingDefinition | PlainTraitBindingDefinition;
+export interface ToolSchemaSlotDefinition {
+    readonly kind: "schema";
+    readonly description?: string;
+}
+export type ToolSlotDefinition = ToolSchemaSlotDefinition;
+export interface TraitBindingToolDefinition {
+    readonly slots?: Readonly<Record<string, EffectSchemaValue>>;
+}
+export interface TraitToolAttachmentDefinition {
+    readonly ref: string;
+}
+export interface OrbitParameterDefinition {
+    readonly name: string;
+    readonly description?: string;
+    readonly required?: boolean;
+}
+export interface OrbitBindingDefinition {
+    readonly orbit: OrbitRefInput;
+    readonly bindings?: Readonly<Record<string, string>>;
+}
+export interface OrbitTraitRequirementDefinition {
+    readonly all: ReadonlyArray<TraitRefInput>;
+    readonly min?: number;
+}
+export type OrbitToolPermissionToolDefinition = string | {
+    readonly ref: string;
+    readonly as?: string;
+};
+export interface OrbitOrchestratorDefinition {
+    readonly agent: AgentRefInput;
+    readonly tools: ReadonlyArray<OrbitToolPermissionToolDefinition>;
+}
+export interface OrbitPhaseWorkflowDefinition {
+    readonly when?: string;
+    readonly inputs?: ReadonlyArray<string>;
+    readonly outputs?: ReadonlyArray<string>;
+    readonly sequence?: ReadonlyArray<string>;
+    readonly coordination?: string;
+    readonly finish_criteria?: ReadonlyArray<string>;
+    readonly escalation?: string;
+}
+export interface OrbitPhaseDefinition {
+    readonly name: string;
+    readonly orbit?: OrbitRefInput;
+    readonly orbit_binding?: OrbitBindingDefinition;
+    readonly agents?: ReadonlyArray<AgentRefInput>;
+    readonly agent?: AgentRefInput;
+    readonly requires?: ReadonlyArray<OrbitTraitRequirementDefinition>;
+    readonly notes?: Readonly<Record<string, string>>;
+    /**
+     * Short structured fields rendered into the root orbit SKILL.md per-phase
+     * block. Use these to describe the phase at a glance; deep content belongs
+     * in `body` (which lowers to `references/<phase>.md`).
+     */
+    readonly telos?: string;
+    readonly real_world_change?: string;
+    readonly cold_pickup_test?: string;
+    /**
+     * Generic workflow-authoring guidance for this phase. Prism renders this
+     * into generated orbit skills, but does not attach runtime semantics to it.
+     */
+    readonly workflow?: OrbitPhaseWorkflowDefinition;
+    /**
+     * Long-form markdown for this phase. When present, lowerers write it to
+     * `references/<phase-name>.md` next to the orbit SKILL.md. Treat this as
+     * the full phase download — telos, procrastination shapes, per-agent
+     * focus, links to deeper modules.
+     */
+    readonly body?: string;
+}
+export interface OrbitPulsarCheckpointDefinition {
+    readonly after?: string;
+    readonly before?: string;
+    readonly note?: string;
+}
+export type OrbitSignalEmitterPriority = "low" | "normal" | "high" | "urgent";
+export interface OrbitSignalEmitterDestinationDefinition {
+    readonly project_key: string;
+    readonly orbit: string;
+    readonly default_priority?: OrbitSignalEmitterPriority;
+    readonly note?: string;
+}
+export interface OrbitSignalEmitterDefinition {
+    /**
+     * Known destinations this orbit may emit signals to. Each entry is a
+     * `project_key`/`orbit` pair, optionally with a default priority and a
+     * note describing what the destination handles. Used as structural
+     * documentation, as input for delegation-map validation, and as the
+     * basis for tighter bound trait surfaces (e.g., per-destination
+     * delegate wrappers) when wanted.
+     *
+     * Leaving this empty marks the orbit as an emitter without constraining
+     * destinations — appropriate when the routing table is fluid or
+     * authored entirely in agent doctrine. Filled destinations make the
+     * permission surface explicit and reviewable.
+     */
+    readonly destinations?: ReadonlyArray<OrbitSignalEmitterDestinationDefinition>;
+}
+export interface OrbitDefinitionEntryDefinition {
+    readonly purpose: string;
+    readonly contains?: ReadonlyArray<string>;
+    readonly boundaries?: ReadonlyArray<string>;
+    readonly avoid?: ReadonlyArray<string>;
+}
+export interface OrbitDefinitionsDefinition {
+    readonly glyphs?: OrbitDefinitionEntryDefinition;
+    readonly dispatches?: OrbitDefinitionEntryDefinition;
+    readonly chatter?: OrbitDefinitionEntryDefinition;
+    readonly signals?: OrbitDefinitionEntryDefinition;
+}
+export interface OrbitDefinition {
+    readonly name: string;
+    readonly description: string;
+    readonly produces?: string;
+    readonly definitions?: OrbitDefinitionsDefinition;
+    readonly parameters?: ReadonlyArray<OrbitParameterDefinition>;
+    readonly phases: ReadonlyArray<OrbitPhaseDefinition>;
+    readonly orchestrator?: OrbitOrchestratorDefinition;
+    readonly tool_permissions?: ReadonlyArray<OrbitToolPermissionToolDefinition>;
+    readonly pulsar_checkpoints?: ReadonlyArray<OrbitPulsarCheckpointDefinition>;
+    readonly evolution?: string;
+    readonly body?: string;
+    /**
+     * When present, declares this orbit emits signals to other orbits — the
+     * routing/delegation surface that is privileged separately from the
+     * receive-side signal tools. Authors should attach the `signal-emitter`
+     * trait (from the `oracle` plugin) to the orchestrator agent (and to
+     * any other phase agent that authentically owns inter-orbit
+     * delegation). Declared `destinations` make the routing surface
+     * explicit and auditable.
+     */
+    readonly signal_emitter?: OrbitSignalEmitterDefinition;
+}
+export type OrbitSource = OrbitDefinition;
+export interface ToolTargetBindingDefinition {
+    readonly name: string;
+}
+export interface ToolDefinition {
+    readonly description?: string;
+    readonly targets: Readonly<Record<string, ToolTargetBindingDefinition>>;
+}
+export interface ToolGroupDefinition {
+    readonly description?: string;
+    readonly tools: ReadonlyArray<ToolRefInput>;
+}
+export interface ToolspaceDefinition {
+    readonly name: string;
+    readonly description?: string;
+    readonly tools: Readonly<Record<string, ToolDefinition>>;
+    readonly groups?: Readonly<Record<string, ToolGroupDefinition>>;
+}
+export type ToolspaceSource = ToolspaceDefinition;
+export interface ModelTargetDefinition {
+    readonly model: string;
+    readonly variant?: string;
+    readonly temperature?: number;
+    readonly top_p?: number;
+}
+export interface ModelPoolTargetDefinition {
+    readonly strategy: "any-of" | "round-robin" | "ordered";
+    readonly models: readonly ModelTargetDefinition[];
+}
+export type ModelTargetBlockDefinition = ModelTargetDefinition | ModelPoolTargetDefinition | Readonly<Record<string, unknown>>;
+export interface ModelProfileDefinition {
+    readonly description?: string;
+    readonly targets: Readonly<Record<string, ModelTargetBlockDefinition>>;
+}
+export interface ModelspaceDefinition {
+    readonly name: string;
+    readonly description?: string;
+    readonly profiles: Readonly<Record<string, ModelProfileDefinition>>;
+}
+export type ModelspaceSource = ModelspaceDefinition;
+export interface SkillTargetBindingDefinition {
+    readonly name: string;
+}
+export interface SkillDefinition {
+    readonly description?: string;
+    readonly targets: Readonly<Record<string, SkillTargetBindingDefinition>>;
+}
+export interface SkillspaceDefinition {
+    readonly name: string;
+    readonly description?: string;
+    readonly skills: Readonly<Record<string, SkillDefinition>>;
+}
+export type SkillspaceSource = SkillspaceDefinition;
+export declare const hookEvent: {
+    readonly toolBefore: "tool.before";
+    readonly toolAfter: "tool.after";
+    readonly promptSubmit: "prompt.submit";
+    readonly permissionRequest: "permission.request";
+    readonly sessionStart: "session.start";
+    readonly sessionEnd: "session.end";
+};
+export type HookEvent = (typeof hookEvent)[keyof typeof hookEvent];
+export interface HookTargetContextDefinition {
+    readonly harness: string;
+    readonly nativeEvent: string;
+}
+export interface HookSessionContextDefinition {
+    readonly id?: string;
+    readonly transcriptPath?: string;
+}
+export interface HookToolContextDefinition {
+    readonly logical?: string;
+    readonly nativeName: string;
+    readonly input: unknown;
+}
+export interface ToolBeforeHookEventDefinition {
+    readonly event: typeof hookEvent.toolBefore;
+    readonly target: HookTargetContextDefinition;
+    readonly tool: HookToolContextDefinition;
+    readonly cwd?: string;
+    readonly session?: HookSessionContextDefinition;
+    readonly native?: Record<string, unknown>;
+}
+export interface ToolAfterHookEventDefinition {
+    readonly event: typeof hookEvent.toolAfter;
+    readonly target: HookTargetContextDefinition;
+    readonly tool: HookToolContextDefinition & {
+        readonly output: unknown;
+        readonly success?: boolean;
+    };
+    readonly cwd?: string;
+    readonly session?: HookSessionContextDefinition;
+    readonly native?: Record<string, unknown>;
+}
+export interface SessionStartHookEventDefinition {
+    readonly event: typeof hookEvent.sessionStart;
+    readonly target: HookTargetContextDefinition;
+    readonly cwd?: string;
+    readonly session: HookSessionContextDefinition;
+    readonly native?: Record<string, unknown>;
+}
+export interface PromptSubmitHookEventDefinition {
+    readonly event: typeof hookEvent.promptSubmit;
+    readonly target: HookTargetContextDefinition;
+    readonly cwd?: string;
+    readonly session?: HookSessionContextDefinition;
+    readonly prompt: string;
+    readonly native?: Record<string, unknown>;
+}
+export interface PermissionRequestHookEventDefinition {
+    readonly event: typeof hookEvent.permissionRequest;
+    readonly target: HookTargetContextDefinition;
+    readonly cwd?: string;
+    readonly session?: HookSessionContextDefinition;
+    readonly tool?: HookToolContextDefinition;
+    readonly native?: Record<string, unknown>;
+}
+export interface SessionEndHookEventDefinition {
+    readonly event: typeof hookEvent.sessionEnd;
+    readonly target: HookTargetContextDefinition;
+    readonly cwd?: string;
+    readonly session: HookSessionContextDefinition;
+    readonly reason?: string;
+    readonly native?: Record<string, unknown>;
+}
+export type HookEventPayloadDefinition = ToolBeforeHookEventDefinition | ToolAfterHookEventDefinition | PromptSubmitHookEventDefinition | PermissionRequestHookEventDefinition | SessionStartHookEventDefinition | SessionEndHookEventDefinition;
+export type HookEventPayloadFor<E extends HookEvent> = Extract<HookEventPayloadDefinition, {
+    readonly event: E;
+}>;
+export interface ContinueHookResultDefinition {
+    readonly decision: "continue";
+    readonly systemMessage?: string;
+    readonly additionalContext?: string;
+}
+export interface BlockHookResultDefinition {
+    readonly decision: "block";
+    readonly message: string;
+}
+export interface AllowHookResultDefinition {
+    readonly decision: "allow";
+    readonly systemMessage?: string;
+}
+export type ToolBeforeHookResultDefinition = ContinueHookResultDefinition | BlockHookResultDefinition;
+export type PermissionRequestHookResultDefinition = ContinueHookResultDefinition | AllowHookResultDefinition | BlockHookResultDefinition;
+export type HookResultFor<E extends HookEvent> = E extends typeof hookEvent.toolBefore ? ToolBeforeHookResultDefinition : E extends typeof hookEvent.permissionRequest ? PermissionRequestHookResultDefinition : ContinueHookResultDefinition;
+export type HookHandlerDefinition<E extends HookEvent> = (event: HookEventPayloadFor<E>) => import("effect").Effect.Effect<HookResultFor<E>, unknown, never>;
+export interface HookAnyToolMatcherDefinition {
+    readonly kind: "hook-any-tool";
+}
+export interface HookToolspaceToolMatcherDefinition {
+    readonly kind: "hook-toolspace-tool";
+    readonly tool: ToolRefInput;
+}
+export interface HookToolspaceGroupMatcherDefinition {
+    readonly kind: "hook-toolspace-group";
+    readonly group: ToolGroupRefInput;
+}
+export interface HookCanonicalToolMatcherDefinition {
+    readonly kind: "hook-canonical-tool";
+    readonly ref: string;
+}
+export type HookToolMatcherDefinition = HookAnyToolMatcherDefinition | HookToolspaceToolMatcherDefinition | HookToolspaceGroupMatcherDefinition | HookCanonicalToolMatcherDefinition;
+export interface ToolHookMatchDefinition {
+    readonly tool?: HookToolMatcherDefinition;
+}
+export type HookMatchDefinition<E extends HookEvent> = E extends typeof hookEvent.toolBefore | typeof hookEvent.toolAfter | typeof hookEvent.permissionRequest ? ToolHookMatchDefinition : never;
+export interface HookDefinition<E extends HookEvent = HookEvent> {
+    readonly name: string;
+    readonly description?: string;
+    readonly event: E;
+    readonly targets?: readonly string[];
+    readonly match?: HookMatchDefinition<E>;
+    readonly handle: HookHandlerDefinition<E>;
+}
+export type HookSource<E extends HookEvent = HookEvent> = HookDefinition<E>;
+export declare const withNamedRef: <TKind extends string>(kind: TKind, first: string, second?: string) => {
+    readonly kind: TKind;
+    readonly plugin?: string;
+    readonly name: string;
+};
+export declare function traitRef(name: string): TraitRefDefinition;
+export declare function traitRef(plugin: string, name: string): TraitRefDefinition;
+export declare function agentRef(name: string): AgentRefDefinition;
+export declare function agentRef(plugin: string, name: string): AgentRefDefinition;
+export declare function orbitRef(name: string): OrbitRefDefinition;
+export declare function orbitRef(plugin: string, name: string): OrbitRefDefinition;
+export declare function toolRef(toolspace: string, name: string): ToolRefDefinition;
+export declare function toolRef(plugin: string, toolspace: string, name: string): ToolRefDefinition;
+export declare function toolGroupRef(toolspace: string, name: string): ToolGroupRefDefinition;
+export declare function toolGroupRef(plugin: string, toolspace: string, name: string): ToolGroupRefDefinition;
+export declare function modelProfileRef(modelspace: string, name: string): ModelProfileRefDefinition;
+export declare function modelProfileRef(plugin: string, modelspace: string, name: string): ModelProfileRefDefinition;
+export declare function skillRef(name: string): SkillRefDefinition;
+export declare function skillRef(plugin: string, name: string): SkillRefDefinition;
+export declare function skillspaceRef(skillspace: string, name: string): SkillspaceRefDefinition;
+export declare function skillspaceRef(plugin: string, skillspace: string, name: string): SkillspaceRefDefinition;
+export declare const schemaSlot: (options?: Omit<ToolSchemaSlotDefinition, "kind">) => ToolSchemaSlotDefinition;
+export declare const bindTrait: (trait: TraitRefInput, options?: {
+    readonly tools?: Readonly<Record<string, TraitBindingToolDefinition>>;
+}) => TraitBindingDefinition;
+export declare const hookTool: {
+    readonly any: () => HookAnyToolMatcherDefinition;
+    readonly tool: (tool: ToolRefInput) => HookToolspaceToolMatcherDefinition;
+    readonly group: (group: ToolGroupRefInput) => HookToolspaceGroupMatcherDefinition;
+    readonly canonical: (ref: string) => HookCanonicalToolMatcherDefinition;
+};
+export declare const hookMatcher: {
+    readonly tool: {
+        readonly any: () => HookAnyToolMatcherDefinition;
+        readonly tool: (tool: ToolRefInput) => HookToolspaceToolMatcherDefinition;
+        readonly group: (group: ToolGroupRefInput) => HookToolspaceGroupMatcherDefinition;
+        readonly canonical: (ref: string) => HookCanonicalToolMatcherDefinition;
+    };
+};
+/** Transitional identity wrapper. The canonical public source type is `AgentSource`. */
+export declare const defineAgent: <T extends AgentSource>(agent: T) => T;
+/** Transitional identity wrapper. The canonical public source type is `TraitSource`. */
+export declare const defineTrait: <T extends TraitSource>(trait: T) => T;
+/** Transitional identity wrapper. The canonical public source type is `OrbitSource`. */
+export declare const defineOrbit: <T extends OrbitSource>(orbit: T) => T;
+/** Transitional identity wrapper. The canonical public source type is `ToolSource`. */
+export declare const defineTool: <T extends ToolSource>(tool: T) => T;
+/** Transitional identity wrapper. The canonical public source type is `ToolspaceSource`. */
+export declare const defineToolspace: <T extends ToolspaceSource>(toolspace: T) => T;
+/** Transitional identity wrapper. The canonical public source type is `ModelspaceSource`. */
+export declare const defineModelspace: <T extends ModelspaceSource>(modelspace: T) => T;
+/** Transitional identity wrapper. The canonical public source type is `SkillspaceSource`. */
+export declare const defineSkillspace: <T extends SkillspaceSource>(skillspace: T) => T;
+/** Transitional identity wrapper. The canonical public source type is `HookSource`. */
+export declare const defineHook: <E extends HookEvent, T extends HookSource<E>>(hook: T) => T;
+export type { ToolRuntimeContext, ToolRuntimeCost } from "./compile/runtime/schema-bridge";