@cratylus/canon 0.1.0

package/dist/hooks/stance-guardrail.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stance-guardrail.js","sourceRoot":"","sources":["../../src/hooks/stance-guardrail.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,oCAAoC,CAAC;AAG7D,wEAAwE;AACxE,8EAA8E;AAC9E,2EAA2E;AAC3E,2EAA2E;AAC3E,8EAA8E;AAC9E,gFAAgF;AAEhF,MAAM,CAAC,MAAM,eAAe,GAAa;IACvC,EAAE,EAAE,kBAAkB;IACtB,OAAO,EACL,8UAA8U;IAChV,SAAS,EAAE,SAAS;IACpB,KAAK,EAAE,CAAC;IACR,MAAM,EAAE,CAAC,UAAU,EAAE,cAAc,CAAC;IACpC,KAAK,EAAE,qBAAqB;IAC5B,OAAO,EAAE,EAAE;IACX,IAAI,EAAE,EAAE;IACR,OAAO,EAAE;QACP;YACE,QAAQ,EAAE,qBAAqB;YAC/B,UAAU,EAAE,sDAAsD;YAClE,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkdd;SACI;QACD;YACE,QAAQ,EAAE,iBAAiB;YAC3B,UAAU,EAAE,kDAAkD;YAC9D,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsEd;SACI;QACD;YACE,QAAQ,EAAE,wBAAwB;YAClC,UAAU,EAAE,yDAAyD;YACrE,UAAU,EAAE,KAAK;YACjB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA0LX,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuLV;SACI;KACF;CACF,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@cratylus/schema").AgentPlugin;
+export default _default;

package/dist/index.js

