@agentxm/extension-model 0.28.12 → 0.28.13

package/README.md

@@ -9,6 +9,9 @@ client and the AgentXM platform. Every export lives under an explicit
 `./unstable/*` subpath: the surface is unsupported and may change in any
 release. Ordinary users should use the [`axm` CLI](https://axm.sh) instead.
 
+The executable-specification metadata contract that used to ship as
+`./unstable/specifications` now lives in `@agentxm/specification-metadata`.
+
 ## VERS Parser Reference
 
 `VersRangeSchema` currently targets `package-url/vers-spec` commit

package/dist/src/unstable/extension-types/catalog.d.ts

@@ -0,0 +1,157 @@
+/**
+ * Agent-agnostic extension type capability catalog.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+/** @experimental This API is unstable and may change without notice. */
+export declare const EXTENSION_TYPES_BY_ID: {
+    skill: {
+        id: "skill";
+        summary: string;
+        description: string;
+        standard: {
+            readonly id: "agent-skills";
+            readonly name: "Agent Skills";
+            readonly url: "https://agentskills.io";
+        };
+        docs: {
+            label: string;
+            url: string;
+        }[];
+    };
+    "mcp-server": {
+        id: "mcp-server";
+        summary: string;
+        description: string;
+        standard: {
+            readonly id: "mcp";
+            readonly name: "Model Context Protocol";
+            readonly url: "https://modelcontextprotocol.io";
+        };
+        docs: {
+            label: string;
+            url: string;
+        }[];
+    };
+    subagent: {
+        id: "subagent";
+        summary: string;
+        description: string;
+        standard: null;
+        docs: {
+            label: string;
+            url: string;
+        }[];
+    };
+    rule: {
+        id: "rule";
+        summary: string;
+        description: string;
+        standard: {
+            readonly id: "agents-md";
+            readonly name: "AGENTS.md";
+            readonly url: "https://agents.md";
+        };
+        docs: {
+            label: string;
+            url: string;
+        }[];
+    };
+    hook: {
+        id: "hook";
+        summary: string;
+        description: string;
+        standard: null;
+        docs: {
+            label: string;
+            url: string;
+        }[];
+    };
+    knowledge: {
+        id: "knowledge";
+        summary: string;
+        description: string;
+        standard: {
+            readonly id: "okf-0.2";
+            readonly name: "Open Knowledge Format 0.2";
+            readonly url: "https://github.com/GoogleCloudPlatform/knowledge-catalog/blob/main/okf/SPEC.md";
+        };
+        docs: {
+            label: string;
+            url: string;
+        }[];
+    };
+};
+/** @experimental This API is unstable and may change without notice. */
+export declare const EXTENSION_TYPES: ({
+    id: "skill";
+    summary: string;
+    description: string;
+    standard: {
+        readonly id: "agent-skills";
+        readonly name: "Agent Skills";
+        readonly url: "https://agentskills.io";
+    };
+    docs: {
+        label: string;
+        url: string;
+    }[];
+} | {
+    id: "mcp-server";
+    summary: string;
+    description: string;
+    standard: {
+        readonly id: "mcp";
+        readonly name: "Model Context Protocol";
+        readonly url: "https://modelcontextprotocol.io";
+    };
+    docs: {
+        label: string;
+        url: string;
+    }[];
+} | {
+    id: "subagent";
+    summary: string;
+    description: string;
+    standard: null;
+    docs: {
+        label: string;
+        url: string;
+    }[];
+} | {
+    id: "rule";
+    summary: string;
+    description: string;
+    standard: {
+        readonly id: "agents-md";
+        readonly name: "AGENTS.md";
+        readonly url: "https://agents.md";
+    };
+    docs: {
+        label: string;
+        url: string;
+    }[];
+} | {
+    id: "hook";
+    summary: string;
+    description: string;
+    standard: null;
+    docs: {
+        label: string;
+        url: string;
+    }[];
+} | {
+    id: "knowledge";
+    summary: string;
+    description: string;
+    standard: {
+        readonly id: "okf-0.2";
+        readonly name: "Open Knowledge Format 0.2";
+        readonly url: "https://github.com/GoogleCloudPlatform/knowledge-catalog/blob/main/okf/SPEC.md";
+    };
+    docs: {
+        label: string;
+        url: string;
+    }[];
+})[];
+//# sourceMappingURL=catalog.d.ts.map

package/dist/src/unstable/extension-types/catalog.js

@@ -0,0 +1,62 @@
+/**
+ * Agent-agnostic extension type capability catalog.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import { STANDARDS } from "./standards.js";
+const skill = {
+    id: "skill",
+    summary: "Package reusable agent skills with SKILL.md metadata and instructions.",
+    description: "Reusable capability packages authored in the Agent Skills format. Read by the agent as task-specific behavior and grounded by the Agent Skills open standard.",
+    standard: STANDARDS.skills,
+    docs: [{ label: "Skill manifest schema", url: "https://axm.sh/schemas/skill.schema.json" }],
+};
+const mcpServer = {
+    id: "mcp-server",
+    summary: "Configure Model Context Protocol servers for agents.",
+    description: "MCP server connections installed into each agent's native MCP configuration. The Model Context Protocol is the authoritative standard for this capability.",
+    standard: STANDARDS.mcp,
+    docs: [{ label: "MCP server manifest schema", url: "https://axm.sh/schemas/mcp.schema.json" }],
+};
+const subagent = {
+    id: "subagent",
+    summary: "Install specialized agent profiles into an agent's native subagent system.",
+    description: "Delegated agent profiles installed into vendor-specific subagent layouts. Subagents have no governing open standard.",
+    standard: null,
+    docs: [{ label: "Subagent manifest schema", url: "https://axm.sh/schemas/subagent.schema.json" }],
+};
+const rule = {
+    id: "rule",
+    summary: "Sync instruction files and distribute rule extensions that inject into them.",
+    description: "Umbrella capability for behavior-governing instructions: syncing AGENTS.md, CLAUDE.md, and rules directories, and distributing rule extensions that inject content into those instruction files. Read by the agent to shape behavior.",
+    standard: STANDARDS.rules,
+    docs: [{ label: "Rule manifest schema", url: "https://axm.sh/schemas/rule.schema.json" }],
+};
+const hook = {
+    id: "hook",
+    summary: "Install lifecycle hook extensions into an agent's native hook system.",
+    description: "Lifecycle automation hooks installed into vendor-specific agent hook systems. Hooks have no governing open standard.",
+    standard: null,
+    docs: [{ label: "Hook manifest schema", url: "https://axm.sh/schemas/hook.schema.json" }],
+};
+const knowledge = {
+    id: "knowledge",
+    summary: "Package portable Open Knowledge Format concept bundles.",
+    description: "Reference knowledge installed as isolated Markdown concept bundles using Open Knowledge Format 0.2. Knowledge is discoverable and readable without being injected into agent instructions.",
+    standard: STANDARDS.okf,
+    docs: [
+        { label: "Knowledge manifest schema", url: "https://axm.sh/schemas/knowledge.schema.json" },
+    ],
+};
+/** @experimental This API is unstable and may change without notice. */
+export const EXTENSION_TYPES_BY_ID = {
+    skill,
+    "mcp-server": mcpServer,
+    subagent,
+    rule,
+    hook,
+    knowledge,
+};
+/** @experimental This API is unstable and may change without notice. */
+export const EXTENSION_TYPES = Object.values(EXTENSION_TYPES_BY_ID);
+//# sourceMappingURL=catalog.js.map

package/dist/src/unstable/extension-types/derive.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Derivation helpers for the extension type catalog.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import type { CatalogExtensionType, ExtensionTypeDefinition, Standard } from "./schema.js";
+/** @experimental This API is unstable and may change without notice. */
+export declare const getExtensionTypeDefinition: (id: CatalogExtensionType) => ExtensionTypeDefinition;
+/** @experimental This API is unstable and may change without notice. */
+export declare const getStandardForExtensionType: (id: CatalogExtensionType) => Standard | null;
+/** @experimental This API is unstable and may change without notice. */
+export declare const isSpecTracked: (id: CatalogExtensionType) => boolean;
+//# sourceMappingURL=derive.d.ts.map

package/dist/src/unstable/extension-types/derive.js

@@ -0,0 +1,13 @@
+/**
+ * Derivation helpers for the extension type catalog.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import { EXTENSION_TYPES_BY_ID } from "./catalog.js";
+/** @experimental This API is unstable and may change without notice. */
+export const getExtensionTypeDefinition = (id) => EXTENSION_TYPES_BY_ID[id];
+/** @experimental This API is unstable and may change without notice. */
+export const getStandardForExtensionType = (id) => getExtensionTypeDefinition(id).standard;
+/** @experimental This API is unstable and may change without notice. */
+export const isSpecTracked = (id) => getStandardForExtensionType(id) !== null;
+//# sourceMappingURL=derive.js.map

package/dist/src/unstable/extension-types/index.d.ts

@@ -4,5 +4,7 @@
  * @experimental This API is unstable and may change without notice.
  */
 export { CATALOG_EXTENSION_TYPES, type CatalogExtensionType, CatalogExtensionTypeSchema, type DocLink, DocLinkSchema, type ExtensionTypeCatalog, ExtensionTypeCatalogSchema, type ExtensionTypeDefinition, ExtensionTypeDefinitionSchema, LEAF_EXTENSION_TYPES, type LeafExtensionType, LeafExtensionTypeSchema, type Standard, StandardSchema, type Url, UrlSchema, isCatalogExtensionType, } from "./schema.js";
+export { EXTENSION_TYPES, EXTENSION_TYPES_BY_ID } from "./catalog.js";
+export { getExtensionTypeDefinition, getStandardForExtensionType, isSpecTracked, } from "./derive.js";
 export { STANDARDS } from "./standards.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/unstable/extension-types/index.js

@@ -4,5 +4,7 @@
  * @experimental This API is unstable and may change without notice.
  */
 export { CATALOG_EXTENSION_TYPES, CatalogExtensionTypeSchema, DocLinkSchema, ExtensionTypeCatalogSchema, ExtensionTypeDefinitionSchema, LEAF_EXTENSION_TYPES, LeafExtensionTypeSchema, StandardSchema, UrlSchema, isCatalogExtensionType, } from "./schema.js";
+export { EXTENSION_TYPES, EXTENSION_TYPES_BY_ID } from "./catalog.js";
+export { getExtensionTypeDefinition, getStandardForExtensionType, isSpecTracked, } from "./derive.js";
 export { STANDARDS } from "./standards.js";
 //# sourceMappingURL=index.js.map

package/dist/src/unstable/extensions/common.d.ts

@@ -5,6 +5,7 @@
  */
 import * as Schema from "effect/Schema";
 import * as Option from "effect/Option";
+import { AgentIdSchema } from "../agent-capabilities/catalog.js";
 /**
  * Author information for a manifest.
  *
@@ -510,14 +511,12 @@ export declare const NonPackManifestFields: {
     standalone: Schema.optional<Schema.Boolean>;
 };
 /**
- * Agent identifier enumeration for supported coding agents.
- *
- * Derived from `AGENT_IDS` in agents/types.ts — compile-time enforced,
- * no manual sync required.
+ * Agent identifier enumeration for supported coding agents: the single
+ * definition lives in the capability catalog.
  *
  * @experimental This API is unstable and may change without notice.
  */
-export declare const AgentIdSchema: Schema.Literals<readonly ["adal", "aider-desk", "amp", "antigravity", "antigravity-cli", "augment", "claude-code", "cline", "codearts-agent", "codebuddy", "codemaker", "codestudio", "codex", "command-code", "continue", "cortex", "crush", "cursor", "deepagents", "devin", "dexto", "droid", "firebender", "forgecode", "gemini-cli", "github-copilot-cli", "goose", "grok-cli", "hermes", "ibm-bob", "iflow-cli", "junie", "lingma", "kilo", "kimi-cli", "kiro-cli", "kode", "mcpjam", "minimax-code", "mistral-vibe", "mux", "neovate", "openclaw", "opencode", "openhands", "ona", "pi", "pochi", "qoder", "qoder-cn", "qwen-code", "replit", "roo", "rovodev", "tabnine-cli", "trae-cn", "trae", "warp", "windsurf", "zencoder", "zed", "zenflow", "universal"]>;
+export { AgentIdSchema };
 /**
  * Agent identifiers users may persist in `axm.json`.
  *
@@ -535,5 +534,4 @@ export declare const ConfigurableAgentIdSchema: Schema.Literals<readonly ["adal"
 export type AgentId = Schema.Schema.Type<typeof AgentIdSchema>;
 /** @experimental This API is unstable and may change without notice. */
 export type ConfigurableAgentId = Schema.Schema.Type<typeof ConfigurableAgentIdSchema>;
-export {};
 //# sourceMappingURL=common.d.ts.map

package/dist/src/unstable/extensions/common.js

@@ -7,7 +7,8 @@ import * as EffectRecord from "effect/Record";
 import * as Schema from "effect/Schema";
 import * as Option from "effect/Option";
 import * as Result from "effect/Result";
-import { AGENT_IDS, CONFIGURABLE_AGENT_IDS } from "../agents/types.js";
+import { AgentIdSchema } from "../agent-capabilities/catalog.js";
+import { CONFIGURABLE_AGENT_IDS } from "../agents/types.js";
 import { HANDLE_PATTERN_SOURCE, HandleSchema } from "./handle.js";
 import { parseLicenseExpression } from "./license.js";
 import { CompanionPackageSchema } from "../package-urls/index.js";
@@ -570,24 +571,17 @@ export const NonPackManifestFields = {
         description: "Pack recommendations and same-pack composition metadata. Entries do not install or guarantee the pack or its members.",
     }))),
     standalone: Schema.optional(Schema.Boolean.pipe(Schema.annotate({
-        description: "False means the extension requires sibling extensions that are direct members of a pack named in recommendedPacks; it does not create dependencies.",
+        description: "False means the extension requires sibling extensions that are direct members of a pack named in recommendedPacks, resolved by extension identity rather than by path; it does not create dependencies.",
         default: true,
     }))),
 };
 /**
- * Agent identifier enumeration for supported coding agents.
- *
- * Derived from `AGENT_IDS` in agents/types.ts — compile-time enforced,
- * no manual sync required.
+ * Agent identifier enumeration for supported coding agents: the single
+ * definition lives in the capability catalog.
  *
  * @experimental This API is unstable and may change without notice.
  */
