@skastr0/prism-sdk 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Guilherme Castro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,12 @@
+# @skastr0/prism-sdk
+
+Core Prism contracts and codecs shared by Prism runtimes and workflow tooling.
+
+This package publishes compiled ESM JavaScript plus TypeScript declarations for these public export paths:
+
+- `@skastr0/prism-sdk/compile-manifest`
+- `@skastr0/prism-sdk/refs`
+- `@skastr0/prism-sdk/snapshot`
+- `@skastr0/prism-sdk/stable-json`
+
+It has no Prism CLI dependency. Consumers should import the explicit subpath they need.

package/dist/compile-manifest.d.ts

@@ -0,0 +1,293 @@
+import { Schema } from "effect";
+export declare const COMPILE_MANIFEST_VERSION: 1;
+export declare const HarnessScopeSchema: Schema.Literal<["global", "project"]>;
+export type HarnessScope = typeof HarnessScopeSchema.Type;
+export declare const HarnessIdSchema: Schema.Literal<["amp-code", "antigravity-cli", "claude-code", "codex-cli", "cursor", "factory-droid", "grok", "hermes", "kimi-code", "opencode", "pi"]>;
+export type HarnessId = typeof HarnessIdSchema.Type;
+export declare const CompileManifestPluginSchema: Schema.Struct<{
+    version: Schema.optional<typeof Schema.String>;
+    sourceHash: typeof Schema.String;
+}>;
+export type CompileManifestPlugin = typeof CompileManifestPluginSchema.Type;
+export declare const CompileManifestTargetSchema: Schema.Struct<{
+    harness: Schema.Literal<["amp-code", "antigravity-cli", "claude-code", "codex-cli", "cursor", "factory-droid", "grok", "hermes", "kimi-code", "opencode", "pi"]>;
+    scope: Schema.Literal<["global", "project"]>;
+}>;
+export type CompileManifestTarget = typeof CompileManifestTargetSchema.Type;
+export declare const CompileManifestTraitSchema: Schema.Struct<{
+    id: typeof Schema.String;
+    ref: typeof Schema.String;
+}>;
+export type CompileManifestTrait = typeof CompileManifestTraitSchema.Type;
+export declare const CompileManifestOrbitSchema: Schema.Struct<{
+    plugin: typeof Schema.String;
+    name: typeof Schema.String;
+}>;
+export type CompileManifestOrbit = typeof CompileManifestOrbitSchema.Type;
+export declare const CompileManifestCanonicalToolSchema: Schema.Struct<{
+    plugin: typeof Schema.String;
+    name: typeof Schema.String;
+}>;
+export type CompileManifestCanonicalTool = typeof CompileManifestCanonicalToolSchema.Type;
+export declare const CompileManifestToolspaceToolSchema: Schema.Struct<{
+    plugin: typeof Schema.String;
+    toolspace: typeof Schema.String;
+    name: typeof Schema.String;
+}>;
+export type CompileManifestToolspaceTool = typeof CompileManifestToolspaceToolSchema.Type;
+export declare const CompileManifestGrantsSchema: Schema.Struct<{
+    tools: Schema.Array$<typeof Schema.String>;
+    skills: Schema.Array$<typeof Schema.String>;
+}>;
+export type CompileManifestGrants = typeof CompileManifestGrantsSchema.Type;
+export declare const CompileManifestModelBindingsSchema: Schema.Struct<{
+    modelspace: Schema.optional<typeof Schema.String>;
+    profile: Schema.optional<typeof Schema.String>;
+}>;
+export type CompileManifestModelBindings = typeof CompileManifestModelBindingsSchema.Type;
+export declare const CompileManifestModelspaceSchema: Schema.Struct<{
+    plugin: typeof Schema.String;
+    modelspace: typeof Schema.String;
+    profiles: Schema.Array$<typeof Schema.String>;
+    profilesData: Schema.optional<Schema.Record$<typeof Schema.String, Schema.Record$<typeof Schema.String, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>>>;
+}>;
+export type CompileManifestModelspace = typeof CompileManifestModelspaceSchema.Type;
+export declare const CompileManifestManagedSkillSchema: Schema.Struct<{
+    plugin: typeof Schema.String;
+    name: typeof Schema.String;
+}>;
+export type CompileManifestManagedSkill = typeof CompileManifestManagedSkillSchema.Type;
+export declare const CompileManifestSkillspaceSchema: Schema.Struct<{
+    plugin: typeof Schema.String;
+    skillspace: typeof Schema.String;
+    skills: Schema.Array$<typeof Schema.String>;
+}>;
+export type CompileManifestSkillspace = typeof CompileManifestSkillspaceSchema.Type;
+export declare const CompileManifestPerTargetSchema: Schema.Struct<{
+    scope: Schema.Literal<["global", "project"]>;
+    model: Schema.NullOr<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+    toolGrants: Schema.Array$<typeof Schema.String>;
+    allowedTools: Schema.Array$<typeof Schema.String>;
+    allowedSkills: Schema.Array$<typeof Schema.String>;
+}>;
+export type CompileManifestPerTarget = typeof CompileManifestPerTargetSchema.Type;
+export declare const CompileManifestAgentSchema: Schema.Struct<{
+    name: typeof Schema.String;
+    plugin: typeof Schema.String;
+    description: typeof Schema.String;
+    sourceHash: typeof Schema.String;
+    traits: Schema.Array$<Schema.Struct<{
+        id: typeof Schema.String;
+        ref: typeof Schema.String;
+    }>>;
+    skills: Schema.Array$<typeof Schema.String>;
+    composed: Schema.Struct<{
+        grants: Schema.Struct<{
+            tools: Schema.Array$<typeof Schema.String>;
+            skills: Schema.Array$<typeof Schema.String>;
+        }>;
+        modelBindings: Schema.Struct<{
+            modelspace: Schema.optional<typeof Schema.String>;
+            profile: Schema.optional<typeof Schema.String>;
+        }>;
+        perTarget: Schema.Record$<typeof Schema.String, Schema.Struct<{
+            scope: Schema.Literal<["global", "project"]>;
+            model: Schema.NullOr<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+            toolGrants: Schema.Array$<typeof Schema.String>;
+            allowedTools: Schema.Array$<typeof Schema.String>;
+            allowedSkills: Schema.Array$<typeof Schema.String>;
+        }>>;
+    }>;
+    manifestHash: typeof Schema.String;
+}>;
+export type CompileManifestAgent = typeof CompileManifestAgentSchema.Type;
+export declare const CompileManifestSchema: Schema.Struct<{
+    version: Schema.Literal<[1]>;
+    plugins: Schema.Record$<typeof Schema.String, Schema.Struct<{
+        version: Schema.optional<typeof Schema.String>;
+        sourceHash: typeof Schema.String;
+    }>>;
+    compileTargets: Schema.Array$<Schema.Struct<{
+        harness: Schema.Literal<["amp-code", "antigravity-cli", "claude-code", "codex-cli", "cursor", "factory-droid", "grok", "hermes", "kimi-code", "opencode", "pi"]>;
+        scope: Schema.Literal<["global", "project"]>;
+    }>>;
+    agents: Schema.Record$<typeof Schema.String, Schema.Struct<{
+        name: typeof Schema.String;
+        plugin: typeof Schema.String;
+        description: typeof Schema.String;
+        sourceHash: typeof Schema.String;
+        traits: Schema.Array$<Schema.Struct<{
+            id: typeof Schema.String;
+            ref: typeof Schema.String;
+        }>>;
+        skills: Schema.Array$<typeof Schema.String>;
+        composed: Schema.Struct<{
+            grants: Schema.Struct<{
+                tools: Schema.Array$<typeof Schema.String>;
+                skills: Schema.Array$<typeof Schema.String>;
+            }>;
+            modelBindings: Schema.Struct<{
+                modelspace: Schema.optional<typeof Schema.String>;
+                profile: Schema.optional<typeof Schema.String>;
+            }>;
+            perTarget: Schema.Record$<typeof Schema.String, Schema.Struct<{
+                scope: Schema.Literal<["global", "project"]>;
+                model: Schema.NullOr<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+                toolGrants: Schema.Array$<typeof Schema.String>;
+                allowedTools: Schema.Array$<typeof Schema.String>;
+                allowedSkills: Schema.Array$<typeof Schema.String>;
+            }>>;
+        }>;
+        manifestHash: typeof Schema.String;
+    }>>;
+    modelspaces: Schema.Record$<typeof Schema.String, Schema.Struct<{
+        plugin: typeof Schema.String;
+        modelspace: typeof Schema.String;
+        profiles: Schema.Array$<typeof Schema.String>;
+        profilesData: Schema.optional<Schema.Record$<typeof Schema.String, Schema.Record$<typeof Schema.String, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>>>;
+    }>>;
+    skills: Schema.Record$<typeof Schema.String, Schema.Union<[Schema.Struct<{
+        plugin: typeof Schema.String;
+        name: typeof Schema.String;
+    }>, Schema.Struct<{
+        plugin: typeof Schema.String;
+        skillspace: typeof Schema.String;
+        skills: Schema.Array$<typeof Schema.String>;
+    }>]>>;
+    tools: Schema.Record$<typeof Schema.String, Schema.Union<[Schema.Struct<{
+        plugin: typeof Schema.String;
+        toolspace: typeof Schema.String;
+        name: typeof Schema.String;
+    }>, Schema.Struct<{
+        plugin: typeof Schema.String;
+        name: typeof Schema.String;
+    }>]>>;
+    traits: Schema.Record$<typeof Schema.String, Schema.Struct<{
+        id: typeof Schema.String;
+        ref: typeof Schema.String;
+    }>>;
+    orbits: Schema.Record$<typeof Schema.String, Schema.Struct<{
+        plugin: typeof Schema.String;
+        name: typeof Schema.String;
+    }>>;
+    manifestHash: typeof Schema.String;
+}>;
+export type CompileManifest = typeof CompileManifestSchema.Type;
+export interface UnsupportedCompileManifestVersion {
+    readonly _tag: "UnsupportedCompileManifestVersion";
+    readonly version: unknown;
+    readonly message: string;
+}
+export declare const unsupportedCompileManifestVersion: (version: unknown) => UnsupportedCompileManifestVersion;
+declare const decodeCompileManifestPayload: (u: unknown, overrideOptions?: import("effect/SchemaAST").ParseOptions) => import("effect/Either").Either<{
+    readonly version: 1;
+    readonly tools: {
+        readonly [x: string]: {
+            readonly plugin: string;
+            readonly name: string;
+        } | {
+            readonly plugin: string;
+            readonly name: string;
+            readonly toolspace: string;
+        };
+    };
+    readonly skills: {
+        readonly [x: string]: {
+            readonly plugin: string;
+            readonly name: string;
+        } | {
+            readonly plugin: string;
+            readonly skills: readonly string[];
+            readonly skillspace: string;
+        };
+    };
+    readonly traits: {
+        readonly [x: string]: {
+            readonly id: string;
+            readonly ref: string;
+        };
+    };
+    readonly manifestHash: string;
+    readonly plugins: {
+        readonly [x: string]: {
+            readonly version?: string | undefined;
+            readonly sourceHash: string;
+        };
+    };
+    readonly compileTargets: readonly {
+        readonly harness: "amp-code" | "antigravity-cli" | "claude-code" | "codex-cli" | "cursor" | "factory-droid" | "grok" | "hermes" | "kimi-code" | "opencode" | "pi";
+        readonly scope: "global" | "project";
+    }[];
+    readonly agents: {
+        readonly [x: string]: {
+            readonly sourceHash: string;
+            readonly plugin: string;
+            readonly name: string;
+            readonly skills: readonly string[];
+            readonly description: string;
+            readonly traits: readonly {
+                readonly id: string;
+                readonly ref: string;
+            }[];
+            readonly composed: {
+                readonly grants: {
+                    readonly tools: readonly string[];
+                    readonly skills: readonly string[];
+                };
+                readonly modelBindings: {
+                    readonly modelspace?: string | undefined;
+                    readonly profile?: string | undefined;
+                };
+                readonly perTarget: {
+                    readonly [x: string]: {
+                        readonly scope: "global" | "project";
+                        readonly model: {
+                            readonly [x: string]: unknown;
+                        } | null;
+                        readonly toolGrants: readonly string[];
+                        readonly allowedTools: readonly string[];
+                        readonly allowedSkills: readonly string[];
+                    };
+                };
+            };
+            readonly manifestHash: string;
+        };
+    };
+    readonly modelspaces: {
+        readonly [x: string]: {
+            readonly plugin: string;
+            readonly modelspace: string;
+            readonly profiles: readonly string[];
+            readonly profilesData?: {
+                readonly [x: string]: {
+                    readonly [x: string]: {
+                        readonly [x: string]: unknown;
+                    };
+                };
+            } | undefined;
+        };
+    };
+    readonly orbits: {
+        readonly [x: string]: {
+            readonly plugin: string;
+            readonly name: string;
+        };
+    };
+}, import("effect/ParseResult").ParseError>;
+export type CompileManifestDecodeResult = ReturnType<typeof decodeCompileManifestPayload>;
+export declare const decodeCompileManifest: (json: string) => CompileManifestDecodeResult | UnsupportedCompileManifestVersion;
+export declare const normalizeCompileManifestForEncoding: (manifest: CompileManifest) => CompileManifest;
+export declare const encodeCompileManifest: (manifest: CompileManifest) => string;
+export declare const agentManifestHashInput: (agent: CompileManifestAgent) => Omit<CompileManifestAgent, "manifestHash">;
+export declare const computeAgentManifestHash: (agent: CompileManifestAgent) => string;
+export declare const manifestHashInput: (manifest: CompileManifest) => Omit<CompileManifest, "manifestHash">;
+export declare const computeCompileManifestHash: (manifest: CompileManifest) => string;
+export declare const verifyAgentManifestHash: (agent: CompileManifestAgent) => boolean;
+export declare const verifyCompileManifestHash: (manifest: CompileManifest) => boolean;
+export declare const getCompileManifestAgent: (manifest: CompileManifest, id: string) => CompileManifestAgent | undefined;
+export declare const getCompileManifestAgentForTarget: (manifest: CompileManifest, id: string, harness: HarnessId) => {
+    readonly agent: CompileManifestAgent;
+    readonly target: CompileManifestPerTarget;
+} | undefined;
+export declare const emptyCompileManifest: () => CompileManifest;
+export {};

