@cratylus/canon 0.1.0

package/dist/operator-lexicon.d.ts

@@ -0,0 +1,302 @@
+export type Glyph = string;
+export interface OperatorEntry {
+    /** the dense sense-name an agent-reader dereferences from priors */
+    readonly sense: string;
+    /** the type signature (`name : Domain → Codomain`, or a usage schema) */
+    readonly signature: string;
+    /** a cold reader recovers the operation from the glyph alone */
+    readonly coldVerified: boolean;
+}
+export declare const OPERATORS: {
+    readonly '\u225C': {
+        readonly sense: "defines";
+        readonly signature: "name ≜ expr";
+        readonly coldVerified: true;
+    };
+    readonly '\u2260': {
+        readonly sense: "distinct";
+        readonly signature: "T × T → Prop";
+        readonly coldVerified: true;
+    };
+    readonly '\u227D': {
+        readonly sense: "dominates";
+        readonly signature: "T × T → Prop";
+        readonly coldVerified: true;
+    };
+    readonly '\u227B': {
+        readonly sense: "strictly-dominates";
+        readonly signature: "T × T → Prop";
+        readonly coldVerified: true;
+    };
+    readonly '\u2245': {
+        readonly sense: "reader-isomorphic";
+        readonly signature: "𝒞 × 𝒞 → Prop";
+        readonly coldVerified: true;
+    };
+    readonly '\u227A': {
+        readonly sense: "precedes";
+        readonly signature: "T × T → Prop";
+        readonly coldVerified: true;
+    };
+    readonly '\u2265': {
+        readonly sense: "at-least";
+        readonly signature: "T × T → Prop";
+        readonly coldVerified: true;
+    };
+    readonly '\u2264': {
+        readonly sense: "at-most";
+        readonly signature: "T × T → Prop";
+        readonly coldVerified: true;
+    };
+    readonly '\u2261': {
+        readonly sense: "identical";
+        readonly signature: "T × T → Prop";
+        readonly coldVerified: true;
+    };
+    readonly '\u2262': {
+        readonly sense: "not-identical";
+        readonly signature: "T × T → Prop";
+        readonly coldVerified: true;
+    };
+    readonly '\u27E8': {
+        readonly sense: "tuple-open / modifier-open";
+        readonly signature: "⟨a, b, …⟩ ordered record · X⟨m⟩ modifier (position-disambiguated)";
+        readonly coldVerified: true;
+    };
+    readonly '\u27E9': {
+        readonly sense: "tuple-close / modifier-close";
+        readonly signature: "⟨a, b, …⟩ ordered record · X⟨m⟩ modifier (position-disambiguated)";
+        readonly coldVerified: true;
+    };
+    readonly '\u22E1': {
+        readonly sense: "does-not-dominate";
+        readonly signature: "T × T → Prop";
+        readonly coldVerified: true;
+    };
+    readonly '\u27FC': {
+        readonly sense: "maps-to";
+        readonly signature: "x ⟼ f(x)";
+        readonly coldVerified: true;
+    };
+    readonly 𝔹: {
+        readonly sense: "Booleans";
+        readonly signature: "{⊤, ⊥}";
+        readonly coldVerified: true;
+    };
+    readonly '\u00AC': {
+        readonly sense: "not";
+        readonly signature: "Prop → Prop";
+        readonly coldVerified: true;
+    };
+    readonly '\u2227': {
+        readonly sense: "and";
+        readonly signature: "Prop × Prop → Prop";
+        readonly coldVerified: true;
+    };
+    readonly '\u2228': {
+        readonly sense: "or";
+        readonly signature: "Prop × Prop → Prop";
+        readonly coldVerified: true;
+    };
+    readonly '\u22BB': {
+        readonly sense: "exclusive-or";
+        readonly signature: "Prop × Prop → Prop";
+        readonly coldVerified: true;
+    };
+    readonly '\u21D2': {
+        readonly sense: "implies";
+        readonly signature: "Prop × Prop → Prop";
+        readonly coldVerified: true;
+    };
+    readonly '\u21CF': {
+        readonly sense: "not-implies";
+        readonly signature: "Prop × Prop → Prop";
+        readonly coldVerified: true;
+    };
+    readonly '\u21D4': {
+        readonly sense: "iff";
+        readonly signature: "Prop × Prop → Prop";
+        readonly coldVerified: true;
+    };
+    readonly '\u22A5': {
+        readonly sense: "contradiction";
+        readonly signature: "Prop";
+        readonly coldVerified: true;
+    };
+    readonly '\u2234': {
+        readonly sense: "therefore";
+        readonly signature: "Prop ∴ Prop";
+        readonly coldVerified: true;
+    };
+    readonly '\u2235': {
+        readonly sense: "because";
+        readonly signature: "Prop ∵ Prop";
+        readonly coldVerified: true;
+    };
+    readonly '\u2200': {
+        readonly sense: "for-all";
+        readonly signature: "∀ x : Prop";
+        readonly coldVerified: true;
+    };
+    readonly '\u2203': {
+        readonly sense: "exists";
+        readonly signature: "∃ x : Prop";
+        readonly coldVerified: true;
+    };
+    readonly '\u2204': {
+        readonly sense: "none-exist";
+        readonly signature: "∄ x : Prop";
+        readonly coldVerified: true;
+    };
+    readonly '\u2208': {
+        readonly sense: "member";
+        readonly signature: "El × Set → Prop";
+        readonly coldVerified: true;
+    };
+    readonly '\u2209': {
+        readonly sense: "non-member";
+        readonly signature: "El × Set → Prop";
+        readonly coldVerified: true;
+    };
+    readonly '=': {
+        readonly sense: "equality-binding";
+        readonly signature: "A × A → Prop";
+        readonly coldVerified: true;
+    };
+    readonly '|': {
+        readonly sense: "given ⟨such-that⟩";
+        readonly signature: "A × Cond → A";
+        readonly coldVerified: true;
+    };
+    readonly '+': {
+        readonly sense: "sum-conjunction";
+        readonly signature: "A × A → A";
+        readonly coldVerified: true;
+    };
+    readonly '\u2286': {
+        readonly sense: "subset";
+        readonly signature: "Set × Set → Prop";
+        readonly coldVerified: true;
+    };
+    readonly '\u2282': {
+        readonly sense: "proper-subset";
+        readonly signature: "Set × Set → Prop";
+        readonly coldVerified: true;
+    };
+    readonly '\u2287': {
+        readonly sense: "superset";
+        readonly signature: "Set × Set → Prop";
+        readonly coldVerified: true;
+    };
+    readonly '\u2295': {
+        readonly sense: "direct-sum ⟨composition of parts into a whole⟩";
+        readonly signature: "A × A → A";
+        readonly coldVerified: true;
+    };
+    readonly '\u222A': {
+        readonly sense: "union";
+        readonly signature: "Set × Set → Set";
+        readonly coldVerified: true;
+    };
+    readonly '\u2229': {
+        readonly sense: "intersection";
+        readonly signature: "Set × Set → Set";
+        readonly coldVerified: true;
+    };
+    readonly '\u22C3': {
+        readonly sense: "n-ary-union";
+        readonly signature: "Set[Set] → Set";
+        readonly coldVerified: true;
+    };
+    readonly '\u2205': {
+        readonly sense: "empty";
+        readonly signature: "Set";
+        readonly coldVerified: true;
+    };
+    readonly '\u00D7': {
+        readonly sense: "product";
+        readonly signature: "Set × Set → Set";
+        readonly coldVerified: true;
+    };
+    readonly ℘: {
+        readonly sense: "power-set";
+        readonly signature: "Set → Set[Set]";
+        readonly coldVerified: true;
+    };
+    readonly '\u228A': {
+        readonly sense: "proper-subset";
+        readonly signature: "Set × Set → Prop";
+        readonly coldVerified: true;
+    };
+    readonly '\u2294': {
+        readonly sense: "join";
+        readonly signature: "Set[El] → El";
+        readonly coldVerified: true;
+    };
+    readonly '\u2192': {
+        readonly sense: "maps";
+        readonly signature: "A → B";
+        readonly coldVerified: true;
+    };
+    readonly '\u21A6': {
+        readonly sense: "sends";
+        readonly signature: "x ↦ y";
+        readonly coldVerified: true;
+    };
+    readonly '\u21C0': {
+        readonly sense: "partial-map";
+        readonly signature: "A ⇀ B";
+        readonly coldVerified: true;
+    };
+    readonly '\u21A3': {
+        readonly sense: "injective-map";
+        readonly signature: "A ↣ B";
+        readonly coldVerified: true;
+    };
+    readonly '\u22A8': {
+        readonly sense: "entails";
+        readonly signature: "X ⊨ Y";
+        readonly coldVerified: true;
+    };
+    readonly '\u21BE': {
+        readonly sense: "restriction";
+        readonly signature: "X ↾ Y — X narrowed to scope Y";
+        readonly coldVerified: true;
+    };
+    readonly '\u2218': {
+        readonly sense: "compose";
+        readonly signature: "(B → C) × (A → B) → (A → C)";
+        readonly coldVerified: true;
+    };
+    readonly '\u00B7': {
+        readonly sense: "and-list";
+        readonly signature: "a · b · c";
+        readonly coldVerified: true;
+    };
+    readonly '\u2026': {
+        readonly sense: "and-so-on";
+        readonly signature: "{ a, b, … }";
+        readonly coldVerified: true;
+    };
+    readonly '@': {
+        readonly sense: "resides-at / sourced-from — the authoritative on-disk or subsystem home of a fact";
+        readonly signature: "fact @ location";
+        readonly coldVerified: true;
+    };
+    readonly '${}': {
+        readonly sense: "esm-reference";
+        readonly signature: "${cell} — template-literal interpolation of another cell, resolved at eval";
+        readonly coldVerified: false;
+    };
+};
+/**
+ * The non-ASCII declared glyph set — the SYMBOLS-gate keyset (replaces the live markdown
+ * read). Each key contributes its non-ASCII code points; ASCII keys (`${}`) add nothing.
+ */
+export declare function declaredGlyphs(): Set<string>;
+/**
+ * The σ* value-algebra operators the RESIDUE gate admits inside a residue expression:
+ * restriction, the modifier bracket, and the ESM reference mechanism. Member-composition is
+ * the agent's set-arity vector, NOT a glyph — no compose operator without its own survey.
+ */
+export declare const RESIDUE_OPERATORS: readonly ["↾", "⟨", "⟩", "${}"];