-export const AgentIdSchema = Schema.Literals([...AGENT_IDS]).annotate({
-    identifier: "AgentId",
-    title: "Agent ID",
-    description: "Supported coding agent identifier.",
-    examples: ["claude-code", "codex", "cursor"],
-});
+export { AgentIdSchema };
 /**
  * Agent identifiers users may persist in `axm.json`.
  *

package/dist/src/unstable/path-types.d.ts

@@ -19,4 +19,11 @@ export declare const makeAbsolutePath: (path: Path.Path, value: string) => Absol
 export declare const makeRelativePath: (path: Path.Path, value: string) => Option.Option<RelativePath>;
 export declare const makeWorkspaceRelativePath: (path: Path.Path, workspaceRoot: AbsolutePath | string, target: string) => Option.Option<RelativePath>;
 export declare const makeWorkspaceRelativeSourcePath: (path: Path.Path, workspaceRoot: AbsolutePath | string, target: string) => Option.Option<string>;
+/**
+ * Whether a resolved target path stays within a base directory.
+ *
+ * Uses a path-separator boundary check so a sibling directory sharing a name
+ * prefix is not mistaken for a child.
+ */
+export declare const isPathSafe: (path: Path.Path, base: string, target: string) => boolean;
 //# sourceMappingURL=path-types.d.ts.map