package/dist/compile-manifest.js

@@ -0,0 +1,232 @@
+import { Schema } from "effect";
+import { compareCodePoint, sortStableStrings, stableJsonHash, stableJsonValue, } from "./stable-json.js";
+export const COMPILE_MANIFEST_VERSION = 1;
+export const HarnessScopeSchema = Schema.Literal("global", "project");
+export const HarnessIdSchema = Schema.Literal("amp-code", "antigravity-cli", "claude-code", "codex-cli", "cursor", "factory-droid", "grok", "hermes", "kimi-code", "opencode", "pi");
+export const CompileManifestPluginSchema = Schema.Struct({
+    version: Schema.optional(Schema.String),
+    sourceHash: Schema.String,
+});
+export const CompileManifestTargetSchema = Schema.Struct({
+    harness: HarnessIdSchema,
+    scope: HarnessScopeSchema,
+});
+export const CompileManifestTraitSchema = Schema.Struct({
+    id: Schema.String,
+    ref: Schema.String,
+});
+export const CompileManifestOrbitSchema = Schema.Struct({
+    plugin: Schema.String,
+    name: Schema.String,
+});
+export const CompileManifestCanonicalToolSchema = Schema.Struct({
+    plugin: Schema.String,
+    name: Schema.String,
+});
+export const CompileManifestToolspaceToolSchema = Schema.Struct({
+    plugin: Schema.String,
+    toolspace: Schema.String,
+    name: Schema.String,
+});
+export const CompileManifestGrantsSchema = Schema.Struct({
+    tools: Schema.Array(Schema.String),
+    skills: Schema.Array(Schema.String),
+});
+export const CompileManifestModelBindingsSchema = Schema.Struct({
+    modelspace: Schema.optional(Schema.String),
+    profile: Schema.optional(Schema.String),
+});
+export const CompileManifestModelspaceSchema = Schema.Struct({
+    plugin: Schema.String,
+    modelspace: Schema.String,
+    profiles: Schema.Array(Schema.String),
+    profilesData: Schema.optional(Schema.Record({
+        key: Schema.String,
+        value: Schema.Record({
+            key: Schema.String,
+            value: Schema.Record({ key: Schema.String, value: Schema.Unknown }),
+        }),
+    })),
+});
+export const CompileManifestManagedSkillSchema = Schema.Struct({
+    plugin: Schema.String,
+    name: Schema.String,
+});
+export const CompileManifestSkillspaceSchema = Schema.Struct({
+    plugin: Schema.String,
+    skillspace: Schema.String,
+    skills: Schema.Array(Schema.String),
+});
+const JsonRecordSchema = Schema.Record({ key: Schema.String, value: Schema.Unknown });
+export const CompileManifestPerTargetSchema = Schema.Struct({
+    scope: HarnessScopeSchema,
+    model: Schema.NullOr(JsonRecordSchema),
+    toolGrants: Schema.Array(Schema.String),
+    allowedTools: Schema.Array(Schema.String),
+    allowedSkills: Schema.Array(Schema.String),
+});
+export const CompileManifestAgentSchema = Schema.Struct({
+    name: Schema.String,
+    plugin: Schema.String,
+    description: Schema.String,
+    sourceHash: Schema.String,
+    traits: Schema.Array(CompileManifestTraitSchema),
+    skills: Schema.Array(Schema.String),
+    composed: Schema.Struct({
+        grants: CompileManifestGrantsSchema,
+        modelBindings: CompileManifestModelBindingsSchema,
+        perTarget: Schema.Record({ key: Schema.String, value: CompileManifestPerTargetSchema }),
+    }),
+    manifestHash: Schema.String,
+});
+const CompileManifestV1Schema = Schema.Struct({
+    version: Schema.Literal(COMPILE_MANIFEST_VERSION),
+    plugins: Schema.Record({ key: Schema.String, value: CompileManifestPluginSchema }),
+    compileTargets: Schema.Array(CompileManifestTargetSchema),
+    agents: Schema.Record({ key: Schema.String, value: CompileManifestAgentSchema }),
+    modelspaces: Schema.Record({ key: Schema.String, value: CompileManifestModelspaceSchema }),
+    skills: Schema.Record({ key: Schema.String, value: Schema.Union(CompileManifestManagedSkillSchema, CompileManifestSkillspaceSchema) }),
+    tools: Schema.Record({ key: Schema.String, value: Schema.Union(CompileManifestToolspaceToolSchema, CompileManifestCanonicalToolSchema) }),
+    traits: Schema.Record({ key: Schema.String, value: CompileManifestTraitSchema }),
+    orbits: Schema.Record({ key: Schema.String, value: CompileManifestOrbitSchema }),
+    manifestHash: Schema.String,
+});
+export const CompileManifestSchema = CompileManifestV1Schema;
+export const unsupportedCompileManifestVersion = (version) => ({
+    _tag: "UnsupportedCompileManifestVersion",
+    version,
+    message: `Unsupported compile manifest version: ${String(version)}. Expected ${COMPILE_MANIFEST_VERSION}.`,
+});
+const decodeJson = (json) => JSON.parse(json);
+const versionFromJson = (json) => {
+    const parsed = decodeJson(json);
+    return parsed && typeof parsed === "object" && "version" in parsed
+        ? parsed.version
+        : undefined;
+};
+const decodeCompileManifestPayload = Schema.decodeUnknownEither(Schema.parseJson(CompileManifestSchema));
+export const decodeCompileManifest = (json) => {
+    let version;
+    try {
+        version = versionFromJson(json);
+    }
+    catch {
+        return decodeCompileManifestPayload(json);
+    }
+    if (version !== COMPILE_MANIFEST_VERSION) {
+        return unsupportedCompileManifestVersion(version);
+    }
+    return decodeCompileManifestPayload(json);
+};
+const sortRecord = (record, normalize) => Object.fromEntries(sortStableStrings(Object.keys(record)).map((key) => [key, normalize(record[key])]));
+const sortStrings = (values) => sortStableStrings(values);
+const sortTargets = (targets) => [...targets].sort((left, right) => left.harness === right.harness
+    ? (left.scope === right.scope ? 0 : left.scope < right.scope ? -1 : 1)
+    : left.harness < right.harness ? -1 : 1);
+const sortTraits = (traits) => [...traits].sort((left, right) => left.id === right.id
+    ? (left.ref === right.ref ? 0 : left.ref < right.ref ? -1 : 1)
+    : left.id < right.id ? -1 : 1);
+const sortOrbits = (orbits) => [...orbits].sort((left, right) => left.plugin === right.plugin
+    ? compareCodePoint(left.name, right.name)
+    : compareCodePoint(left.plugin, right.plugin));
+const sortTools = (tools) => [...tools].sort((left, right) => left.plugin === right.plugin
+    ? ("toolspace" in left && left.toolspace !== undefined
+        ? ("toolspace" in right && right.toolspace !== undefined
+            ? (left.toolspace === right.toolspace
+                ? compareCodePoint(left.name, right.name)
+                : compareCodePoint(left.toolspace, right.toolspace))
+            : -1)
+        : ("toolspace" in right && right.toolspace !== undefined
+            ? 1
+            : compareCodePoint(left.name, right.name)))
+    : compareCodePoint(left.plugin, right.plugin));
+const normalizeAgentForEncoding = (agent) => ({
+    ...agent,
+    traits: sortTraits(agent.traits),
+    skills: sortStrings(agent.skills),
+    composed: {
+        grants: {
+            tools: sortStrings(agent.composed.grants.tools),
+            skills: sortStrings(agent.composed.grants.skills),
+        },
+        modelBindings: stableJsonValue(agent.composed.modelBindings),
+        perTarget: sortRecord(agent.composed.perTarget, (slice) => ({
+            ...slice,
+            model: slice.model === null ? null : stableJsonValue(slice.model),
+            toolGrants: sortStrings(slice.toolGrants),
+            allowedTools: sortStrings(slice.allowedTools),
+            allowedSkills: sortStrings(slice.allowedSkills),
+        })),
+    },
+});
+export const normalizeCompileManifestForEncoding = (manifest) => ({
+    version: COMPILE_MANIFEST_VERSION,
+    plugins: sortRecord(manifest.plugins, (plugin) => plugin),
+    compileTargets: sortTargets(manifest.compileTargets),
+    agents: sortRecord(manifest.agents, normalizeAgentForEncoding),
+    modelspaces: sortRecord(manifest.modelspaces, (entry) => ({
+        plugin: entry.plugin,
+        modelspace: entry.modelspace,
+        profiles: sortStrings(entry.profiles),
+        profilesData: entry.profilesData
+            ? sortRecord(entry.profilesData, (profileMap) => sortRecord(profileMap, (targetBlock) => stableJsonValue(targetBlock)))
+            : undefined,
+    })),
+    skills: sortRecord(manifest.skills, (entry) => "skillspace" in entry && entry.skillspace !== undefined
+        ? {
+            plugin: entry.plugin,
+            skillspace: entry.skillspace,
+            skills: sortStrings(entry.skills),
+        }
+        : {
+            plugin: entry.plugin,
+            name: entry.name,
+        }),
+    tools: sortRecord(manifest.tools, (entry) => "toolspace" in entry && entry.toolspace !== undefined
+        ? {
+            plugin: entry.plugin,
+            toolspace: entry.toolspace,
+            name: entry.name,
+        }
+        : {
+            plugin: entry.plugin,
+            name: entry.name,
+        }),
+    traits: sortRecord(manifest.traits, (trait) => trait),
+    orbits: sortRecord(manifest.orbits, (entry) => entry),
+    manifestHash: manifest.manifestHash,
+});
+export const encodeCompileManifest = (manifest) => `${JSON.stringify(normalizeCompileManifestForEncoding(manifest), null, 2)}\n`;
+export const agentManifestHashInput = (agent) => {
+    const { manifestHash: _manifestHash, ...rest } = normalizeAgentForEncoding(agent);
+    return rest;
+};
+export const computeAgentManifestHash = (agent) => stableJsonHash(agentManifestHashInput(agent));
+export const manifestHashInput = (manifest) => {
+    const { manifestHash: _manifestHash, ...rest } = normalizeCompileManifestForEncoding(manifest);
+    return rest;
+};
+export const computeCompileManifestHash = (manifest) => stableJsonHash(manifestHashInput(manifest));
+export const verifyAgentManifestHash = (agent) => computeAgentManifestHash(agent) === agent.manifestHash;
+export const verifyCompileManifestHash = (manifest) => computeCompileManifestHash(manifest) === manifest.manifestHash;
+export const getCompileManifestAgent = (manifest, id) => manifest.agents[id];
+export const getCompileManifestAgentForTarget = (manifest, id, harness) => {
+    const agent = getCompileManifestAgent(manifest, id);
+    const target = agent?.composed.perTarget[harness];
+    return agent && target ? { agent, target } : undefined;
+};
+export const emptyCompileManifest = () => {
+    const manifest = {
+        version: COMPILE_MANIFEST_VERSION,
+        plugins: {},
+        compileTargets: [],
+        agents: {},
+        modelspaces: {},
+        skills: {},
+        tools: {},
+        traits: {},
+        orbits: {},
+        manifestHash: "",
+    };
+    return { ...manifest, manifestHash: computeCompileManifestHash(manifest) };
+};