package/dist/operator-lexicon.js

@@ -0,0 +1,198 @@
+// operator-lexicon — the corpus's shared operator vocabulary: the declared table `T`
+// of self-sufficient-formalism's `closed(B)`. One glyph ⇔ one sense (injective, like
+// signify on names): a glyph carries a single meaning across every fence, fixed by its
+// `sense` and pinned by its `signature`. `T` DECLARES rather than derives — the one table
+// exempt from "every symbol registered".
+//
+// DECLARE-NOT-DEGRADE (llm-native): `T` is a decodability REGISTRY, not an expression cap.
+// When the SYMBOLS gate rejects the FITTEST sign, EXTEND `T` with it (cold-verify its
+// decode) — never swap it for a weaker declared glyph to appease the gate.
+//
+// SINGLE HOME (DRY): the ONLY source for both gates —
+//   • the SYMBOLS gate (`test/symbols.test.ts`): every fence-interior glyph must be a
+//     non-ASCII key here (∪ the calibrated exempt classes).
+//   • the RESIDUE gate (`forge/src/validate/residue.ts`): its admissible σ* value-algebra
+//     operators = `↾ · ⟨⟩ · ${}`.
+// Agent-audience: dense `sense` + `signature` only — NO human-comprehension prose. A human
+// dereferences a glyph by asking an agent to explain the artifact (the on-demand channel),
+// never a maintained doc.
+//
+// `coldVerified`: a cold reader recovers the operation from the glyph ALONE
+// (SIGNIFIED/COLD-BLIND). Universal math/logic notation is cold by ubiquity; `↾`/`⟨⟩` were
+// cold-surveyed against reader priors and passed. `${}` is a CODE mechanism (resolved at
+// eval, not decoded) ⇒ false.
+export const OPERATORS = {
+    // ── Definition & comparison ──────────────────────────────────────────────
+    '≜': { sense: 'defines', signature: 'name ≜ expr', coldVerified: true },
+    '≠': { sense: 'distinct', signature: 'T × T → Prop', coldVerified: true },
+    '≽': { sense: 'dominates', signature: 'T × T → Prop', coldVerified: true },
+    '≻': {
+        sense: 'strictly-dominates',
+        signature: 'T × T → Prop',
+        coldVerified: true,
+    },
+    '≅': {
+        sense: 'reader-isomorphic',
+        signature: '𝒞 × 𝒞 → Prop',
+        coldVerified: true,
+    },
+    '≺': { sense: 'precedes', signature: 'T × T → Prop', coldVerified: true },
+    '≥': { sense: 'at-least', signature: 'T × T → Prop', coldVerified: true },
+    '≤': { sense: 'at-most', signature: 'T × T → Prop', coldVerified: true },
+    '≡': { sense: 'identical', signature: 'T × T → Prop', coldVerified: true },
+    '≢': {
+        sense: 'not-identical',
+        signature: 'T × T → Prop',
+        coldVerified: true,
+    },
+    '⟨': {
+        sense: 'tuple-open / modifier-open',
+        signature: '⟨a, b, …⟩ ordered record · X⟨m⟩ modifier (position-disambiguated)',
+        coldVerified: true,
+    },
+    '⟩': {
+        sense: 'tuple-close / modifier-close',
+        signature: '⟨a, b, …⟩ ordered record · X⟨m⟩ modifier (position-disambiguated)',
+        coldVerified: true,
+    },
+    '⋡': {
+        sense: 'does-not-dominate',
+        signature: 'T × T → Prop',
+        coldVerified: true,
+    },
+    '⟼': { sense: 'maps-to', signature: 'x ⟼ f(x)', coldVerified: true },
+    𝔹: { sense: 'Booleans', signature: '{⊤, ⊥}', coldVerified: true },
+    // ── Propositional logic ──────────────────────────────────────────────────
+    '¬': { sense: 'not', signature: 'Prop → Prop', coldVerified: true },
+    '∧': { sense: 'and', signature: 'Prop × Prop → Prop', coldVerified: true },
+    '∨': { sense: 'or', signature: 'Prop × Prop → Prop', coldVerified: true },
+    '⊻': {
+        sense: 'exclusive-or',
+        signature: 'Prop × Prop → Prop',
+        coldVerified: true,
+    },
+    '⇒': {
+        sense: 'implies',
+        signature: 'Prop × Prop → Prop',
+        coldVerified: true,
+    },
+    '⇏': {
+        sense: 'not-implies',
+        signature: 'Prop × Prop → Prop',
+        coldVerified: true,
+    },
+    '⇔': { sense: 'iff', signature: 'Prop × Prop → Prop', coldVerified: true },
+    '⊥': { sense: 'contradiction', signature: 'Prop', coldVerified: true },
+    '∴': { sense: 'therefore', signature: 'Prop ∴ Prop', coldVerified: true },
+    '∵': { sense: 'because', signature: 'Prop ∵ Prop', coldVerified: true },
+    // ── Quantifiers ──────────────────────────────────────────────────────────
+    '∀': { sense: 'for-all', signature: '∀ x : Prop', coldVerified: true },
+    '∃': { sense: 'exists', signature: '∃ x : Prop', coldVerified: true },
+    '∄': { sense: 'none-exist', signature: '∄ x : Prop', coldVerified: true },
+    // ── Sets ─────────────────────────────────────────────────────────────────
+    '∈': { sense: 'member', signature: 'El × Set → Prop', coldVerified: true },
+    '∉': {
+        sense: 'non-member',
+        signature: 'El × Set → Prop',
+        coldVerified: true,
+    },
+    // ASCII operators. Barred for years not by cold-verification but by an encoding
+    // filter in the residue grammar (`codePointAt > 0x7f`); `=` and `|` were in live
+    // use the whole time, hand-split in code. Cold-verifiability is the only bar.
+    '=': {
+        sense: 'equality-binding',
+        signature: 'A × A → Prop',
+        coldVerified: true,
+    },
+    '|': {
+        sense: 'given ⟨such-that⟩',
+        signature: 'A × Cond → A',
+        coldVerified: true,
+    },
+    '+': { sense: 'sum-conjunction', signature: 'A × A → A', coldVerified: true },
+    '⊆': { sense: 'subset', signature: 'Set × Set → Prop', coldVerified: true },
+    '⊂': {
+        sense: 'proper-subset',
+        signature: 'Set × Set → Prop',
+        coldVerified: true,
+    },
+    '⊇': { sense: 'superset', signature: 'Set × Set → Prop', coldVerified: true },
+    '⊕': {
+        sense: 'direct-sum ⟨composition of parts into a whole⟩',
+        signature: 'A × A → A',
+        coldVerified: true,
+    },
+    '∪': { sense: 'union', signature: 'Set × Set → Set', coldVerified: true },
+    '∩': {
+        sense: 'intersection',
+        signature: 'Set × Set → Set',
+        coldVerified: true,
+    },
+    '⋃': {
+        sense: 'n-ary-union',
+        signature: 'Set[Set] → Set',
+        coldVerified: true,
+    },
+    '∅': { sense: 'empty', signature: 'Set', coldVerified: true },
+    '×': { sense: 'product', signature: 'Set × Set → Set', coldVerified: true },
+    ℘: { sense: 'power-set', signature: 'Set → Set[Set]', coldVerified: true },
+    '⊊': {
+        sense: 'proper-subset',
+        signature: 'Set × Set → Prop',
+        coldVerified: true,
+    },
+    '⊔': { sense: 'join', signature: 'Set[El] → El', coldVerified: true },
+    // ── Maps ─────────────────────────────────────────────────────────────────
+    '→': { sense: 'maps', signature: 'A → B', coldVerified: true },
+    '↦': { sense: 'sends', signature: 'x ↦ y', coldVerified: true },
+    '⇀': { sense: 'partial-map', signature: 'A ⇀ B', coldVerified: true },
+    '↣': { sense: 'injective-map', signature: 'A ↣ B', coldVerified: true },
+    '⊨': { sense: 'entails', signature: 'X ⊨ Y', coldVerified: true },
+    '↾': {
+        sense: 'restriction',
+        signature: 'X ↾ Y — X narrowed to scope Y',
+        coldVerified: true,
+    },
+    '∘': {
+        sense: 'compose',
+        signature: '(B → C) × (A → B) → (A → C)',
+        coldVerified: true,
+    },
+    // ── Enumeration ──────────────────────────────────────────────────────────
+    '·': { sense: 'and-list', signature: 'a · b · c', coldVerified: true },
+    '…': { sense: 'and-so-on', signature: '{ a, b, … }', coldVerified: true },
+    // ── Provenance / representation (ASCII — contributes no gate glyph) ────────
+    '@': {
+        sense: 'resides-at / sourced-from — the authoritative on-disk or subsystem home of a fact',
+        signature: 'fact @ location',
+        coldVerified: true,
+    },
+    // ── Reference mechanism (value algebra; ASCII — contributes no gate glyph) ─
+    '${}': {
+        sense: 'esm-reference',
+        signature: '${cell} — template-literal interpolation of another cell, resolved at eval',
+        coldVerified: false,
+    },
+};
+/**
+ * The non-ASCII declared glyph set — the SYMBOLS-gate keyset (replaces the live markdown
+ * read). Each key contributes its non-ASCII code points; ASCII keys (`${}`) add nothing.
+ */
+export function declaredGlyphs() {
+    const out = new Set();
+    for (const glyph of Object.keys(OPERATORS)) {
+        for (const ch of glyph) {
+            if ((ch.codePointAt(0) ?? 0) > 127) {
+                out.add(ch);
+            }
+        }
+    }
+    return out;
+}
+/**
+ * The σ* value-algebra operators the RESIDUE gate admits inside a residue expression:
+ * restriction, the modifier bracket, and the ESM reference mechanism. Member-composition is
+ * the agent's set-arity vector, NOT a glyph — no compose operator without its own survey.
+ */
+export const RESIDUE_OPERATORS = ['↾', '⟨', '⟩', '${}'];
+//# sourceMappingURL=operator-lexicon.js.map