package/dist/src/unstable/path-types.js

@@ -45,4 +45,15 @@ export const makeWorkspaceRelativeSourcePath = (path, workspaceRoot, target) =>
         return Option.none();
     return Option.some(path.normalize(relative.length === 0 ? "." : relative));
 };
+/**
+ * Whether a resolved target path stays within a base directory.
+ *
+ * Uses a path-separator boundary check so a sibling directory sharing a name
+ * prefix is not mistaken for a child.
+ */
+export const isPathSafe = (path, base, target) => {
+    const resolvedBase = path.resolve(base);
+    const resolvedTarget = path.resolve(target);
+    return resolvedTarget === resolvedBase || resolvedTarget.startsWith(resolvedBase + path.sep);
+};
 //# sourceMappingURL=path-types.js.map

package/dist/src/unstable/sources/source-host-provider.d.ts

@@ -75,6 +75,59 @@ export type NamedRegistryResolution = {
     readonly requestedRange?: string;
     readonly candidate: ReleaseAgeEvidence;
 };
+/**
+ * Index-level selection decision for one named Registry target, before the
+ * provider maps the chosen entry to an `ExtensionRef` or probes any archive.
+ * Versions are identified by their version string; the provider owns the
+ * index and looks the entry up.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type NamedRegistryVersionDecision = {
+    readonly kind: "selected";
+    readonly version: string;
+    readonly newerHeld?: ReleaseAgeEvidence;
+} | {
+    readonly kind: "exempted";
+    readonly version: string;
+    readonly bypassed: ReleaseAgeEvidence;
+    readonly exemption: ReleaseAgeExemption;
+} | {
+    readonly kind: "not_found";
+} | {
+    readonly kind: "version_unsatisfied";
+    readonly requestedRange: string;
+} | {
+    readonly kind: "policy_held";
+    readonly requestedRange?: string;
+    readonly candidate: ReleaseAgeEvidence;
+};
+/**
+ * What selecting one probe-verified candidate would mean under the policy.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type NamedRegistryCandidateOutcome = {
+    readonly kind: "selected";
+} | {
+    readonly kind: "exempted";
+    readonly bypassed: ReleaseAgeEvidence;
+    readonly exemption: ReleaseAgeExemption;
+} | {
+    readonly kind: "held";
+    readonly candidate: ReleaseAgeEvidence;
+};
+/**
+ * One candidate a provider may verify before selecting a named target, in
+ * policy order: selectable candidates newest first, then held candidates
+ * newest first.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export interface NamedRegistryCandidate {
+    readonly version: string;
+    readonly outcome: NamedRegistryCandidateOutcome;
+}
 /**
  * Materialized extension files ready for installation.
  *

package/package.json

@@ -11,6 +11,7 @@
   },
   "description": "Shared AgentXM extension model: identities, manifests, version constraints, and agent capabilities. Unstable and unsupported — use the axm.sh CLI.",
   "devDependencies": {
+    "@agentxm/specification-metadata": "0.28.13",
     "@effect/vitest": "4.0.0-rc.112",
     "@types/semver": "^7.7.1",
     "@types/spdx-expression-parse": "4.0.0",
@@ -62,6 +63,16 @@
       "default": "./dist/src/unstable/extension-types/index.js",
       "types": "./dist/src/unstable/extension-types/index.d.ts"
     },
+    "./unstable/extension-types/catalog": {
+      "axm-source": "./src/unstable/extension-types/catalog.ts",
+      "default": "./dist/src/unstable/extension-types/catalog.js",
+      "types": "./dist/src/unstable/extension-types/catalog.d.ts"
+    },
+    "./unstable/extension-types/derive": {
+      "axm-source": "./src/unstable/extension-types/derive.ts",
+      "default": "./dist/src/unstable/extension-types/derive.js",
+      "types": "./dist/src/unstable/extension-types/derive.d.ts"
+    },
     "./unstable/extension-types/schema": {
       "axm-source": "./src/unstable/extension-types/schema.ts",
       "default": "./dist/src/unstable/extension-types/schema.js",
@@ -287,11 +298,6 @@
       "default": "./dist/src/unstable/sources/workspace.js",
       "types": "./dist/src/unstable/sources/workspace.d.ts"
     },
-    "./unstable/specifications": {
-      "axm-source": "./src/unstable/specifications/index.ts",
-      "default": "./dist/src/unstable/specifications/index.js",
-      "types": "./dist/src/unstable/specifications/index.d.ts"
-    },
     "./unstable/subagents/manifest-schema": {
       "axm-source": "./src/unstable/subagents/manifest-schema.ts",
       "default": "./dist/src/unstable/subagents/manifest-schema.js",
@@ -327,11 +333,11 @@
     "access": "public"
   },
   "repository": {
-    "directory": "packages/extension-model",
+    "directory": "packages/core/extension-model",
     "type": "git",
     "url": "https://github.com/agentxm/axm.git"
   },
   "sideEffects": false,
   "type": "module",
-  "version": "0.28.12"
-}
+  "version": "0.28.13"
+}

package/dist/src/unstable/specifications/conformance.d.ts

@@ -1,62 +0,0 @@
-/**
- * Corpus conformance for executable specifications.
- *
- * A pure check over already-decoded metadata: it establishes that a
- * specification corpus has the contract's form and linkage — vocabulary,
- * identity, goal references, boundary rationale, lineage, and product
- * language. A clean result never establishes that the accepted obligations
- * are the right ones; that judgment stays with set review and the acceptance
- * decision.
- *
- * Both repositories run this check over their own corpus. Shared goal
- * identities come from the installed contract, so a specification that names
- * a shared goal the installed release cohort does not register is a dangling
- * cross-repository reference and fails here.
- *
- * @experimental This API is unstable and may change without notice.
- */
-import { type ExecutionBinding, type ProductGoalRegistry, type SpecificationMetadata } from "./contract.js";
-export interface ConformanceIssue {
-    readonly severity: "error" | "warning";
-    /** Repository-relative source the issue is anchored to. */
-    readonly source: string;
-    readonly message: string;
-}
-export interface CorpusSpecification {
-    /** Repository-relative source path of the specification file. */
-    readonly source: string;
-    readonly metadata: SpecificationMetadata;
-}
-export interface CorpusExecutionBinding {
-    /** Repository-relative source path of the boundary execution. */
-    readonly source: string;
-    readonly binding: ExecutionBinding;
-}
-export interface CorpusInput {
-    readonly specifications: readonly CorpusSpecification[];
-    /** The repository's local product-goal registry. */
-    readonly localGoals: ProductGoalRegistry;
-    /** Source path reported for local-registry issues. */
-    readonly localGoalsSource: string;
-    /** Shared goals from the installed contract. Defaults to `sharedProductGoals`. */
-    readonly sharedGoals?: ProductGoalRegistry;
-    readonly executionBindings?: readonly CorpusExecutionBinding[];
-}
-/**
- * Whether at least one declared method produces runner evidence. A method
- * set made only of unverifiable methods is reported as unverified by the
- * harness, never as passing.
- */
-export declare const isExecutableMethodSet: (methods: readonly string[]) => boolean;
-/**
- * Lints a title or statement for implementation vocabulary. Specification
- * text describes conditions and observable results; it never names
- * handlers, services, Layers, private functions, or mock interactions.
- */
-export declare const lintProductLanguage: (text: string) => string | undefined;
-/**
- * Checks one corpus for contract form and linkage. Issues are ordered by
- * discovery; callers decide whether warnings block.
- */
-export declare const checkSpecificationCorpus: (input: CorpusInput) => readonly ConformanceIssue[];
-//# sourceMappingURL=conformance.d.ts.map