@@ -0,0 +1,45 @@
+// ─────────────────────────────────────────────────────────────────────────────
+// canon AS A PLUGIN — the package's `defineAgentPlugin` default export.
+//
+// This makes canon the FIRST agent-plugin: the baseline catalog + golden
+// example + zero-config default, distributed as a peer plugin (not special-cased
+// as "the corpus"). A consumer `npm i @cratylus/canon` then `extends` this
+// exported object — addressing by IMPORTED BINDING, never a string id.
+//
+// The dir fields point at the live source dirs this corpus already carries: the
+// fragment modules under `src/dimensions/<dim>/*.ts`, and the agent / skill preset
+// modules. The forge resolver scans these paths exactly as the existing
+// directory-scan does; no resolver logic lives here.
+//
+// SELF-LOCATION (why absolute, not `'./src/dimensions'`): a consumer `extends`
+// this plugin by importing the OBJECT, which has lost its package-root provenance
+// — a bare relative dir would be unresolvable to the config-is-code loader,
+// wherever the package is installed. So the plugin resolves its own dirs against
+// `import.meta.url` at definition time; the loader consumes the absolute paths
+// verbatim. This module is at `src/index.ts`, so the dirs are its siblings.
+// ─────────────────────────────────────────────────────────────────────────────
+import { fileURLToPath } from 'node:url';
+import { defineAgentPlugin } from '@cratylus/schema';
+import { foundingDoctrine } from './genus/founding-doctrine.js';
+import { CANONICAL_EVENTS, MANIFEST } from './manifest.js';
+/** Resolve a sibling dir of this module to an absolute path (self-location). */
+const dir = (rel) => fileURLToPath(new URL(rel, import.meta.url));
+export default defineAgentPlugin({
+    name: 'canon',
+    // WHICH dimensions exist — this corpus's own manifest, carried on the plugin so
+    // a consumer projecting canon gets canon's dimension set without the projector
+    // containing it. The same carry as `preamble` below.
+    manifest: MANIFEST,
+    // WHICH lifecycle events exist — carried the same way, and for the same reason.
+    // The projector needs the members to emit a host's runtime configuration
+    // (ARCHITECTURE property 4); property 3 says it may only RECEIVE them. This
+    // field is that receipt: DATA on the plugin, never an import of this package.
+    events: CANONICAL_EVENTS,
+    fragments: dir('./dimensions'),
+    agents: dir('./agents'),
+    skills: dir('./skills'),
+    // The axiom rides the PLUGIN, so it survives projection by any consumer.
+    preamble: foundingDoctrine,
+    hooks: dir('./hooks'),
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,wEAAwE;AACxE,EAAE;AACF,yEAAyE;AACzE,iFAAiF;AACjF,2EAA2E;AAC3E,uEAAuE;AACvE,EAAE;AACF,gFAAgF;AAChF,mFAAmF;AACnF,wEAAwE;AACxE,qDAAqD;AACrD,EAAE;AACF,+EAA+E;AAC/E,kFAAkF;AAClF,4EAA4E;AAC5E,iFAAiF;AACjF,+EAA+E;AAC/E,4EAA4E;AAC5E,gFAAgF;AAEhF,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE3D,gFAAgF;AAChF,MAAM,GAAG,GAAG,CAAC,GAAW,EAAU,EAAE,CAClC,aAAa,CAAC,IAAI,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;AAE/C,eAAe,iBAAiB,CAAC;IAC/B,IAAI,EAAE,OAAO;IACb,gFAAgF;IAChF,+EAA+E;IAC/E,qDAAqD;IACrD,QAAQ,EAAE,QAAQ;IAClB,gFAAgF;IAChF,yEAAyE;IACzE,4EAA4E;IAC5E,8EAA8E;IAC9E,MAAM,EAAE,gBAAgB;IACxB,SAAS,EAAE,GAAG,CAAC,cAAc,CAAC;IAC9B,MAAM,EAAE,GAAG,CAAC,UAAU,CAAC;IACvB,MAAM,EAAE,GAAG,CAAC,UAAU,CAAC;IACvB,yEAAyE;IACzE,QAAQ,EAAE,gBAAgB;IAC1B,KAAK,EAAE,GAAG,CAAC,SAAS,CAAC;CACtB,CAAC,CAAC"}

package/dist/manifest.d.ts

@@ -0,0 +1,191 @@
+import type { AgentOf, HookCell as HookCellOf, RequiredDimensionOf, SetDimensionOf, SkillExpression, Skill as SkillOf, Value as ValueOfDimension } from '@cratylus/schema';
+/**
+ * The one runtime home for this corpus's dimension metadata. Every derivation
+ * below reads it, so a dimension is added HERE and nowhere else.
+ *
+ * `as const satisfies Record<string, DimensionMeta>` is LOAD-BEARING and is not
+ * interchangeable with a `: Record<string, DimensionMeta>` annotation. The
+ * annotation widens the keys to `string`, which collapses `Dimension` to `string`
+ * and takes every alias, `Agent` field and arity check below down with it —
+ * silently, while everything still compiles.
+ */
+export declare const MANIFEST: {
+    readonly autonomy: {
+        readonly axis: "Persona";
+        readonly repertoire: "latent";
+        readonly arity: "set";
+    };
+    readonly role: {
+        readonly axis: "Persona";
+        readonly repertoire: "open";
+        readonly arity: "scalar";
+    };
+    readonly formality: {
+        readonly axis: "Persona";
+        readonly repertoire: "latent";
+        readonly arity: "scalar";
+    };
+    readonly 'audience-adaptation': {
+        readonly axis: "Persona";
+        readonly repertoire: "latent";
+        readonly arity: "scalar";
+    };
+    readonly transparency: {
+        readonly axis: "Persona";
+        readonly repertoire: "latent";
+        readonly arity: "scalar";
+    };
+    readonly objective: {
+        readonly axis: "Constitution";
+        readonly repertoire: "open";
+        readonly arity: "scalar";
+    };
+    readonly guardrails: {
+        readonly axis: "Constitution";
+        readonly repertoire: "curated";
+        readonly arity: "set";
+        readonly required: true;
+    };
+    readonly 'engineering-principles': {
+        readonly axis: "Constitution";
+        readonly repertoire: "curated";
+        readonly arity: "set";
+    };
+    readonly heuristics: {
+        readonly axis: "Constitution";
+        readonly repertoire: "curated";
+        readonly arity: "set";
+    };
+    readonly capabilities: {
+        readonly axis: "Constitution";
+        readonly repertoire: "open";
+        readonly arity: "set";
+    };
+    readonly learning: {
+        readonly axis: "Constitution";
+        readonly repertoire: "latent";
+        readonly arity: "scalar";
+    };
+    readonly 'situation-awareness': {
+        readonly axis: "Constitution";
+        readonly repertoire: "latent";
+        readonly arity: "scalar";
+    };
+    readonly actions: {
+        readonly axis: "Constitution";
+        readonly repertoire: "latent";
+        readonly arity: "set";
+    };
+    readonly modalities: {
+        readonly axis: "Constitution";
+        readonly repertoire: "latent";
+        readonly arity: "scalar";
+    };
+    readonly model: {
+        readonly axis: "Constitution";
+        readonly repertoire: "latent";
+        readonly arity: "scalar";
+    };
+    readonly memory: {
+        readonly axis: "Constitution";
+        readonly repertoire: "latent";
+        readonly arity: "scalar";
+    };
+    readonly trigger: {
+        readonly axis: "Constitution";
+        readonly repertoire: "latent";
+        readonly arity: "scalar";
+    };
+    readonly framing: {
+        readonly axis: "Constitution";
+        readonly repertoire: "open";
+        readonly arity: "scalar";
+    };
+    readonly 'reasoning-strategy': {
+        readonly axis: "Constitution";
+        readonly repertoire: "latent";
+        readonly arity: "scalar";
+    };
+    readonly satisficing: {
+        readonly axis: "Constitution";
+        readonly repertoire: "latent";
+        readonly arity: "scalar";
+    };
+    readonly 'output-format': {
+        readonly axis: "Constitution";
+        readonly repertoire: "latent";
+        readonly arity: "scalar";
+    };
+    readonly 'self-evaluation': {
+        readonly axis: "Constitution";
+        readonly repertoire: "latent";
+        readonly arity: "scalar";
+    };
+};
+/**
+ * Every fragment dimension of this corpus — DERIVED from `MANIFEST`, never listed
+ * twice. `archetype` and `provenance` are NOT here: archetype is a plain-string
+ * description on the agent and provenance the structured `{mark}`;
+ * both carry data, not a σ* residue, so neither is a value-fragment dimension.
+ */
+export type Dimension = keyof typeof MANIFEST;
+/** Every fragment-dimension name, in manifest (Persona-then-Constitution) declaration order. */
+export declare const DIMENSION_NAMES: readonly Dimension[];
+/**
+ * A dimension VALUE of THIS corpus: a bare branded declaration, or one that
+ * enforces itself.
+ *
+ * `D extends Dimension`, and that constraint is the whole reason this alias
+ * exists rather than forge's `Value` being imported directly: a misspelled
+ * dimension (`Value<'guardrials'>`) is a compile error here, and cannot be one
+ * inside a projector that does not know which dimensions exist.
+ */
+export type Value<D extends Dimension> = ValueOfDimension<D>;
+/** The dimensions holding MANY values — derived from `MANIFEST`'s `arity`. */
+export type SetDimension = SetDimensionOf<typeof MANIFEST>;
+/** The dimensions an agent may NOT omit — derived from `MANIFEST`'s `required`. */
+export type RequiredDimension = RequiredDimensionOf<typeof MANIFEST>;
+/**
+ * An agent of this corpus: a FLAT, explicit selection over `MANIFEST` (depth 1 —
+ * composition over inheritance), plus the identity fields forge reads.
+ *
+ * Every dimension key is REQUIRED (completeness law). A scalar dimension holds
+ * ONE branded value or `null` (explicit omit-to-inherit — do NOT project this
+ * dimension; inherit whatever the harness provides); a set dimension holds an
+ * array, or `null` to omit the whole section. `guardrails` has no `| null`: it is
+ * `required: true` in the catalog, so the unconfined agent cannot be written down.
+ */
+export type Agent = AgentOf<typeof MANIFEST>;
+export type Autonomy = Value<'autonomy'>;
+export type Role = Value<'role'>;
+export type Formality = Value<'formality'>;
+export type AudienceAdaptation = Value<'audience-adaptation'>;
+export type Transparency = Value<'transparency'>;
+export type Objective = Value<'objective'>;
+export type Guardrails = Value<'guardrails'>;
+export type EngineeringPrinciples = Value<'engineering-principles'>;
+export type Heuristics = Value<'heuristics'>;
+export type Capabilities = Value<'capabilities'>;
+export type Learning = Value<'learning'>;
+export type SituationAwareness = Value<'situation-awareness'>;
+export type Actions = Value<'actions'>;
+export type Modalities = Value<'modalities'>;
+export type Model = Value<'model'>;
+export type Memory = Value<'memory'>;
+export type Trigger = Value<'trigger'>;
+export type Framing = Value<'framing'>;
+export type ReasoningStrategy = Value<'reasoning-strategy'>;
+export type Satisficing = Value<'satisficing'>;
+export type OutputFormat = Value<'output-format'>;
+export type SelfEvaluation = Value<'self-evaluation'>;
+export declare const RUNTIME_CAPABILITIES: readonly ["memory", "eventTap", "carryOn", "heartbeat"];
+/** A runtime capability this corpus ships a face for. */
+export type RuntimeCapability = (typeof RUNTIME_CAPABILITIES)[number];
+/** This corpus's `Skill`: schema's shape, narrowed to the capabilities above. */
+export type Skill = SkillOf<RuntimeCapability>;
+export type { SkillExpression };
+export declare const CANONICAL_EVENTS: readonly ["session.start", "session.resume", "session.end", "prompt.submit", "turn.end", "turn.fail", "agent.idle", "model.request.pre", "model.response.post", "tool.use.pre", "tool.use.post", "tool.use.fail", "file.edit.post", "file.read.pre", "file.change.external", "shell.exec.pre", "shell.exec.post", "mcp.exec.pre", "mcp.exec.post", "subagent.dispatch.pre", "subagent.start", "subagent.end", "operator.consult.pre", "permission.request", "permission.deny", "notification", "context.compact.pre", "context.compact.post", "config.changed", "instructions.loaded", "vcs.commit.post"];
+/** One moment this corpus has a name for — the pivot every adapter maps FROM. */
+export type CanonicalEvent = (typeof CANONICAL_EVENTS)[number];
+/** This corpus's `HookCell`: schema's shape, narrowed to the events above. */
+export type HookCell = HookCellOf<CanonicalEvent>;

package/dist/manifest.js

@@ -0,0 +1,237 @@
+// ─────────────────────────────────────────────────────────────────────────────
+// THE DIMENSION MANIFEST — canon's own, and the one home for it.
+//
+// `@cratylus/schema` owns the META-MODEL: that a dimension HAS an `axis`, a
+// `repertoire`, an `arity`, a `required`, and all machinery that operates on any
+// manifest obeying that shape. THIS module owns the INSTANCE: WHICH dimensions
+// exist, and each one's metadata. The manifest rides the PLUGIN (`src/index.ts`
+// declares `manifest: MANIFEST`), exactly as `preamble` does — "the axiom rides
+// the PLUGIN, so it survives projection by any consumer."
+//
+// The manifest used to live in `forge`, which meant a corpus could not
+// discover a dimension without editing the projector — the thesis inverted at its
+// most load-bearing point. A projector that knows there are exactly 22 dimensions
+// named these 22 things is not projecting a design; it contains one.
+//
+// WHERE THE TYPO-CATCHING LIVES. The schema's `Fragment<O>` is constrained
+// `O extends string`, not `O extends Dimension`, and MUST NOT be re-tightened:
+// the brand discriminates by the type ARGUMENT, so every value-level guarantee
+// (the cross-dimension refusal, the `required` catch-all) holds without the
+// constraint. The one property the relaxation costs is catching a MISSPELLED
+// dimension name, and it is restored HERE, by `Value<D extends Dimension>` below
+// — the corpus that owns the manifest is the only place that can know a name is
+// not one of its own.
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * The one runtime home for this corpus's dimension metadata. Every derivation
+ * below reads it, so a dimension is added HERE and nowhere else.
+ *
+ * `as const satisfies Record<string, DimensionMeta>` is LOAD-BEARING and is not
+ * interchangeable with a `: Record<string, DimensionMeta>` annotation. The
+ * annotation widens the keys to `string`, which collapses `Dimension` to `string`
+ * and takes every alias, `Agent` field and arity check below down with it —
+ * silently, while everything still compiles.
+ */
+export const MANIFEST = {
+    // Persona
+    autonomy: { axis: 'Persona', repertoire: 'latent', arity: 'set' },
+    role: { axis: 'Persona', repertoire: 'open', arity: 'scalar' },
+    formality: { axis: 'Persona', repertoire: 'latent', arity: 'scalar' },
+    'audience-adaptation': {
+        axis: 'Persona',
+        repertoire: 'latent',
+        arity: 'scalar',
+    },
+    transparency: { axis: 'Persona', repertoire: 'latent', arity: 'scalar' },
+    // Constitution — standing drives
+    objective: { axis: 'Constitution', repertoire: 'open', arity: 'scalar' },
+    // `required` — this dimension may NOT be omitted. The catch-all against
+    // attachment failing open: an agent composed with no bound is not a lesser
+    // agent, it is an unconfined one. Stated HERE, as catalog data, because
+    // "may this be omitted?" is a fact about the dimension exactly as `arity` is —
+    // and because it is a CANON doctrine, which is why it could never be at home
+    // as a hand-written exception inside the projector's `Agent` interface.
+    guardrails: {
+        axis: 'Constitution',
+        repertoire: 'curated',
+        arity: 'set',
+        required: true,
+    },
+    'engineering-principles': {
+        axis: 'Constitution',
+        repertoire: 'curated',
+        arity: 'set',
+    },
+    heuristics: { axis: 'Constitution', repertoire: 'curated', arity: 'set' },
+    capabilities: { axis: 'Constitution', repertoire: 'open', arity: 'set' },
+    learning: { axis: 'Constitution', repertoire: 'latent', arity: 'scalar' },
+    'situation-awareness': {
+        axis: 'Constitution',
+        repertoire: 'latent',
+        arity: 'scalar',
+    },
+    // Constitution — apparatus
+    actions: { axis: 'Constitution', repertoire: 'latent', arity: 'set' },
+    modalities: { axis: 'Constitution', repertoire: 'latent', arity: 'scalar' },
+    model: { axis: 'Constitution', repertoire: 'latent', arity: 'scalar' },
+    memory: { axis: 'Constitution', repertoire: 'latent', arity: 'scalar' },
+    // Constitution — per-turn act
+    trigger: { axis: 'Constitution', repertoire: 'latent', arity: 'scalar' },
+    framing: { axis: 'Constitution', repertoire: 'open', arity: 'scalar' },
+    'reasoning-strategy': {
+        axis: 'Constitution',
+        repertoire: 'latent',
+        arity: 'scalar',
+    },
+    satisficing: {
+        axis: 'Constitution',
+        repertoire: 'latent',
+        arity: 'scalar',
+    },
+    'output-format': {
+        axis: 'Constitution',
+        repertoire: 'latent',
+        arity: 'scalar',
+    },
+    'self-evaluation': {
+        axis: 'Constitution',
+        repertoire: 'latent',
+        arity: 'scalar',
+    },
+};
+/** Every fragment-dimension name, in manifest (Persona-then-Constitution) declaration order. */
+export const DIMENSION_NAMES = Object.keys(MANIFEST);
+// ── The runtime-capability vocabulary ───────────────────────────────────────
+//
+// WHICH runtime capabilities exist is this corpus's to say, exactly as WHICH
+// dimensions exist is. `@cratylus/schema` states only that a capability HAS a
+// name (`CapabilityName`); the members live here, and `Skill` below is narrowed
+// against them so a cell naming a capability this corpus does not ship is a
+// COMPILE error rather than a shim that forwards to a bin verb nobody serves.
+//
+// This retires the `schema → runtime` edge. `CapabilityName` used to read
+// `keyof Omit<RuntimePlugin, 'name'>` — schema reaching into the runtime's
+// IMPLEMENTATION INTERFACE to borrow a set of NAMES. `shape ⊥ vocabulary`
+// (`MODEL.md:22`): the ports stay in the runtime where ARCHITECTURE puts them,
+// and the names come from the corpus. Nothing moved except where the members
+// are declared.
+//
+// THE SIGN IS `RuntimeCapability`, WHICH IS WHAT SCHEMA ALREADY CALLED IT — and
+// that is the finding. The name was never the defect; the derivation source was.
+// The qualifier is load-bearing HERE and not in schema: this package also
+// declares a DIMENSION named `capabilities` (`Capabilities` above), an
+// agent-design axis, which is a different concept. Bare `Capability` beside it
+// would be one root over two concepts.
+export const RUNTIME_CAPABILITIES = [
+    'memory',
+    'eventTap',
+    'carryOn',
+    'heartbeat',
+];
+// ── The lifecycle-event vocabulary ──────────────────────────────────────────
+//
+// `MODEL.md:22`, verbatim:
+//
+//   Event ≜ the harness-agnostic lifecycle vocabulary ⟨corpus-owned ⟨a name for a
+//   moment ∴ signification⟩ ; shape ⊥ vocabulary : shape @ schema · names @ corpus ;
+//   the PIVOT every adapter maps from⟩
+//
+// A NAME FOR A MOMENT IS A SIGNIFICATION, and signification is what this corpus is.
+// That single clause decides the home: not schema (which held 28 of these, emitted
+// from a JSON file by a generator), not runtime (which held the same 28,
+// hand-authored, identical as sets AND in order), but here — beside
+// `RUNTIME_CAPABILITIES`, which is the same ruling one axis over, already landed.
+// The two declarations agreed by coincidence for as long as they coexisted, and
+// nothing enforced it because their consumer sets were disjoint.
+//
+// EVERY OTHER SITE DERIVES OR RECEIVES:
+//   · schema  states only that an event HAS a name (`EventName`) and narrows
+//     `HookCell` from this tuple by type argument — an undeclared event is a
+//     compile error at the cell;
+//   · forge   receives it as DATA on the plugin (`AgentPlugin.events`, ARCHITECTURE
+//     property 3) and keys its own harness maps over it;
+//   · runtime receives it as CONFIGURATION THE PROJECTION EMITTED (property 4,
+//     verbatim) — `deploy` writes the host config, `dispatch` validates against it.
+// Only the first is a compiler-enforced derivation; the other two cross package
+// boundaries the type system cannot, which is what `test/event-vocabulary.test.ts`
+// is for.
+//
+// TWO MEMBERS NAME AN ACT RATHER THAN A HARNESS CALLBACK, and they are the reason
+// there is no tool vocabulary. `stance-guardrail-pre` bound `tool.use.pre` and then
+// narrowed it with `matcher: 'AskUserQuestion|Agent|SendMessage'` — three claude tool
+// names, on a cell whose whole claim is harness-neutrality, silently dropped by the
+// codex adapter (so the hook fired on every tool call there). The obvious repair — a
+// canonical TOOL vocabulary beside this one — is a category error: harnesses share a
+// LIFECYCLE, which is closed, but their TOOL SETS are open-world (MCP servers add
+// tools at run time, users add their own), so a closed enum over them is permanently
+// incomplete and every adapter map would be near-empty.
+//
+// The vocabulary was already written in the cell's own σ*: its residue reads
+// `permission-menu ⟨AskUserQuestion⟩ · dispatch-echo ⟨Agent · SendMessage⟩` — three
+// tool names already factored into TWO ACTS, four lines above the field that
+// flattened them back. The residue was the argmin and the matcher its lossy
+// projection, so the two acts are signified here and the projection is computed:
+//
+//   · `operator.consult.pre`   — about to put a question or a menu to the operator.
+//     `principal.consult.pre` was the runner-up; `user.ask.pre` is rejected (`user`
+//     collides with deploy's install-scope `user`, and it is the VENDOR word while
+//     this pivot is vendor-neutral); `elicit.pre` is rejected (occupied by the
+//     concept-recovery skill); `decision.request.pre` is rejected (collides with
+//     `permission.request` INSIDE this tuple).
+//   · `subagent.dispatch.pre`  — about to hand work to an agent. Covers spawn AND
+//     message, and pairs as the pre-phase of `subagent.start`/`subagent.end`.
+//
+// TWO, and no third: a third act has no site in this corpus. An adapter maps each to
+// its native ⟨event, selector⟩ pair (`NativeBinding`); a harness that can fire the
+// act but not narrow it DECLARES that loss and the projection warns, which is what
+// closed the codex divergence. `matcher` no longer exists on any cell or IR shape.
+//
+// `vcs.commit.post` IS AN ORDINARY MEMBER. It was `SubstrateEvent = CanonicalEvent |
+// 'vcs.commit.post'` — a union that existed only because the enum was closed and a
+// git-substrate moment had no literal to be. Nothing about it was ever exceptional:
+// it is a name for a moment, on the `git` substrate rather than the `harness` one,
+// and `substrate` is a declared axis (`Substrate = 'harness' | 'git'`) that already
+// routes it. With an open `EventName` the union has nothing to widen, so it
+// dissolved on its own.
+export const CANONICAL_EVENTS = [
+    // harness substrate — a session's shape
+    'session.start',
+    'session.resume',
+    'session.end',
+    'prompt.submit',
+    'turn.end',
+    'turn.fail',
+    'agent.idle',
+    // harness substrate — the model exchange
+    'model.request.pre',
+    'model.response.post',
+    // harness substrate — tool use
+    'tool.use.pre',
+    'tool.use.post',
+    'tool.use.fail',
+    // harness substrate — the file the agent works on
+    'file.edit.post',
+    'file.read.pre',
+    'file.change.external',
+    // harness substrate — execution the agent delegates
+    'shell.exec.pre',
+    'shell.exec.post',
+    'mcp.exec.pre',
+    'mcp.exec.post',
+    'subagent.dispatch.pre',
+    'subagent.start',
+    'subagent.end',
+    // harness substrate — what the operator is asked and told
+    'operator.consult.pre',
+    'permission.request',
+    'permission.deny',
+    'notification',
+    // harness substrate — the context itself
+    'context.compact.pre',
+    'context.compact.post',
+    'config.changed',
+    'instructions.loaded',
+    // git substrate
+    'vcs.commit.post',
+];
+//# sourceMappingURL=manifest.js.map

package/dist/manifest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.js","sourceRoot":"","sources":["../src/manifest.ts"],"names":[],"mappings":"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"}