package/dist/operator-lexicon.js.map

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

package/dist/plan-states.d.ts

@@ -0,0 +1,31 @@
+/** The plan-layout state folders, in task-file lifecycle order. */
+export declare const PLAN_STATES: readonly ["pending", "ready", "active", "completed"];
+/** `frontier(P)` — the states a shard sits in when the plan is workable AT it
+ *  (praxis: `{ t | state(t) ∈ { ready, active } }`, where the plan IS, not merely
+ *  what is dispatchable). A subset of {@link PLAN_STATES} and not derivable from
+ *  their ORDER: `pending` is open too, and is not frontier. */
+export declare const PLAN_FRONTIER: readonly ["ready", "active"];
+/**
+ * The plan-tier dotfile MARKERS whose only home is here.
+ *
+ * A relation with no on-disk carrier is not readable — the reading `praxis.sh`
+ * states in its own words when it explains why `.landed` exists ("exactly parallel
+ * to `.superseded-by`"). These are the two markers a reader of the plan set needs
+ * that have no other TypeScript home: `.superseded-by` already has one
+ * (`plan-set.ts`'s `SUPERSEDED_MARKER`) and is deliberately not restated.
+ *
+ * `.ruling-owed` is the third carrier this corpus has minted on that reading, and
+ * it carries the concept the corpus ALREADY signifies as a ruling owed — "a
+ * decision nobody has taken", which the `praxis` cell distinguishes from a
+ * dependency ("a dep waits itself out, a ruling needs a human"). At the SHARD tier
+ * that concept is `ruling-owed(t)`, and it gates `ready`; at the
+ * PLAN tier it had no carrier at all, so a fork the principal cannot resolve —
+ * irreversible, or above its competence — was unreadable from disk however loudly
+ * it had been surfaced. Its content is the fork as it was put to the operator.
+ */
+export declare const PLAN_MARKERS: {
+    /** `bound(P)` — the plan-level commitment; exactly one plan carries it (WIP=1). */
+    readonly bound: ".bound";
+    /** `fork⊥(P)` — a fork surfaced to the operator, whose ruling nobody has taken. */
+    readonly rulingOwed: ".ruling-owed";
+};