package/dist/src/unstable/specifications/conformance.js

@@ -1,137 +0,0 @@
-/**
- * Corpus conformance for executable specifications.
- *
- * A pure check over already-decoded metadata: it establishes that a
- * specification corpus has the contract's form and linkage — vocabulary,
- * identity, goal references, boundary rationale, lineage, and product
- * language. A clean result never establishes that the accepted obligations
- * are the right ones; that judgment stays with set review and the acceptance
- * decision.
- *
- * Both repositories run this check over their own corpus. Shared goal
- * identities come from the installed contract, so a specification that names
- * a shared goal the installed release cohort does not register is a dangling
- * cross-repository reference and fails here.
- *
- * @experimental This API is unstable and may change without notice.
- */
-import { IDENTITY_SEGMENT_PATTERN, UNVERIFIABLE_SPECIFICATION_METHODS, } from "./contract.js";
-import { sharedProductGoals } from "./shared-goals.js";
-/** Words that identify implementation vocabulary leaking into product language. */
-const IMPLEMENTATION_WORDS = new Set([
-    "layer",
-    "handler",
-    "mock",
-    "stub",
-    "middleware",
-    "refactor",
-]);
-const CAMEL_CASE_TOKEN = /\b[a-z]+[A-Z][A-Za-z]*\b/;
-/**
- * Whether at least one declared method produces runner evidence. A method
- * set made only of unverifiable methods is reported as unverified by the
- * harness, never as passing.
- */
-export const isExecutableMethodSet = (methods) => methods.some((method) => !UNVERIFIABLE_SPECIFICATION_METHODS.some((entry) => entry === method));
-/**
- * Lints a title or statement for implementation vocabulary. Specification
- * text describes conditions and observable results; it never names
- * handlers, services, Layers, private functions, or mock interactions.
- */
-export const lintProductLanguage = (text) => {
-    if (CAMEL_CASE_TOKEN.test(text)) {
-        return `contains an implementation-style camelCase token: "${text}"`;
-    }
-    for (const word of text.toLowerCase().split(/[^a-z]+/)) {
-        if (IMPLEMENTATION_WORDS.has(word)) {
-            return `contains implementation vocabulary ("${word}"): "${text}"`;
-        }
-    }
-    return undefined;
-};
-const error = (source, message) => ({
-    severity: "error",
-    source,
-    message,
-});
-const warning = (source, message) => ({
-    severity: "warning",
-    source,
-    message,
-});
-/**
- * Checks one corpus for contract form and linkage. Issues are ordered by
- * discovery; callers decide whether warnings block.
- */
-export const checkSpecificationCorpus = (input) => {
-    const issues = [];
-    const sharedGoals = input.sharedGoals ?? sharedProductGoals;
-    for (const id of Object.keys(input.localGoals)) {
-        if (!IDENTITY_SEGMENT_PATTERN.test(id)) {
-            issues.push(error(input.localGoalsSource, `product-goal id \`${id}\` must be a lowercase kebab identifier`));
-        }
-        if (Object.hasOwn(sharedGoals, id)) {
-            issues.push(error(input.localGoalsSource, `product goal \`${id}\` is a shared goal; reference the shared identity instead of redefining it locally`));
-        }
-    }
-    const registeredGoals = new Map();
-    for (const registry of [sharedGoals, input.localGoals]) {
-        for (const [id, definition] of Object.entries(registry)) {
-            registeredGoals.set(id, { status: definition.status ?? "active" });
-        }
-    }
-    const byRequirement = new Map();
-    for (const specification of input.specifications) {
-        const existing = byRequirement.get(specification.metadata.requirement);
-        if (existing !== undefined) {
-            issues.push(error(specification.source, `duplicate requirement identity \`${specification.metadata.requirement}\` (also declared in ${existing.source})`));
-            continue;
-        }
-        byRequirement.set(specification.metadata.requirement, specification);
-    }
-    const referencedGoals = new Set();
-    for (const { source, metadata } of input.specifications) {
-        for (const goal of metadata.goals) {
-            referencedGoals.add(goal);
-            const registered = registeredGoals.get(goal);
-            if (registered === undefined) {
-                issues.push(error(source, `references unregistered product goal \`${goal}\``));
-            }
-            else if (registered.status === "retired") {
-                issues.push(error(source, `references retired product goal \`${goal}\`; the specification is a retirement candidate`));
-            }
-        }
-        for (const superseded of metadata.supersedes) {
-            if (byRequirement.has(superseded)) {
-                issues.push(error(source, `supersedes \`${superseded}\`, which is still present in the corpus; retire the predecessor in the same change`));
-            }
-        }
-        const titleFinding = lintProductLanguage(metadata.title);
-        if (titleFinding !== undefined) {
-            issues.push(error(source, `title ${titleFinding}`));
-        }
-        const statementFinding = lintProductLanguage(metadata.statement);
-        if (statementFinding !== undefined) {
-            issues.push(error(source, `statement ${statementFinding}`));
-        }
-        if (!isExecutableMethodSet(metadata.methods)) {
-            issues.push(warning(source, `declares only unverifiable methods (${metadata.methods.join(", ")}); the harness reports this specification as unverified`));
-        }
-    }
-    for (const [id, definition] of registeredGoals) {
-        if (definition.status === "active" &&
-            !referencedGoals.has(id) &&
-            input.specifications.length > 0) {
-            issues.push(warning(input.localGoalsSource, `active product goal \`${id}\` has no referencing specification (missing coverage or a dead goal)`));
-        }
-    }
-    for (const { source, binding } of input.executionBindings ?? []) {
-        for (const requirement of binding.requirements) {
-            if (!byRequirement.has(requirement)) {
-                issues.push(error(source, `execution binding references unknown requirement \`${requirement}\``));
-            }
-        }
-    }
-    return issues;
-};
-//# sourceMappingURL=conformance.js.map

package/dist/src/unstable/specifications/contract.d.ts