package/dist/mcp/daemon-resolver.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Resolve-or-spawn: given a plugin name, produce a *live* daemon registry
+ * entry to connect to -- spawning a fresh daemon when the registry has no
+ * entry, the recorded entry is dead, or the recorded entry's bundle hash no
+ * longer matches the compiled bundle on disk (a `prism refresh` ran since
+ * that daemon started).
+ *
+ * Builds entirely on the wave-0 substrate rather than re-implementing any of
+ * it:
+ *  - `getDaemon` / the per-plugin registry file (`uds-registry.ts`).
+ *  - `udsPathFor`, the content-addressed socket path (`uds-path.ts`) --
+ *    a different bundle hash always yields a different socket path, so a
+ *    stale daemon (old hash) and a fresh one (new hash) never collide on the
+ *    same file.
+ *  - `probeSocketLiveness` (`uds-singleton.ts`).
+ *
+ * This module deliberately never binds a socket or acquires the bind lock
+ * itself. Every compiled bundle's own runtime already calls
+ * `bindUnixSocketSingleton` on startup (see `src/compile/mcp-bundle.ts`'s
+ * `MCP_SDK_HTTP_RUNTIME`), and *that* is what guarantees exactly one winner
+ * when N callers race to spawn the same plugin: this module just spawns
+ * (possibly redundantly) and waits for a live registry entry to show up.
+ * Losing spawns detect "already-served" inside their own bundle and
+ * `process.exit(0)` before ever registering.
+ */
+import { type RegistryEntry, type RegistryResult } from "./uds-registry.js";
+import { type ProbeResult } from "./uds-singleton.js";
+export declare class DaemonResolveError extends Error {
+    readonly pluginName: string;
+    readonly cause?: unknown | undefined;
+    readonly kind: "daemon-resolve-error";
+    constructor(pluginName: string, message: string, cause?: unknown | undefined);
+}
+export declare const DEFAULT_SPAWN_TIMEOUT_MS = 15000;
+/**
+ * `<prismHome>/runtime/mcp/<plugin>` -- the per-plugin runtime directory
+ * that owns this plugin's registry file, socket file(s), and compiled
+ * bundle. Derived from `udsPathFor` (any hash value yields the same parent
+ * directory) rather than re-deriving the layout independently.
+ *
+ * `prismHome` is threaded explicitly (never read from the environment
+ * here): the CLI edge resolves `PRISM_HOME` once via `resolvePrismHome()`
+ * and passes the result down. An omitted value falls back to the same
+ * `~/.prism` default `resolvePrismHome()` uses when unset -- `prism-sdk`
+ * cannot import that resolver itself (no dependency on the root `src/`
+ * tree).
+ */
+export declare const pluginRuntimeDir: (plugin: string, prismHome?: string) => string;
+/**
+ * `<prismHome>/runtime/mcp/<plugin>/server.mjs` -- the canonical compiled
+ * bundle a `prism refresh` run produces. This module only ever reads it; it
+ * never writes or rebuilds it.
+ */
+export declare const pluginBundlePath: (plugin: string, prismHome?: string) => string;
+export type GetDaemonFn = (plugin: string) => Promise<RegistryResult<RegistryEntry>>;
+export type ProbeSocketLivenessFn = (socketPath: string) => Promise<ProbeResult>;
+export type HashBundleFn = (bundlePath: string) => Promise<string>;
+export type UdsPathForFn = (plugin: string, bundleHash: string) => string;
+export interface SpawnDaemonOptions {
+    readonly plugin: string;
+    readonly bundlePath: string;
+    readonly udsPath: string;
+    readonly bundleHash: string;
+}
+export type SpawnDaemonFn = (options: SpawnDaemonOptions) => void;
+export interface ResolveOrSpawnOptions {
+    readonly plugin: string;
+    /**
+     * Prism home directory, threaded from the CLI edge (`resolvePrismHome()`).
+     * Only consulted to build the *default* `bundlePathFor`/`udsPathFor`; a
+     * caller that supplies either override directly takes over that
+     * resolution entirely and this is ignored for that one.
+     */
+    readonly prismHome?: string;
+    readonly spawnTimeoutMs?: number;
+    readonly pollIntervalMs?: number;
+    readonly getDaemon?: GetDaemonFn;
+    readonly probeSocketLiveness?: ProbeSocketLivenessFn;
+    readonly bundlePathFor?: (plugin: string) => string;
+    readonly udsPathFor?: UdsPathForFn;
+    readonly hashBundle?: HashBundleFn;
+    readonly spawnDaemon?: SpawnDaemonFn;
+}
+/**
+ * Resolves the live registry entry to connect to for `plugin`:
+ *
+ *   registry entry present -> liveness probe
+ *     live & bundle hash matches on-disk bundle -> use it
+ *     dead, OR bundle hash stale               -> spawn fresh
+ *   registry entry absent                       -> spawn fresh
+ *
+ * "Spawn fresh" computes the bundle's current content hash, derives its
+ * content-addressed socket path via `udsPathFor`, launches the daemon, and
+ * polls the registry + a liveness probe until a live entry at that exact
+ * socket path appears or `spawnTimeoutMs` elapses.
+ *
+ * Throws `DaemonResolveError` when the bundle cannot be read (nothing to
+ * spawn) or the spawned daemon never becomes live in time.
+ */
+export declare const resolveOrSpawnDaemon: (options: ResolveOrSpawnOptions) => Promise<RegistryEntry>;