package/dist/plan-states.js

@@ -0,0 +1,42 @@
+// plan-states.ts — the CANON home of the sharded-plan-layout state folders, in
+// lifecycle order. ONE home, two consumers (DRY): the `praxis` skill's formal
+// block (`../skills/praxis.ts`, whose `States ≜ {…}` set derives from here) and
+// the canon project template (`./project-template.ts`, whose `planStates` is
+// this). It lives here — not as a second export on the praxis skill module — because
+// a skill module carries exactly one export (its `Skill`); this is praxis's canon,
+// factored out to a sibling both can source.
+/** The plan-layout state folders, in task-file lifecycle order. */
+export const PLAN_STATES = ['pending', 'ready', 'active', 'completed'];
+/** `frontier(P)` — the states a shard sits in when the plan is workable AT it
+ *  (praxis: `{ t | state(t) ∈ { ready, active } }`, where the plan IS, not merely
+ *  what is dispatchable). A subset of {@link PLAN_STATES} and not derivable from
+ *  their ORDER: `pending` is open too, and is not frontier. */
+export const PLAN_FRONTIER = [
+    'ready',
+    'active',
+];
+/**
+ * The plan-tier dotfile MARKERS whose only home is here.
+ *
+ * A relation with no on-disk carrier is not readable — the reading `praxis.sh`
+ * states in its own words when it explains why `.landed` exists ("exactly parallel
+ * to `.superseded-by`"). These are the two markers a reader of the plan set needs
+ * that have no other TypeScript home: `.superseded-by` already has one
+ * (`plan-set.ts`'s `SUPERSEDED_MARKER`) and is deliberately not restated.
+ *
+ * `.ruling-owed` is the third carrier this corpus has minted on that reading, and
+ * it carries the concept the corpus ALREADY signifies as a ruling owed — "a
+ * decision nobody has taken", which the `praxis` cell distinguishes from a
+ * dependency ("a dep waits itself out, a ruling needs a human"). At the SHARD tier
+ * that concept is `ruling-owed(t)`, and it gates `ready`; at the
+ * PLAN tier it had no carrier at all, so a fork the principal cannot resolve —
+ * irreversible, or above its competence — was unreadable from disk however loudly
+ * it had been surfaced. Its content is the fork as it was put to the operator.
+ */
+export const PLAN_MARKERS = {
+    /** `bound(P)` — the plan-level commitment; exactly one plan carries it (WIP=1). */
+    bound: '.bound',
+    /** `fork⊥(P)` — a fork surfaced to the operator, whose ruling nobody has taken. */
+    rulingOwed: '.ruling-owed',
+};
+//# sourceMappingURL=plan-states.js.map