@@ -1,215 +0,0 @@
-/**
- * Shared executable-specification contract.
- *
- * One metadata contract, one classification lens, one set of controlled
- * vocabularies, and one shared product-goal registry for every AgentXM
- * specification corpus. Each repository keeps its own specification files,
- * local product goals, and local placement rules; only this contract and the
- * shared goal identities cross the repository boundary.
- *
- * Metadata is data. Every specification file exports one `specification`
- * constant built with `defineSpecification`: a literal object carrying only
- * the cross-method information that discovery, conformance, and reporting
- * need. It never wraps or replaces native test-framework constructs, and
- * catalog tooling reads it statically without executing the specification.
- *
- * @experimental This API is unstable and may change without notice.
- */
-/**
- * The review lens a specification is classified by. Classification selects
- * the review expertise and quality criteria the obligation most needs; it
- * does not determine priority, acceptance, subject, or verification method.
- *
- * - `functional`: responses, transformations, rules, and observable
- *   capabilities;
- * - `quality`: a measurable degree such as performance, reliability,
- *   security, or installability, named by `characteristic`;
- * - `constraint`: a genuine restriction on solution, environment,
- *   technology, or operation;
- * - `external-conformance`: an obligation adopted from a named law,
- *   standard, contract, or interface;
- * - `human-factors`: capabilities and qualities arising from people, tasks,
- *   accessibility, ergonomics, or context of use; and
- * - `process`: an obligation on development, delivery, operation, support,
- *   migration, or retirement.
- */
-export type SpecificationClass = "functional" | "quality" | "constraint" | "external-conformance" | "human-factors" | "process";
-export declare const SPECIFICATION_CLASSES: readonly SpecificationClass[];
-/**
- * How a specification participates in the product contract and its reading
- * paths. Experience specifications describe tasks in product language,
- * interface specifications state public machine-consumable contracts, and
- * supporting specifications state subordinate system or engineering
- * obligations.
- */
-export type SpecificationRole = "experience" | "interface" | "supporting";
-export declare const SPECIFICATION_ROLES: readonly SpecificationRole[];
-/**
- * Where the specification's default execution observes the system.
- * Additional boundary-specific executions bind their own evidence to the
- * same requirement identity.
- */
-export type ExecutionBoundary = "memory" | "process" | "binary" | "packed-artifact" | "installed" | "platform" | "published-artifact" | "deployed" | "repository";
-export declare const EXECUTION_BOUNDARIES: readonly ExecutionBoundary[];
-/** When this specification's evidence is selected by default. */
-export type ExecutionSelection = "per-change" | "platform-matrix" | "scheduled" | "release-candidate" | "post-deployment";
-export declare const EXECUTION_SELECTIONS: readonly ExecutionSelection[];
-/**
- * Known testing methods. The vocabulary is extensible: a method not listed
- * here is accepted when it is a lowercase kebab identifier, so a new or
- * combined method never needs a contract change before use.
- */
-export declare const KNOWN_SPECIFICATION_METHODS: readonly ["example", "decision-table", "property", "model", "contract", "conformance-matrix", "golden-output", "measurement", "static", "smoke", "manual", "review"];
-export type KnownSpecificationMethod = (typeof KNOWN_SPECIFICATION_METHODS)[number];
-/**
- * Methods whose evidence is produced by a person rather than a runner. A
- * specification whose methods are all unverifiable is reported as unverified
- * by the harness; it is never reported as passing.
- */
-export declare const UNVERIFIABLE_SPECIFICATION_METHODS: readonly KnownSpecificationMethod[];
-/**
- * Known quality characteristics. Required for `quality`-class specifications
- * and permitted elsewhere; extensible under the same identifier rule as
- * methods.
- */
-export declare const KNOWN_QUALITY_CHARACTERISTICS: readonly ["installability", "compatibility", "performance", "security", "privacy", "reliability", "availability", "maintainability", "observability", "accessibility", "usability"];
-export type KnownQualityCharacteristic = (typeof KNOWN_QUALITY_CHARACTERISTICS)[number];
-/** Segments of a requirement identity or product-goal identity. */
-export declare const IDENTITY_SEGMENT_PATTERN: RegExp;
-/** A declared blind spot of one specification and the condition that retires it. */
-export interface SpecificationLimitation {
-    /** What the specification's evidence cannot establish, in product language. */
-    readonly limitation: string;
-    /** The observable condition under which this limitation is removed. */
-    readonly retirementCondition: string;
-}
-export interface SpecificationMetadata {
-    /**
-     * Stable requirement identity: lowercase kebab path segments joined by `/`,
-     * for example `cli/install/realizes-direct-intent`. Declared here, not
-     * derived from the filesystem; repository policy keeps it equal to the
-     * file's path under `specifications/`, so moving or renaming a file is an
-     * identity change — a requirements decision.
-     */
-    readonly requirement: string;
-    /** Product-language title, readable without the source. */
-    readonly title: string;
-    /**
-     * The normative statement: obligated subject, condition or trigger, and
-     * the required or prohibited outcome, in product language. This sentence
-     * is the obligation; native tests are its reportable scenarios.
-     */
-    readonly statement: string;
-    /** The review lens this specification is classified by. */
-    readonly class: SpecificationClass;
-    /**
-     * The quality characteristic a `quality` specification measures, or the
-     * human-factors quality a `human-factors` specification names. Required
-     * for `quality`; optional otherwise.
-     */
-    readonly characteristic?: string;
-    /** The specification's primary role in the product contract. */
-    readonly role: SpecificationRole;
-    /**
-     * Registered product-goal identities this specification supports. Every
-     * entry must exist, active, in the shared registry or the repository's
-     * local registry.
-     */
-    readonly goals: readonly [string, ...string[]];
-    /** Observation boundary of the default execution. Defaults to `memory`. */
-    readonly boundary?: ExecutionBoundary;
-    /**
-     * Why this specification observes a boundary other than memory: the
-     * evidence that boundary supplies which an in-memory run cannot. Required
-     * whenever `boundary` is not `memory`.
-     */
-    readonly boundaryRationale?: string;
-    /** Testing methods the specification actually uses. */
-    readonly methods: readonly [string, ...string[]];
-    /** Default evidence-selection policy. Defaults to `per-change`. */
-    readonly selection?: ExecutionSelection;
-    /**
-     * Sources this obligation was derived from: predecessor requirement
-     * identities, prior specification identities, tests that witnessed the
-     * behavior, or surfaces that supplied its conditions. Empty when the
-     * specification is an original source.
-     */
-    readonly derivedFrom: readonly string[];
-    /**
-     * Identities this specification replaces as authority. A superseded
-     * identity is retired in the same change that lands its successor and
-     * must not remain present in the corpus.
-     */
-    readonly supersedes: readonly string[];
-    /**
-     * Conditions the obligation presumes and its evidence does not establish.
-     * An empty list records that none were found after review; `"unknown"`
-     * records that assumptions have not been assessed.
-     */
-    readonly assumptions: readonly string[] | "unknown";
-    /**
-     * Unresolved questions about the obligation's meaning, scope, or subject.
-     * An empty list records that none remain; `"unknown"` records that the
-     * specification has not been reviewed for open questions.
-     */
-    readonly openQuestions: readonly string[] | "unknown";
-    /** Declared blind spots of this specification's evidence. */
-    readonly limitations?: readonly [SpecificationLimitation, ...SpecificationLimitation[]];
-}
-/**
- * Declares one specification's metadata. Identity function: it exists to type
- * the literal and to give discovery a stable syntactic anchor.
- */
-export declare const defineSpecification: <const M extends SpecificationMetadata>(metadata: M) => M;
-/** One registered product goal. */
-export interface ProductGoalDefinition {
-    /** One-sentence statement of the desired outcome this goal names. */
-    readonly outcome: string;
-    /**
-     * Retired goals stay registered so specifications referencing them are
-     * flagged as retirement candidates instead of silently orphaned.
-     */
-    readonly status?: "active" | "retired";
-}
-export type ProductGoalRegistry = Readonly<Record<string, ProductGoalDefinition>>;
-/**
- * Declares a product-goal registry. Identity function with the same
- * literal-only discipline as `defineSpecification`.
- */
-export declare const defineProductGoals: <const R extends ProductGoalRegistry>(registry: R) => R;
-/**
- * Binds a boundary-specific execution (for example an end-to-end test file)
- * to the requirement identities it provides evidence for. The execution is
- * evidence, never a second authority: it must not state new requirements.
- */
-export interface ExecutionBinding {
-    /** Requirement identities this execution binds evidence to. */
-    readonly requirements: readonly [string, ...string[]];
-    /** Observation boundary of this execution. */
-    readonly boundary: ExecutionBoundary;
-    /**
-     * The boundary-specific reason this execution exists beyond the in-memory
-     * evidence — required so boundary scenarios never silently duplicate
-     * in-memory scenarios.
-     */
-    readonly rationale: string;
-}
-/** Declares a boundary-specific execution binding. Identity function. */
-export declare const defineExecutionBinding: <const B extends ExecutionBinding>(binding: B) => B;
-/**
- * One static verification gate whose result is bound to the owning
- * specification's requirement identity. Bound evidence supports the owning
- * specification; it never replaces it and never states a new requirement.
- */
-export interface BoundEvidenceGate {
-    /** The static gate, named by the verification surface that runs it. */
-    readonly gate: string;
-    /** What the gate verifies for this requirement, in product language. */
-    readonly verifies: string;
-}
-/**
- * Declares the static gates bound to a specification as evidence. Exported
- * as `boundEvidence` beside the `specification` constant. Identity function.
- */
-export declare const defineBoundEvidence: <const E extends readonly [BoundEvidenceGate, ...BoundEvidenceGate[]]>(evidence: E) => E;
-//# sourceMappingURL=contract.d.ts.map

package/dist/src/unstable/specifications/contract.js

@@ -1,114 +0,0 @@
-/**
- * Shared executable-specification contract.
- *
- * One metadata contract, one classification lens, one set of controlled
- * vocabularies, and one shared product-goal registry for every AgentXM
- * specification corpus. Each repository keeps its own specification files,
- * local product goals, and local placement rules; only this contract and the
- * shared goal identities cross the repository boundary.
- *
- * Metadata is data. Every specification file exports one `specification`
- * constant built with `defineSpecification`: a literal object carrying only
- * the cross-method information that discovery, conformance, and reporting
- * need. It never wraps or replaces native test-framework constructs, and
- * catalog tooling reads it statically without executing the specification.
- *
- * @experimental This API is unstable and may change without notice.
- */
-export const SPECIFICATION_CLASSES = [
-    "functional",
-    "quality",
-    "constraint",
-    "external-conformance",
-    "human-factors",
-    "process",
-];
-export const SPECIFICATION_ROLES = [
-    "experience",
-    "interface",
-    "supporting",
-];
-export const EXECUTION_BOUNDARIES = [
-    "memory",
-    "process",
-    "binary",
-    "packed-artifact",
-    "installed",
-    "platform",
-    "published-artifact",
-    "deployed",
-    "repository",
-];
-export const EXECUTION_SELECTIONS = [
-    "per-change",
-    "platform-matrix",
-    "scheduled",
-    "release-candidate",
-    "post-deployment",
-];
-/**
- * Known testing methods. The vocabulary is extensible: a method not listed
- * here is accepted when it is a lowercase kebab identifier, so a new or
- * combined method never needs a contract change before use.
- */
-export const KNOWN_SPECIFICATION_METHODS = [
-    "example",
-    "decision-table",
-    "property",
-    "model",
-    "contract",
-    "conformance-matrix",
-    "golden-output",
-    "measurement",
-    "static",
-    "smoke",
-    "manual",
-    "review",
-];
-/**
- * Methods whose evidence is produced by a person rather than a runner. A
- * specification whose methods are all unverifiable is reported as unverified
- * by the harness; it is never reported as passing.
- */
-export const UNVERIFIABLE_SPECIFICATION_METHODS = [
-    "manual",
-    "review",
-];
-/**
- * Known quality characteristics. Required for `quality`-class specifications
- * and permitted elsewhere; extensible under the same identifier rule as
- * methods.
- */
-export const KNOWN_QUALITY_CHARACTERISTICS = [
-    "installability",
-    "compatibility",
-    "performance",
-    "security",
-    "privacy",
-    "reliability",
-    "availability",
-    "maintainability",
-    "observability",
-    "accessibility",
-    "usability",
-];
-/** Segments of a requirement identity or product-goal identity. */
-export const IDENTITY_SEGMENT_PATTERN = /^[a-z0-9]+(-[a-z0-9]+)*$/;
-/**
- * Declares one specification's metadata. Identity function: it exists to type
- * the literal and to give discovery a stable syntactic anchor.
- */
-export const defineSpecification = (metadata) => metadata;
-/**
- * Declares a product-goal registry. Identity function with the same
- * literal-only discipline as `defineSpecification`.
- */
-export const defineProductGoals = (registry) => registry;
-/** Declares a boundary-specific execution binding. Identity function. */
-export const defineExecutionBinding = (binding) => binding;
-/**
- * Declares the static gates bound to a specification as evidence. Exported
- * as `boundEvidence` beside the `specification` constant. Identity function.
- */
-export const defineBoundEvidence = (evidence) => evidence;
-//# sourceMappingURL=contract.js.map

package/dist/src/unstable/specifications/decode.d.ts