package/dist/plan-states.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-states.js","sourceRoot":"","sources":["../src/plan-states.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,8EAA8E;AAC9E,gFAAgF;AAChF,6EAA6E;AAC7E,qFAAqF;AACrF,mFAAmF;AACnF,6CAA6C;AAE7C,mEAAmE;AACnE,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,WAAW,CAAU,CAAC;AAEhF;;;+DAG+D;AAC/D,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,OAAO;IACP,QAAQ;CACkD,CAAC;AAE7D;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,mFAAmF;IACnF,KAAK,EAAE,QAAQ;IACf,mFAAmF;IACnF,UAAU,EAAE,cAAc;CAClB,CAAC"}

package/dist/rules/repo-preamble.d.ts

@@ -0,0 +1,2 @@
+import type { RuleCell } from '@cratylus/schema';
+export declare const repoPreamble: RuleCell;

package/dist/rules/repo-preamble.js

@@ -0,0 +1,56 @@
+// repo-preamble — the FIRST `rule` corpus instance (MODEL `Kind ∋ rule`,
+// `activation: rule↦scope`). The workspace-root standing instruction (`AGENTS.md`):
+// the always-loaded orientation every session binds on entry. Retiring the
+// `AGENTS.md@node` dream memory-sink (see `src/skills/dream.ts`) removed the sole
+// blocker to treating the repo-root `AGENTS.md` as a byte-locked rule TARGET — it is
+// no longer SelfAuthored memory (`SelfAuthored ∉ Target` no longer applies), so it is
+// a curated source-of-truth cell whose `content` projects + byte-locks to `/AGENTS.md`.
+//
+//   residue — the σ*-signified canonical identity (`body = ⟨α, residue⟩`), the
+//             `accept()`/REFLEXIVE target. It is `residue`, NOT `definiens`: it has
+//             already paid the `∖ fired(α)` subtraction (`schema/src/rule-cell.ts`).
+//   content — the VERBATIM directive payload, regenerated to `targetPath` by
+//             `project-targets` and byte-locked by `test/hook-rule-boundary.test.ts`.
+//             `content`, NOT `body`: `body(c) = ⟨α, residue⟩` is the whole cell, and
+//             this is the sibling of `HookWorker.content` (`schema/src/rule-cell.ts`).
+export const repoPreamble = {
+    kind: 'rule',
+    id: 'repo-preamble',
+    slug: 'repo-preamble',
+    residue: 'scope-rule ↾ workspace-root · loaded ∀ session on entry — the standing orientation: doctrine-pointers ⟨why · what · how · corpus-index ; LOCKED-immutable-grounding : source-aligns-up · ¬regenerated-from-source⟩ · working-convention ⟨conventional-commits ; header ≤100 ; commit-autonomous@natural-boundaries ; push-gated⟩ · tooling-prerequisite ⟨graph-indexer⟩ ; activation=scope ⟨¬dream-sink : curated source, projected + byte-locked⟩',
+    scope: '',
+    targetPath: 'AGENTS.md',
+    refs: [],
+    content: `# AGENTS
+
+**CRITICAL INVARIENT:** You **MUST Read** these documents upon session-start:\\*\\*
+
+- [\`CANON.md\`](./CANON.md) — **overview and primer**
+- [\`CRATYLISM\`](./packages/canon/src/dimensions/engineering-principles/cratylism.ts) — The First Principle (**LOCKED**)
+- [\`VISION.md\`](./VISION.md) — **why** the canon exists
+- [\`MODEL.md\`](./MODEL.md) — **what** exists: conceptual objectives and acceptance criteria
+- [\`ENGINE.md\`](./ENGINE.md) — **how** primitives are discovered, validated, and projected
+- [\`ARCHITECTURE\`](./ARCHITECTURE.md) — purpose and relationship of the packages, and the seams that separate their concerns.
+
+## Working conventions
+
+- Conventional Commits, header ≤100 chars (commitlint, \`commit-msg\` hook).
+- **Commit autonomously at natural boundaries — no operator approval needed.** This overrides the generic harness default ("commit only when the user asks"); do not gate commits on approval. Only \`git push\` is gated: push only when the operator asks.
+
+# Prerequisite
+
+[Graphify](https://github.com/safishamsi/graphify)
+
+confirm installed dependencies - mise => python3 => uv => graphifyy
+
+\`\`\`zsh
+mise install python uv
+uv --system-certs tool install graphifyy   # PyPI package is graphifyy; the CLI it installs is \`graphify\`
+# user scope, claude code  (see --help for more options)
+graphify install
+cd {repo}
+graphify hook install
+\`\`\`
+`,
+};
+//# sourceMappingURL=repo-preamble.js.map

package/dist/rules/repo-preamble.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"repo-preamble.js","sourceRoot":"","sources":["../../src/rules/repo-preamble.ts"],"names":[],"mappings":"AAEA,yEAAyE;AACzE,oFAAoF;AACpF,2EAA2E;AAC3E,kFAAkF;AAClF,qFAAqF;AACrF,sFAAsF;AACtF,wFAAwF;AACxF,EAAE;AACF,+EAA+E;AAC/E,oFAAoF;AACpF,qFAAqF;AACrF,6EAA6E;AAC7E,sFAAsF;AACtF,qFAAqF;AACrF,uFAAuF;AAEvF,MAAM,CAAC,MAAM,YAAY,GAAa;IACpC,IAAI,EAAE,MAAM;IACZ,EAAE,EAAE,eAAe;IACnB,IAAI,EAAE,eAAe;IACrB,OAAO,EACL,obAAob;IACtb,KAAK,EAAE,EAAE;IACT,UAAU,EAAE,WAAW;IACvB,IAAI,EAAE,EAAE;IACR,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BV;CACA,CAAC"}

package/dist/skills/carry-on/skill.d.ts

@@ -0,0 +1,2 @@
+import type { Skill } from '../../manifest.js';
+export declare const carryOn: Skill;