@@ -1,57 +0,0 @@
-/**
- * Decoders for the shared specification contract.
- *
- * Catalog tooling extracts each literal statically; result adapters read the
- * exported constant at run time. Both decode the unknown value through these
- * schemas so every corpus applies one vocabulary with one set of messages.
- *
- * @experimental This API is unstable and may change without notice.
- */
-import * as Schema from "effect/Schema";
-import { type ExecutionBinding, type ProductGoalRegistry, type BoundEvidenceGate, type SpecificationMetadata } from "./contract.js";
-export declare const SpecificationMetadataSchema: Schema.Struct<{
-    readonly requirement: Schema.String;
-    readonly title: Schema.NonEmptyString;
-    readonly statement: Schema.NonEmptyString;
-    readonly class: Schema.Literals<import("./contract.js").SpecificationClass[]>;
-    readonly characteristic: Schema.optionalKey<Schema.String>;
-    readonly role: Schema.Literals<import("./contract.js").SpecificationRole[]>;
-    readonly goals: Schema.NonEmptyArray<Schema.String>;
-    readonly boundary: Schema.optionalKey<Schema.Literals<import("./contract.js").ExecutionBoundary[]>>;
-    readonly boundaryRationale: Schema.optionalKey<Schema.NonEmptyString>;
-    readonly methods: Schema.NonEmptyArray<Schema.String>;
-    readonly selection: Schema.optionalKey<Schema.Literals<import("./contract.js").ExecutionSelection[]>>;
-    readonly derivedFrom: Schema.$Array<Schema.NonEmptyString>;
-    readonly supersedes: Schema.$Array<Schema.NonEmptyString>;
-    readonly assumptions: Schema.Union<readonly [Schema.$Array<Schema.NonEmptyString>, Schema.Literal<"unknown">]>;
-    readonly openQuestions: Schema.Union<readonly [Schema.$Array<Schema.NonEmptyString>, Schema.Literal<"unknown">]>;
-    readonly limitations: Schema.optionalKey<Schema.NonEmptyArray<Schema.Struct<{
-        readonly limitation: Schema.NonEmptyString;
-        readonly retirementCondition: Schema.NonEmptyString;
-    }>>>;
-}>;
-export declare const ProductGoalRegistrySchema: Schema.$Record<Schema.String, Schema.Struct<{
-    readonly outcome: Schema.NonEmptyString;
-    readonly status: Schema.optionalKey<Schema.Literals<readonly ["active", "retired"]>>;
-}>>;
-export declare const ExecutionBindingSchema: Schema.Struct<{
-    readonly requirements: Schema.NonEmptyArray<Schema.String>;
-    readonly boundary: Schema.Literals<import("./contract.js").ExecutionBoundary[]>;
-    readonly rationale: Schema.NonEmptyString;
-}>;
-export declare const BoundEvidenceSchema: Schema.NonEmptyArray<Schema.Struct<{
-    readonly gate: Schema.NonEmptyString;
-    readonly verifies: Schema.NonEmptyString;
-}>>;
-export type DecodeResult<T> = {
-    readonly ok: true;
-    readonly value: T;
-} | {
-    readonly ok: false;
-    readonly issues: readonly string[];
-};
-export declare const decodeSpecificationMetadata: (value: unknown) => DecodeResult<SpecificationMetadata>;
-export declare const decodeProductGoalRegistry: (value: unknown) => DecodeResult<ProductGoalRegistry>;
-export declare const decodeExecutionBinding: (value: unknown) => DecodeResult<ExecutionBinding>;
-export declare const decodeBoundEvidence: (value: unknown) => DecodeResult<readonly [BoundEvidenceGate, ...BoundEvidenceGate[]]>;
-//# sourceMappingURL=decode.d.ts.map

package/dist/src/unstable/specifications/decode.js

@@ -1,91 +0,0 @@
-/**
- * Decoders for the shared specification contract.
- *
- * Catalog tooling extracts each literal statically; result adapters read the
- * exported constant at run time. Both decode the unknown value through these
- * schemas so every corpus applies one vocabulary with one set of messages.
- *
- * @experimental This API is unstable and may change without notice.
- */
-import * as Result from "effect/Result";
-import * as Schema from "effect/Schema";
-import { formatSchemaIssuesToLines } from "../schema-issues.js";
-import { EXECUTION_BOUNDARIES, EXECUTION_SELECTIONS, IDENTITY_SEGMENT_PATTERN, SPECIFICATION_CLASSES, SPECIFICATION_ROLES, } from "./contract.js";
-const REQUIREMENT_IDENTITY_PATTERN = /^[a-z0-9]+(-[a-z0-9]+)*(\/[a-z0-9]+(-[a-z0-9]+)*)+$/;
-const RequirementIdentitySchema = Schema.String.pipe(Schema.check(Schema.isPattern(REQUIREMENT_IDENTITY_PATTERN, {
-    title: "Requirement identity",
-    message: "Expected two or more lowercase kebab segments joined by '/'",
-})));
-const IdentifierSchema = Schema.String.pipe(Schema.check(Schema.isPattern(IDENTITY_SEGMENT_PATTERN, {
-    title: "Identifier",
-    message: "Expected a lowercase kebab identifier",
-})));
-const SpecificationLimitationSchema = Schema.Struct({
-    limitation: Schema.NonEmptyString,
-    retirementCondition: Schema.NonEmptyString,
-});
-const StatedOrUnknownSchema = Schema.Union([
-    Schema.Array(Schema.NonEmptyString),
-    Schema.Literal("unknown"),
-]);
-const specificationClasses = SPECIFICATION_CLASSES.map((entry) => entry);
-const specificationRoles = SPECIFICATION_ROLES.map((entry) => entry);
-const executionBoundaries = EXECUTION_BOUNDARIES.map((entry) => entry);
-const executionSelections = EXECUTION_SELECTIONS.map((entry) => entry);
-export const SpecificationMetadataSchema = Schema.Struct({
-    requirement: RequirementIdentitySchema,
-    title: Schema.NonEmptyString,
-    statement: Schema.NonEmptyString,
-    class: Schema.Literals(specificationClasses),
-    characteristic: Schema.optionalKey(IdentifierSchema),
-    role: Schema.Literals(specificationRoles),
-    goals: Schema.NonEmptyArray(IdentifierSchema),
-    boundary: Schema.optionalKey(Schema.Literals(executionBoundaries)),
-    boundaryRationale: Schema.optionalKey(Schema.NonEmptyString),
-    methods: Schema.NonEmptyArray(IdentifierSchema),
-    selection: Schema.optionalKey(Schema.Literals(executionSelections)),
-    derivedFrom: Schema.Array(Schema.NonEmptyString),
-    supersedes: Schema.Array(Schema.NonEmptyString),
-    assumptions: StatedOrUnknownSchema,
-    openQuestions: StatedOrUnknownSchema,
-    limitations: Schema.optionalKey(Schema.NonEmptyArray(SpecificationLimitationSchema)),
-}).pipe(Schema.check(Schema.makeFilter((metadata) => metadata.class === "quality" && metadata.characteristic === undefined
-    ? "A quality specification must name the characteristic it measures"
-    : undefined), Schema.makeFilter((metadata) => (metadata.boundary ?? "memory") !== "memory" && metadata.boundaryRationale === undefined
-    ? "A specification observed outside memory must state the evidence that boundary supplies"
-    : undefined), Schema.makeFilter((metadata) => metadata.supersedes.some((entry) => metadata.supersedes.indexOf(entry) !== metadata.supersedes.lastIndexOf(entry))
-    ? "supersedes must not repeat an identity"
-    : undefined)));
-const ProductGoalDefinitionSchema = Schema.Struct({
-    outcome: Schema.NonEmptyString,
-    status: Schema.optionalKey(Schema.Literals(["active", "retired"])),
-});
-export const ProductGoalRegistrySchema = Schema.Record(IdentifierSchema, ProductGoalDefinitionSchema);
-export const ExecutionBindingSchema = Schema.Struct({
-    requirements: Schema.NonEmptyArray(RequirementIdentitySchema),
-    boundary: Schema.Literals(executionBoundaries),
-    rationale: Schema.NonEmptyString,
-});
-const BoundEvidenceGateSchema = Schema.Struct({
-    gate: Schema.NonEmptyString,
-    verifies: Schema.NonEmptyString,
-});
-export const BoundEvidenceSchema = Schema.NonEmptyArray(BoundEvidenceGateSchema);
-const toDecodeResult = (result) => Result.isSuccess(result)
-    ? { ok: true, value: result.success }
-    : { ok: false, issues: formatSchemaIssuesToLines(result.failure.issue) };
-/**
- * Metadata is a closed literal: a field the contract does not define is a
- * decoding failure, never ignored.
- */
-const decodeMetadata = Schema.decodeUnknownResult(SpecificationMetadataSchema, {
-    onExcessProperty: "error",
-});
-const decodeRegistry = Schema.decodeUnknownResult(ProductGoalRegistrySchema);
-const decodeBinding = Schema.decodeUnknownResult(ExecutionBindingSchema);
-const decodeEvidence = Schema.decodeUnknownResult(BoundEvidenceSchema);
-export const decodeSpecificationMetadata = (value) => toDecodeResult(decodeMetadata(value));
-export const decodeProductGoalRegistry = (value) => toDecodeResult(decodeRegistry(value));
-export const decodeExecutionBinding = (value) => toDecodeResult(decodeBinding(value));
-export const decodeBoundEvidence = (value) => toDecodeResult(decodeEvidence(value));
-//# sourceMappingURL=decode.js.map

package/dist/src/unstable/specifications/index.d.ts

@@ -1,10 +0,0 @@
-/**
- * Area barrel for the shared executable-specification contract.
- *
- * @experimental This API is unstable and may change without notice.
- */
-export { type BoundEvidenceGate, EXECUTION_BOUNDARIES, EXECUTION_SELECTIONS, type ExecutionBinding, type ExecutionBoundary, type ExecutionSelection, IDENTITY_SEGMENT_PATTERN, KNOWN_QUALITY_CHARACTERISTICS, KNOWN_SPECIFICATION_METHODS, type KnownQualityCharacteristic, type KnownSpecificationMethod, type ProductGoalDefinition, type ProductGoalRegistry, SPECIFICATION_CLASSES, SPECIFICATION_ROLES, type SpecificationClass, type SpecificationLimitation, type SpecificationMetadata, type SpecificationRole, UNVERIFIABLE_SPECIFICATION_METHODS, defineBoundEvidence, defineExecutionBinding, defineProductGoals, defineSpecification, } from "./contract.js";
-export { BoundEvidenceSchema, ExecutionBindingSchema, ProductGoalRegistrySchema, SpecificationMetadataSchema, decodeBoundEvidence, decodeExecutionBinding, decodeProductGoalRegistry, decodeSpecificationMetadata, type DecodeResult, } from "./decode.js";
-export { type ConformanceIssue, type CorpusExecutionBinding, type CorpusInput, type CorpusSpecification, checkSpecificationCorpus, isExecutableMethodSet, lintProductLanguage, } from "./conformance.js";
-export { type SharedProductGoalId, sharedProductGoals } from "./shared-goals.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/src/unstable/specifications/index.js

@@ -1,10 +0,0 @@
-/**
- * Area barrel for the shared executable-specification contract.
- *
- * @experimental This API is unstable and may change without notice.
- */
-export { EXECUTION_BOUNDARIES, EXECUTION_SELECTIONS, IDENTITY_SEGMENT_PATTERN, KNOWN_QUALITY_CHARACTERISTICS, KNOWN_SPECIFICATION_METHODS, SPECIFICATION_CLASSES, SPECIFICATION_ROLES, UNVERIFIABLE_SPECIFICATION_METHODS, defineBoundEvidence, defineExecutionBinding, defineProductGoals, defineSpecification, } from "./contract.js";
-export { BoundEvidenceSchema, ExecutionBindingSchema, ProductGoalRegistrySchema, SpecificationMetadataSchema, decodeBoundEvidence, decodeExecutionBinding, decodeProductGoalRegistry, decodeSpecificationMetadata, } from "./decode.js";
-export { checkSpecificationCorpus, isExecutableMethodSet, lintProductLanguage, } from "./conformance.js";
-export { sharedProductGoals } from "./shared-goals.js";
-//# sourceMappingURL=index.js.map

package/dist/src/unstable/specifications/shared-goals.d.ts

@@ -1,36 +0,0 @@
-/**
- * Shared product goals: outcomes that more than one AgentXM repository
- * serves. Each is registered once, here, with a stable identity; every
- * repository's specification corpus references these identities and keeps
- * repository-specific goals in its own local registry. A local registry must
- * not redefine a shared identity.
- *
- * The registry does not restate, own, or rank the specifications that
- * support a goal. Requirements review walks goals: a retired goal makes its
- * referencing specifications retirement candidates, and an active goal with
- * no referencing specification identifies missing coverage or a dead goal.
- *
- * @experimental This API is unstable and may change without notice.
- */
-export declare const sharedProductGoals: {
-    readonly "extension-adoption": {
-        readonly outcome: "People and agents can find, install, update, and remove reusable extensions across coding agents through dependable product surfaces.";
-    };
-    readonly "trustworthy-distribution": {
-        readonly outcome: "Publishing and acquiring extensions preserves integrity, provenance, and immutable accepted resolutions.";
-    };
-    readonly "machine-automation": {
-        readonly outcome: "Machine consumers can drive AgentXM surfaces non-interactively with complete, schema-backed results separated from diagnostics.";
-    };
-    readonly "knowledge-access": {
-        readonly outcome: "People and agents can discover concepts, commands, and contracts from the surface they are already using.";
-    };
-    readonly "privacy-and-consent": {
-        readonly outcome: "Observation of product use stays within the documented data boundary and under the control of the person being observed.";
-    };
-    readonly "dependable-change-process": {
-        readonly outcome: "Changes and releases land through the governed repository process with required evidence and human approval.";
-    };
-};
-export type SharedProductGoalId = keyof typeof sharedProductGoals;
-//# sourceMappingURL=shared-goals.d.ts.map

package/dist/src/unstable/specifications/shared-goals.js

@@ -1,36 +0,0 @@
-/**
- * Shared product goals: outcomes that more than one AgentXM repository
- * serves. Each is registered once, here, with a stable identity; every
- * repository's specification corpus references these identities and keeps
- * repository-specific goals in its own local registry. A local registry must
- * not redefine a shared identity.
- *
- * The registry does not restate, own, or rank the specifications that
- * support a goal. Requirements review walks goals: a retired goal makes its
- * referencing specifications retirement candidates, and an active goal with
- * no referencing specification identifies missing coverage or a dead goal.
- *
- * @experimental This API is unstable and may change without notice.
- */
-import { defineProductGoals } from "./contract.js";
-export const sharedProductGoals = defineProductGoals({
-    "extension-adoption": {
-        outcome: "People and agents can find, install, update, and remove reusable extensions across coding agents through dependable product surfaces.",
-    },
-    "trustworthy-distribution": {
-        outcome: "Publishing and acquiring extensions preserves integrity, provenance, and immutable accepted resolutions.",
-    },
-    "machine-automation": {
-        outcome: "Machine consumers can drive AgentXM surfaces non-interactively with complete, schema-backed results separated from diagnostics.",
-    },
-    "knowledge-access": {
-        outcome: "People and agents can discover concepts, commands, and contracts from the surface they are already using.",
-    },
-    "privacy-and-consent": {
-        outcome: "Observation of product use stays within the documented data boundary and under the control of the person being observed.",
-    },
-    "dependable-change-process": {
-        outcome: "Changes and releases land through the governed repository process with required evidence and human approval.",
-    },
-});
-//# sourceMappingURL=shared-goals.js.map