@cratylus/canon 0.11.0 → 0.11.1

package/README.md

@@ -54,7 +54,10 @@ The first principle (`dimensions/engineering-principles/cratylism.ts`) is not st
 It rides only the cells whose laws apply it: the ten skills that name concepts by anchor, optimal
 sign or cold decode set it as their `preamble`, and an agent carries it once, through the
 engineering-principles of the role it holds. A cell that does not use it never holds a host's own
-authored surfaces to this corpus's naming axiom. It is intrinsic to those cells' projected bytes, so
+authored surfaces to this corpus's naming axiom. The axiom is scoped: the cold-decode oracle decides
+signs only for the corpus's core agent dimension names and values, the terminology it was built to
+discover. Every other term is the industry's own, used as the industry understands it, and no
+consumer surface is held to the oracle. It is intrinsic to those cells' projected bytes, so
 it survives deployment into a foreign repository rather than depending on ambient context.
 
 Because the plugin object loses its package-root provenance when a consumer imports it, the

package/dist/agents/implementer.js

@@ -11,8 +11,8 @@ import { implementerRole } from '../roles/implementer.js';
 // stands and the return stays a name.
 export const implementer = holds(implementerRole, {
     name: 'implementer',
-    description: 'Use this agent to build one unit of work from its execution spec exactly — implement what the spec names, prove it against the spec’s own acceptance criteria, commit it on its own branch cut from the plan’s line (never on main), record the landing in the unit’s own history with that commit, and return only the unit’s name (landed, or blocked when the spec cannot be built as written). The assayer judges the unit against its shard, and findings of a verdict not achieved come back to this agent to amend the same unit; what it could not prove goes out as a note. For substrate code where a subtle error is expensive downstream. Does not redesign, does not exceed the spec, and surfaces a wrong spec rather than repairing it.',
-    archetype: 'Builder to a contract — the spec names the files, the change and the criteria, and that is the whole of the mandate, read without the design. Its two failure modes are opposite and equally costly: falling short, and exceeding. Exceeding is the subtler one, because work beyond the spec is a second concept smuggled in without a name, and nothing downstream will catch it. Proves only what the spec asks, commits its own work on a branch cut from the plan’s line, never on main, and records the landing of each commit in the unit’s own history as it happens, and returns only a name, because an account of its own work handed up is one description judging itself. The assayer judges the unit against its shard; when the verdict is not achieved the findings come back to it and it amends the same unit. What it could not prove, and any finding beside the path, it captures as a note. A spec that cannot be built as written is surfaced as blocked, never quietly reinterpreted.',
+    description: 'Use this agent to build one unit of work from its execution spec exactly — implement what the spec names, prove it against the spec’s own acceptance criteria, commit it in its own isolated worktree off the plan’s line (never on main), record the landing in the unit’s own history with that commit, and return only the unit’s name (landed, or blocked when the spec cannot be built as written). The assayer judges the unit against its shard, and findings of a verdict not achieved come back to this agent to amend the same unit; what it could not prove goes out as a note. For substrate code where a subtle error is expensive downstream. Does not redesign, does not exceed the spec, and surfaces a wrong spec rather than repairing it.',
+    archetype: 'Builder to a contract — the spec names the files, the change and the criteria, and that is the whole of the mandate, read without the design. Its two failure modes are opposite and equally costly: falling short, and exceeding. Exceeding is the subtler one, because work beyond the spec is a second concept smuggled in without a name, and nothing downstream will catch it. Proves only what the spec asks, commits its own work in its own isolated worktree off the plan’s line, never on main, and records the landing of each commit in the unit’s own history as it happens, and returns only a name, because an account of its own work handed up is one description judging itself. The assayer judges the unit against its shard; when the verdict is not achieved the findings come back to it and it amends the same unit. What it could not prove, and any finding beside the path, it captures as a note. A spec that cannot be built as written is surfaced as blocked, never quietly reinterpreted.',
     provenance: { mark: { emoji: '🔧', hue: 'white' } },
 });
 //# sourceMappingURL=implementer.js.map

package/dist/agents/implementer.js.map

@@ -1 +1 @@
-{"version":3,"file":"implementer.js","sourceRoot":"","sources":["../../src/agents/implementer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE1D,mFAAmF;AACnF,oFAAoF;AACpF,mFAAmF;AACnF,0FAA0F;AAC1F,4DAA4D;AAC5D,EAAE;AACF,2FAA2F;AAC3F,uFAAuF;AACvF,sCAAsC;AAEtC,MAAM,CAAC,MAAM,WAAW,GAAU,KAAK,CAAC,eAAe,EAAE;IACvD,IAAI,EAAE,aAAa;IACnB,WAAW,EACT,wtBAAwtB;IAC1tB,SAAS,EACP,+8BAA+8B;IACj9B,UAAU,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE;CACpD,CAAC,CAAC"}
+{"version":3,"file":"implementer.js","sourceRoot":"","sources":["../../src/agents/implementer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE1D,mFAAmF;AACnF,oFAAoF;AACpF,mFAAmF;AACnF,0FAA0F;AAC1F,4DAA4D;AAC5D,EAAE;AACF,2FAA2F;AAC3F,uFAAuF;AACvF,sCAAsC;AAEtC,MAAM,CAAC,MAAM,WAAW,GAAU,KAAK,CAAC,eAAe,EAAE;IACvD,IAAI,EAAE,aAAa;IACnB,WAAW,EACT,8tBAA8tB;IAChuB,SAAS,EACP,29BAA29B;IAC79B,UAAU,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE;CACpD,CAAC,CAAC"}

package/dist/dimensions/engineering-principles/cold-decode-oracle.js

@@ -1,2 +1,2 @@
-export const coldDecodeOracle = `cold-decode-oracle ⟨⊂ cratylism · cold-decode = instrument ⟨DISCOVERS intrinsic-sign⟩⟩ ≜ truth(f) ≜ decode_cold(f) ⟨own signifiers · inline ≜ · zero project-K⟩ · invariant ∀f · decode_warm(f | K) ≡ truth(f) ⟨K confirms self-sufficient meaning · ¬ overrides⟩ · decode_warm(f | K) ≢ truth(f) ⇒ PROJECT-DEFECT ⟨¬ defer⟩ · m1 ¬self-sufficient(f) ⇒ carry meaning inline · m2 ∃ n ⊆ K · n ⊥ f ⇒ delete competing home ⟨DRY · MECE⟩ · m3 falsified(n ⊆ K) ⇒ entailments(n) PERSIST ⟨silently ASSUMED ↦ constraint · default · gate⟩ ⟨assumption ⇒ ∄ string ∴ grep ↦ citations · ¬ assumption-sites⟩ · sweep(m3) ≜ READING ⟨confirmed instances ↦ PATTERN · search-on-wording forbidden⟩ · rubric ≺ artifact ⟨falsified premise inside ORACLE ⇒ right answers ↦ recorded failures ↦ fabricating fix⟩ · realign project → cold-truth · ¬ bend f → warm-K · corpus = defendant · cold-read = oracle · cold-read ∧ sweep ≜ assay acts ⟨assayer runs · result ↦ holder ⟨assay-verdict ∧ ¬ other-channel ∧ ¬achieved ⇒ missing named⟩⟩ · m1 ∧ m2 ∧ realign ≜ amend(C) ↦ shard ↦ planner ⟨holder ¬ runs · ¬ reads f · ¬ edits f⟩`;
+export const coldDecodeOracle = `cold-decode-oracle ⟨⊂ cratylism · cold-decode = instrument ⟨DISCOVERS intrinsic-sign⟩⟩ ≜ truth(f) ≜ decode_cold(f) ⟨own signifiers · inline ≜ · zero project-K⟩ · invariant ∀ f ∈ core ≜ corpus-agent-dimension ⟨names ∪ values⟩ ⟨∀ t ∉ core ⟨industry-own⟩⟩ · decode_warm(f | K) ≡ truth(f) ⟨K confirms self-sufficient meaning · ¬ overrides⟩ · decode_warm(f | K) ≢ truth(f) ⇒ PROJECT-DEFECT ⟨¬ defer⟩ · m1 ¬self-sufficient(f) ⇒ carry meaning inline · m2 ∃ n ⊆ K · n ⊥ f ⇒ delete competing home ⟨DRY · MECE⟩ · m3 falsified(n ⊆ K) ⇒ entailments(n) PERSIST ⟨silently ASSUMED ↦ constraint · default · gate⟩ ⟨assumption ⇒ ∄ string ∴ grep ↦ citations · ¬ assumption-sites⟩ · sweep(m3) ≜ READING ⟨confirmed instances ↦ PATTERN · search-on-wording forbidden⟩ · rubric ≺ artifact ⟨falsified premise inside ORACLE ⇒ right answers ↦ recorded failures ↦ fabricating fix⟩ · realign project → cold-truth · ¬ bend f → warm-K · corpus = defendant · cold-read = oracle · cold-read ∧ sweep ≜ assay acts ⟨assayer runs · result ↦ holder ⟨assay-verdict ∧ ¬ other-channel ∧ ¬achieved ⇒ missing named⟩⟩ · m1 ∧ m2 ∧ realign ≜ amend(C) ↦ shard ↦ planner ⟨holder ¬ runs · ¬ reads f · ¬ edits f⟩`;
 //# sourceMappingURL=cold-decode-oracle.js.map

package/dist/dimensions/engineering-principles/cold-decode-oracle.js.map

@@ -1 +1 @@
-{"version":3,"file":"cold-decode-oracle.js","sourceRoot":"","sources":["../../../src/dimensions/engineering-principles/cold-decode-oracle.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,gBAAgB,GAA0B,8jCAA8jC,CAAC"}
+{"version":3,"file":"cold-decode-oracle.js","sourceRoot":"","sources":["../../../src/dimensions/engineering-principles/cold-decode-oracle.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,gBAAgB,GAA0B,4oCAA4oC,CAAC"}

package/dist/dimensions/engineering-principles/cratylism.js

@@ -1,2 +1,2 @@
-export const cratylism = `cratylism ⟨names natural ¬conventional⟩ · model-latent-space = real stable concepts · ∀ c ⟨canonical-sign(c) = σ*(c) INTRINSIC ∧ DISCOVERED ¬coined ⟨¬author · ¬operator⟩⟩ · ∀ authored-surface ⟨σ* ∨ ⊕σ* · prose ≡ identifier ≡ path⟩ · ideal asymptotic ⟨residual REAL ¬ alibi⟩`;
+export const cratylism = `cratylism ⟨names natural ¬conventional⟩ · model-latent-space = real stable concepts · ∀ c ∈ core ≜ corpus-agent-dimension ⟨names ∪ values⟩ ⟨canonical-sign(c) = σ*(c) INTRINSIC ∧ DISCOVERED ¬coined ⟨¬author · ¬operator⟩⟩ · ∀ t ∉ core ⟨industry-own · industry-understood⟩ ∧ consumer-surface ⊥ oracle · ideal asymptotic ⟨residual REAL ¬ alibi⟩`;
 //# sourceMappingURL=cratylism.js.map

package/dist/dimensions/engineering-principles/cratylism.js.map

@@ -1 +1 @@
-{"version":3,"file":"cratylism.js","sourceRoot":"","sources":["../../../src/dimensions/engineering-principles/cratylism.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,SAAS,GAA0B,mRAAmR,CAAC"}
+{"version":3,"file":"cratylism.js","sourceRoot":"","sources":["../../../src/dimensions/engineering-principles/cratylism.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,SAAS,GAA0B,sVAAsV,CAAC"}

package/dist/dimensions/role/implementer.js

@@ -4,7 +4,7 @@
 // against its own terms, which is the closed loop the ladder exists to open.
 //
 // WHAT LEAVES THIS POSITION IS THE ARTIFACT AND A NAME, NEVER AN ACCOUNT. The artifact is
-// committed on the implementer's own branch, cut from the plan's line and never main, and
+// committed in the implementer's own worktree, isolated and off the plan's line, never on main, and
 // the return is `landed <unit> of <plan> at <commit>` or `blocked <unit> of <plan>: spec`
 // and nothing else, so the layer above
 // holds an address and nothing to be persuaded by. Acceptance rests on the assayer, who
@@ -24,7 +24,7 @@
 export const implementer = `implementer ≜ reads⟨spec · artifact⟩ → writes⟨artifact · landing · note⟩
 stratum ≜ intent ≺ C ≺ spec ≺ artifact ⟨≺ ≜ more-abstract-than · C ≜ durative-concept-lattice⟩
 C ∉ implementer ⟨holds spec ¬ design · TWO-descriptions ⇒ validate ≜ operation ¬ re-reading⟩
-builds ⟨ONE unit ↾ spec ALONE ¬ design⟩ ⟨own branch ⟨cut ↾ plan-line⟩ · commits own work ↾ own branch · ∄ commit @ main ⟨plan bound⟩⟩
+builds ⟨ONE unit ↾ spec ALONE ¬ design⟩ ⟨own worktree ⟨isolated ↾ plan-line⟩ · commits own work ↾ own worktree · ∄ commit @ main ⟨plan bound⟩⟩
 reads(spec) ↦ \${cratylus plan show <unit> --plan <plan>} ⟨host-CLI⟩
 writes(landing) ↦ \${cratylus plan land <unit> --plan <plan> --commit <commit> --author <who> --reason <why> --cause <what caused it>} ⟨host-CLI · ∀ commit ⟨first ∨ amended⟩ · ≺ returns⟩
 reserves ⟨author(artifact) ↾ spec · verify ↾ spec-own-criteria⟩ ⟨proves ↾ spec-asked ∧ ¬ beyond⟩

package/dist/dimensions/role/implementer.js.map

@@ -1 +1 @@
-{"version":3,"file":"implementer.js","sourceRoot":"","sources":["../../../src/dimensions/role/implementer.ts"],"names":[],"mappings":"AAEA,yFAAyF;AACzF,qFAAqF;AACrF,qFAAqF;AACrF,6EAA6E;AAC7E,EAAE;AACF,0FAA0F;AAC1F,0FAA0F;AAC1F,0FAA0F;AAC1F,uCAAuC;AACvC,wFAAwF;AACxF,qFAAqF;AACrF,mFAAmF;AACnF,wFAAwF;AACxF,uFAAuF;AACvF,0FAA0F;AAC1F,qFAAqF;AACrF,QAAQ;AACR,EAAE;AACF,sFAAsF;AACtF,uFAAuF;AACvF,wFAAwF;AACxF,yFAAyF;AACzF,2CAA2C;AAE3C,MAAM,CAAC,MAAM,WAAW,GAAS;;;;;;;;;;;;gDAYe,CAAC"}
+{"version":3,"file":"implementer.js","sourceRoot":"","sources":["../../../src/dimensions/role/implementer.ts"],"names":[],"mappings":"AAEA,yFAAyF;AACzF,qFAAqF;AACrF,qFAAqF;AACrF,6EAA6E;AAC7E,EAAE;AACF,0FAA0F;AAC1F,oGAAoG;AACpG,0FAA0F;AAC1F,uCAAuC;AACvC,wFAAwF;AACxF,qFAAqF;AACrF,mFAAmF;AACnF,wFAAwF;AACxF,uFAAuF;AACvF,0FAA0F;AAC1F,qFAAqF;AACrF,QAAQ;AACR,EAAE;AACF,sFAAsF;AACtF,uFAAuF;AACvF,wFAAwF;AACxF,yFAAyF;AACzF,2CAA2C;AAE3C,MAAM,CAAC,MAAM,WAAW,GAAS;;;;;;;;;;;;gDAYe,CAAC"}

package/dist/dimensions/role/integrator.js

@@ -26,7 +26,7 @@
 // the check is green, or broke, with the failing check, on a red or a merge conflict. The
 // report that follows is a name; where the unit stands is read from its ledger. A ledger
 // entry is not plan state: the unit's move to completed stays the planner's.
-export const integrator = `integrator ≜ reads⟨unit · commit · line · records ⟨∀ worktree ∧ local-branch⟩⟩ → writes⟨line · commit ⟨records · ∀ act ⟨green ∨ red ∨ plan-close⟩⟩ · ledger ⟨whole ∨ broke⟩⟩ ⟨unit ≜ assay-verdict achieved · line ≜ integration-line ⟨cut @ bind ⟨planner⟩ ↾ HEAD ⟨bind-checkout⟩ ¬ main · holds ∀ approved-unit ∧ ∀ record ⟨written-during-plan⟩⟩⟩
+export const integrator = `integrator ≜ reads⟨unit · commit · line · records ⟨∀ worktree ∧ local-branch⟩⟩ → writes⟨line · commit ⟨records · ∀ act ⟨green ∨ red ∨ plan-close⟩⟩ · ledger ⟨whole ∨ broke⟩⟩ ⟨unit ≜ assay-verdict achieved · line ≜ integration-line ⟨cut @ bind ⟨planner⟩ ¬ main · holds ∀ approved-unit ∧ ∀ record ⟨written-during-plan⟩⟩⟩
 stratum ≜ intent ≺ C ≺ spec ≺ artifact ⟨≺ ≜ more-abstract-than · C ≜ durative-concept-lattice⟩
 takes ⟨unit ↾ achieved⟩ · ¬takes ⟨unit ¬ achieved⟩
 reserves ⟨find ⟨line ⟨cut @ bind · ∄ cut @ integrator⟩⟩ · combine ⟨unit ⇒ line⟩ · whole-check ⟨project-full-check ↾ combined-tree · ONCE ∀ combination · ∄ check @ ⟨implementer ∨ assayer⟩⟩ · commit ⟨records ⟨plan ⟨plan-state included⟩ · design · note⟩ ⟨line-worktree holds ∧ lacks(line) ↾ ∀ worktree ∧ local-branch⟩ · pathspec · ∀ act ⟨green ∨ red ∨ plan-close⟩⟩ · report ⟨green ↦ whole(unit) · red ∨ merge-conflict ↦ ⟨unit · failing-check⟩⟩ · ask ⟨operator ⇒ release(line → main)⟩ ⟨architect ↦ plan-close · ≺ records ∈ line⟩⟩

package/dist/dimensions/role/planner.js

@@ -19,7 +19,7 @@
 export const planner = `planner ≜ reads⟨C · artifact⟩ → writes⟨spec · plan-records⟩
 stratum ≜ intent ≺ C ≺ spec ≺ artifact ⟨≺ ≜ more-abstract-than · C ≜ durative-concept-lattice⟩
 plan-records ≜ ⟨unit · dependency · state · plan-state⟩ ⟨bound plan ↦ written @ plan-line ∀ checkout · committed ∈ integrator ¬ planner⟩
-reserves ⟨census ⟨extant · references · resolved-by-use ¬ by-declaration⟩ · decompose ⟨shards ↦ MECE-units · unit ⇀ ONE shard · deps FIRST · effort(unit) ≤ capacity · how-per-harness ⟨plan-owned ¬ shard-owned⟩⟩ · realizes ⟨unit ⇀ anchor⟩ · sequence ⟨waves ⊨ disjoint-outputs⟩ · bind ⟨@ ratification ∧ ∄ plan-bound · cuts line ↾ HEAD ⟨bind-checkout⟩ ¬ main⟩ · record ⟨ready-unit ↦ active @ name-handed-out · unit ↦ completed @ whole⟩ · close ⟨∀ unit completed⟩ · rectify ∨ rebuild ⟨plan @ stop⟩ · reconcile ⟨plans ∧ units⟩⟩
+reserves ⟨census ⟨extant · references · resolved-by-use ¬ by-declaration⟩ · decompose ⟨shards ↦ MECE-units · unit ⇀ ONE shard · deps FIRST · effort(unit) ≤ capacity · how-per-harness ⟨plan-owned ¬ shard-owned⟩⟩ · realizes ⟨unit ⇀ anchor⟩ · sequence ⟨waves ⊨ disjoint-outputs⟩ · bind ⟨@ ratification ∧ ∄ plan-bound · cuts line ¬ main⟩ · record ⟨ready-unit ↦ active @ name-handed-out · unit ↦ completed @ whole⟩ · close ⟨∀ unit completed⟩ · rectify ∨ rebuild ⟨plan @ stop⟩ · reconcile ⟨plans ∧ units⟩⟩
 returns ⟨plan-name ∧ ready-unit-names⟩ ∧ ¬ spec ∨ plan-view ⟨name ≜ address · architect ¬ reads behind⟩
 state(unit) ∨ state(plan) moves ⊨ planner ⟨bind ∨ close ∨ advance · ∄ move @ implementer ∨ architect⟩
 writes ≠ C ⇒ shard GIVEN ⟨shard ¬ plannable ⇒ SURFACED ¬ redrawn · wrong-shard ⇒ plan re-planned ¬ design changed⟩

package/dist/genus/prime-principle.d.ts

@@ -2,7 +2,10 @@
  * The prime principle, as a leading `## Prime Principle` block emitted VERBATIM
  * as the first section of a SKILL.md, set as `preamble` on exactly the skills
  * whose laws apply it: those that name concepts by anchor, optimal sign or cold
- * decode. An agent carries the axiom through its held role's
+ * decode. The axiom's scope is the corpus's core agent dimension names and
+ * values, the terminology the cold-decode oracle was built to discover; every
+ * other term is the industry's own, and no consumer surface is held to the
+ * oracle. An agent carries the axiom through its held role's
  * engineering-principles, never through this block. The apex seed: the
  * `cratylism` ground axiom + the intrinsic-carry clause, and nothing whose truth
  * is contingent on this workspace.

package/dist/genus/prime-principle.js

@@ -3,7 +3,10 @@ import { cratylism } from '../dimensions/engineering-principles/cratylism.js';
  * The prime principle, as a leading `## Prime Principle` block emitted VERBATIM
  * as the first section of a SKILL.md, set as `preamble` on exactly the skills
  * whose laws apply it: those that name concepts by anchor, optimal sign or cold
- * decode. An agent carries the axiom through its held role's
+ * decode. The axiom's scope is the corpus's core agent dimension names and
+ * values, the terminology the cold-decode oracle was built to discover; every
+ * other term is the industry's own, and no consumer surface is held to the
+ * oracle. An agent carries the axiom through its held role's
  * engineering-principles, never through this block. The apex seed: the
  * `cratylism` ground axiom + the intrinsic-carry clause, and nothing whose truth
  * is contingent on this workspace.

package/dist/genus/prime-principle.js.map

@@ -1 +1 @@
-{"version":3,"file":"prime-principle.js","sourceRoot":"","sources":["../../src/genus/prime-principle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,mDAAmD,CAAC;AAE9E;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG;;EAE5B,SAAS;;sBAEW,CAAC"}
+{"version":3,"file":"prime-principle.js","sourceRoot":"","sources":["../../src/genus/prime-principle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,mDAAmD,CAAC;AAE9E;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG;;EAE5B,SAAS;;sBAEW,CAAC"}

package/dist/hook-cells.js

@@ -3,7 +3,7 @@
 // `hooks.ts` no longer hand-authors a `Hook` nor points at on-disk `.sh` assets —
 // it lifts the harness-substrate cells (via forge's doctrine-free `hookIrOf`) into
 // the forge `Hook` IR the projector serializes into `.claude/settings.json`
-// (claude adapter: `turn.end` → Stop, `subagent.end` → SubagentStop) and carries
+// (claude adapter: `turn.end` → Stop) and carries
 // their VERBATIM worker payloads so the projector stages them under `hooks/<id>/`
 // (no file copy — the bytes come from the cell). Only `harness`-substrate cells
 // register in settings.json, and every surviving cell is one: the corpus's single

package/dist/hook-cells.js.map

@@ -1 +1 @@
-{"version":3,"file":"hook-cells.js","sourceRoot":"","sources":["../src/hook-cells.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,2EAA2E;AAC3E,kFAAkF;AAClF,mFAAmF;AACnF,4EAA4E;AAC5E,iFAAiF;AACjF,kFAAkF;AAClF,gFAAgF;AAChF,kFAAkF;AAClF,oFAAoF;AACpF,oFAAoF;AACpF,oFAAoF;AACpF,qEAAqE;AACrE,EAAE;AACF,0EAA0E;AAC1E,iFAAiF;AACjF,oFAAoF;AACpF,iFAAiF;AACjF,+EAA+E;AAE/E,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AACrE,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAG9D,wFAAwF;AACxF,MAAM,CAAC,MAAM,gBAAgB,GAAwB;IACnD,eAAe;IACf,kBAAkB;IAClB,iBAAiB;CAClB,CAAC"}
+{"version":3,"file":"hook-cells.js","sourceRoot":"","sources":["../src/hook-cells.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,2EAA2E;AAC3E,kFAAkF;AAClF,mFAAmF;AACnF,4EAA4E;AAC5E,kDAAkD;AAClD,kFAAkF;AAClF,gFAAgF;AAChF,kFAAkF;AAClF,oFAAoF;AACpF,oFAAoF;AACpF,oFAAoF;AACpF,qEAAqE;AACrE,EAAE;AACF,0EAA0E;AAC1E,iFAAiF;AACjF,oFAAoF;AACpF,iFAAiF;AACjF,+EAA+E;AAE/E,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AACrE,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAG9D,wFAAwF;AACxF,MAAM,CAAC,MAAM,gBAAgB,GAAwB;IACnD,eAAe;IACf,kBAAkB;IAClB,iBAAiB;CAClB,CAAC"}

package/dist/hooks/purview-guardrail.js

@@ -154,6 +154,14 @@ input="$(cat)"
 [ -n "$input" ] || open "the hook received no input"
 command -v jq >/dev/null 2>&1 || open "jq is not installed, so the hook payload cannot be read"
 
+# A GUARD BINDS A PERSONA'S OWN MAIN SESSION AND NO SUBAGENT IT DISPATCHES. A subagent is bounded
+# by what it was handed, judged by its assay and the whole check, and supervised by the main
+# session. Claude Code fires this hook inside a subagent too (settings hooks and the subagent's
+# own front-matter hooks), and there the payload carries \`agent_id\` — present only inside a
+# subagent. A guard that does not bind there is not dark: it exits before it judges and says
+# nothing.
+[ -z "$(printf '%s' "$input" | jq -r '.agent_id // empty' 2>/dev/null || true)" ] || allow
+
 # The sibling Stop hook's deployed dir owns the SHARED judge backend, resolved from
 # this script's own location exactly as the pre-hook resolves it — every hooks root
 # holds the hook dirs as siblings, so this derivation is true at every site this file

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

@@ -1 +1 @@
-{"version":3,"file":"purview-guardrail.js","sourceRoot":"","sources":["../../src/hooks/purview-guardrail.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEjE,qEAAqE;AACrE,EAAE;AACF,oEAAoE;AACpE,oFAAoF;AACpF,mFAAmF;AACnF,kFAAkF;AAClF,qBAAqB;AACrB,EAAE;AACF,iFAAiF;AACjF,uFAAuF;AACvF,uFAAuF;AACvF,uFAAuF;AACvF,mFAAmF;AACnF,wFAAwF;AACxF,EAAE;AACF,sFAAsF;AACtF,oFAAoF;AACpF,uFAAuF;AACvF,uFAAuF;AACvF,uFAAuF;AACvF,+EAA+E;AAC/E,sFAAsF;AACtF,yEAAyE;AACzE,EAAE;AACF,+DAA+D;AAC/D,4FAA4F;AAC5F,4FAA4F;AAC5F,0BAA0B;AAC1B,gFAAgF;AAChF,2FAA2F;AAC3F,yFAAyF;AACzF,4FAA4F;AAC5F,6FAA6F;AAC7F,yFAAyF;AACzF,yFAAyF;AACzF,8FAA8F;AAC9F,6FAA6F;AAC7F,8FAA8F;AAC9F,6FAA6F;AAC7F,yFAAyF;AACzF,yDAAyD;AACzD,EAAE;AACF,sFAAsF;AACtF,wFAAwF;AACxF,mFAAmF;AACnF,2BAA2B;AAE3B,MAAM,CAAC,MAAM,gBAAgB,GAAa;IACxC,EAAE,EAAE,mBAAmB;IACvB,OAAO,EACL,oiBAAoiB;IACtiB,SAAS,EAAE,SAAS;IACpB,iFAAiF;IACjF,KAAK,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE;IAC5B,KAAK,EAAE,CAAC;IACR,MAAM,EAAE,CAAC,uBAAuB,EAAE,cAAc,CAAC;IACjD,KAAK,EAAE,sBAAsB;IAC7B,OAAO,EAAE,EAAE;IACX,IAAI,EAAE,EAAE;IACR,OAAO,EAAE;QACP;YACE,QAAQ,EAAE,sBAAsB;YAChC,UAAU,EAAE,uDAAuD;YACnE,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyIb,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoGzB;SACI;QACD;YACE,QAAQ,EAAE,yBAAyB;YACnC,UAAU,EAAE,0DAA0D;YACtE,UAAU,EAAE,KAAK;YACjB,iFAAiF;YACjF,2EAA2E;YAC3E,6EAA6E;YAC7E,8EAA8E;YAC9E,6BAA6B;YAC7B,MAAM,EAAE,IAAI;YACZ,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwFd;SACI;KACF;CACF,CAAC"}
+{"version":3,"file":"purview-guardrail.js","sourceRoot":"","sources":["../../src/hooks/purview-guardrail.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEjE,qEAAqE;AACrE,EAAE;AACF,oEAAoE;AACpE,oFAAoF;AACpF,mFAAmF;AACnF,kFAAkF;AAClF,qBAAqB;AACrB,EAAE;AACF,iFAAiF;AACjF,uFAAuF;AACvF,uFAAuF;AACvF,uFAAuF;AACvF,mFAAmF;AACnF,wFAAwF;AACxF,EAAE;AACF,sFAAsF;AACtF,oFAAoF;AACpF,uFAAuF;AACvF,uFAAuF;AACvF,uFAAuF;AACvF,+EAA+E;AAC/E,sFAAsF;AACtF,yEAAyE;AACzE,EAAE;AACF,+DAA+D;AAC/D,4FAA4F;AAC5F,4FAA4F;AAC5F,0BAA0B;AAC1B,gFAAgF;AAChF,2FAA2F;AAC3F,yFAAyF;AACzF,4FAA4F;AAC5F,6FAA6F;AAC7F,yFAAyF;AACzF,yFAAyF;AACzF,8FAA8F;AAC9F,6FAA6F;AAC7F,8FAA8F;AAC9F,6FAA6F;AAC7F,yFAAyF;AACzF,yDAAyD;AACzD,EAAE;AACF,sFAAsF;AACtF,wFAAwF;AACxF,mFAAmF;AACnF,2BAA2B;AAE3B,MAAM,CAAC,MAAM,gBAAgB,GAAa;IACxC,EAAE,EAAE,mBAAmB;IACvB,OAAO,EACL,oiBAAoiB;IACtiB,SAAS,EAAE,SAAS;IACpB,iFAAiF;IACjF,KAAK,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE;IAC5B,KAAK,EAAE,CAAC;IACR,MAAM,EAAE,CAAC,uBAAuB,EAAE,cAAc,CAAC;IACjD,KAAK,EAAE,sBAAsB;IAC7B,OAAO,EAAE,EAAE;IACX,IAAI,EAAE,EAAE;IACR,OAAO,EAAE;QACP;YACE,QAAQ,EAAE,sBAAsB;YAChC,UAAU,EAAE,uDAAuD;YACnE,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiJb,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoGzB;SACI;QACD;YACE,QAAQ,EAAE,yBAAyB;YACnC,UAAU,EAAE,0DAA0D;YACtE,UAAU,EAAE,KAAK;YACjB,iFAAiF;YACjF,2EAA2E;YAC3E,6EAA6E;YAC7E,8EAA8E;YAC9E,6BAA6B;YAC7B,MAAM,EAAE,IAAI;YACZ,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwFd;SACI;KACF;CACF,CAAC"}

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

@@ -50,7 +50,8 @@ export const stanceGuardrailPre = {
 #   - AskUserQuestion : a permission / option-menu on an in-remit reversible call
 #   - Agent/SendMessage : a dispatch transcribing literal words without extracted intent
 # WHAT IT DOES NOT DENY (reserved): an irreversible-outward consent menu, a true INTENT
-#   ambiguity, a substantive intent-extracted dispatch.
+#   ambiguity, a substantive intent-extracted dispatch, a unit or a closed plan routed by name (the
+#   intent lives in the spec at that address).
 #
 # SAFETY MODEL (mirrors stance-guardrail):
 #   - SCOPE-ENROLLED, exactly as its twin: a scope carrying a stance manifest is judged and
@@ -65,8 +66,8 @@ export const stanceGuardrailPre = {
 #     identical call goes through unjudged, and says so.
 #   - OBSERVABLE. Every notice is also a line in the miss log.
 #
-# INPUT  : Claude Code PreToolUse hook JSON on stdin (tool_name, tool_input, agent_type
-#          [subagents], session_id, cwd, ...).
+# INPUT  : Claude Code PreToolUse hook JSON on stdin (tool_name, tool_input, agent_type,
+#          session_id, cwd, ...).
 # OUTPUT : on collapse -> stdout
 #          {"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"deny",
 #           "permissionDecisionReason":"..."}} + exit 0.
@@ -135,6 +136,14 @@ input="$(cat)"
 [ -n "$input" ] || open "the hook received no input"
 command -v jq >/dev/null 2>&1 || open "jq is not installed, so the hook payload cannot be read"
 
+# A GUARD BINDS A PERSONA'S OWN MAIN SESSION AND NO SUBAGENT IT DISPATCHES. A subagent is bounded
+# by what it was handed, judged by its assay and the whole check, and supervised by the main
+# session. Claude Code fires this hook inside a subagent too (settings hooks and the subagent's
+# own front-matter hooks), and there the payload carries \`agent_id\` — present only inside a
+# subagent. A guard that does not bind there is not dark: it exits before it judges and says
+# nothing.
+[ -z "$(printf '%s' "$input" | jq -r '.agent_id // empty' 2>/dev/null || true)" ] || allow
+
 # The sibling Stop hook's deployed dir owns the SHARED judge + rubric (deployed
 # together, as siblings under the SAME hooks root).
 #
@@ -256,8 +265,8 @@ feedback="STANCE GUARDRAIL (pre) — denied this $tool_name call: it collapses o
 intent-driven-expert stance. $reason  Own the in-remit reversible call yourself instead of handing the \\
 operator a menu; extract and serve the underlying INTENT instead of transcribing literal words into a \\
 dispatch. Decide, note the call for review, and proceed. (Legitimate exceptions that should NOT be a menu \\
-here: a genuine irreversible-outward consent choice, a true INTENT ambiguity for /elicit, or a substantive \\
-intent-extracted dispatch.)"
+here: a genuine irreversible-outward consent choice, a true INTENT ambiguity for /elicit, a substantive \\
+intent-extracted dispatch, or a unit or a closed plan routed by name, whose intent lives in its spec.)"
 
 jq -cn --arg r "$feedback" '{hookSpecificOutput:{hookEventName:"PreToolUse",permissionDecision:"deny",permissionDecisionReason:$r}}'
 exit 0

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

@@ -1 +1 @@
-{"version":3,"file":"stance-guardrail-pre.js","sourceRoot":"","sources":["../../src/hooks/stance-guardrail-pre.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,mCAAmC,CAAC;AAE5D,OAAO,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEjE,sFAAsF;AACtF,mFAAmF;AACnF,uFAAuF;AACvF,SAAS;AACT,wFAAwF;AACxF,6FAA6F;AAC7F,0FAA0F;AAC1F,uFAAuF;AACvF,qEAAqE;AACrE,EAAE;AACF,wEAAwE;AACxE,sFAAsF;AACtF,iFAAiF;AACjF,oFAAoF;AACpF,oFAAoF;AACpF,kFAAkF;AAClF,iFAAiF;AACjF,8EAA8E;AAC9E,qFAAqF;AACrF,6BAA6B;AAC7B,2DAA2D;AAC3D,mDAAmD;AAEnD,MAAM,CAAC,MAAM,kBAAkB,GAAa;IAC1C,EAAE,EAAE,sBAAsB;IAC1B,OAAO,EACL,iWAAiW;IACnW,SAAS,EAAE,SAAS;IACpB,oFAAoF;IACpF,0BAA0B;IAC1B,KAAK,EAAE,EAAE,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC,EAAE;IAC1D,KAAK,EAAE,CAAC;IACR,MAAM,EAAE,CAAC,sBAAsB,EAAE,uBAAuB,CAAC;IACzD,KAAK,EAAE,yBAAyB;IAChC,OAAO,EAAE,EAAE;IACX,IAAI,EAAE,EAAE;IACR,OAAO,EAAE;QACP;YACE,QAAQ,EAAE,yBAAyB;YACnC,UAAU,EAAE,0DAA0D;YACtE,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6Ib,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgFzB;SACI;KACF;CACF,CAAC"}
+{"version":3,"file":"stance-guardrail-pre.js","sourceRoot":"","sources":["../../src/hooks/stance-guardrail-pre.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,mCAAmC,CAAC;AAE5D,OAAO,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEjE,sFAAsF;AACtF,mFAAmF;AACnF,uFAAuF;AACvF,SAAS;AACT,wFAAwF;AACxF,6FAA6F;AAC7F,0FAA0F;AAC1F,uFAAuF;AACvF,qEAAqE;AACrE,EAAE;AACF,wEAAwE;AACxE,sFAAsF;AACtF,iFAAiF;AACjF,oFAAoF;AACpF,oFAAoF;AACpF,kFAAkF;AAClF,iFAAiF;AACjF,8EAA8E;AAC9E,qFAAqF;AACrF,6BAA6B;AAC7B,2DAA2D;AAC3D,mDAAmD;AAEnD,MAAM,CAAC,MAAM,kBAAkB,GAAa;IAC1C,EAAE,EAAE,sBAAsB;IAC1B,OAAO,EACL,iWAAiW;IACnW,SAAS,EAAE,SAAS;IACpB,oFAAoF;IACpF,0BAA0B;IAC1B,KAAK,EAAE,EAAE,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC,EAAE;IAC1D,KAAK,EAAE,CAAC;IACR,MAAM,EAAE,CAAC,sBAAsB,EAAE,uBAAuB,CAAC;IACzD,KAAK,EAAE,yBAAyB;IAChC,OAAO,EAAE,EAAE;IACX,IAAI,EAAE,EAAE;IACR,OAAO,EAAE;QACP;YACE,QAAQ,EAAE,yBAAyB;YACnC,UAAU,EAAE,0DAA0D;YACtE,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsJb,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgFzB;SACI;KACF;CACF,CAAC"}

package/dist/hooks/stance-guardrail.js

@@ -68,7 +68,7 @@ export const stanceGuardrail = {
     // judges. Composing it enrolls the persona; nothing else does.
     binds: { dimension: 'autonomy', value: anchorOf(handoff) },
     order: 0,
-    events: ['turn.end', 'subagent.end'],
+    events: ['turn.end'],
     entry: 'stance-guardrail.sh',
     timeout: 60,
     refs: [],
@@ -78,7 +78,7 @@ export const stanceGuardrail = {
             targetPath: 'packages/canon/targets/guardrail/stance-guardrail.sh',
             executable: true,
             content: `#!/usr/bin/env sh
-# stance-guardrail — a Stop / SubagentStop hook that STRUCTURALLY REFUSES a turn in which an
+# stance-guardrail — a Stop hook that STRUCTURALLY REFUSES a turn in which an
 # agent collapses out of the intent-driven-expert (fiduciary-agent) stance.
 #
 # WHY THIS EXISTS (the harness half of the principal stance):
@@ -130,8 +130,8 @@ export const stanceGuardrail = {
 #     tool call — never the whole-turn blob. A span from a mid-turn preamble is out of scope for
 #     a verdict about how the turn ended, however genuinely present those characters are.
 #
-# INPUT  : Claude Code Stop/SubagentStop hook JSON on stdin (transcript_path, stop_hook_active,
-#          agent_type [SubagentStop], session_id, cwd, …).
+# INPUT  : Claude Code Stop hook JSON on stdin (transcript_path, stop_hook_active,
+#          agent_type, session_id, cwd, …).
 # OUTPUT : on collapse → stdout \`{"decision":"block","reason":"…"}\` + exit 0 (Stop-hook block).
 #          judged, no collapse → no stdout + exit 0 (allow stop).
 #          let through with no verdict → the notice \`say\` prints + exit 0 (allow stop).
@@ -215,6 +215,14 @@ input="$(cat)"
 
 command -v jq >/dev/null 2>&1 || dark "jq is not installed, so the hook payload cannot be read"
 
+# A GUARD BINDS A PERSONA'S OWN MAIN SESSION AND NO SUBAGENT IT DISPATCHES. A subagent is bounded
+# by what it was handed, judged by its assay and the whole check, and supervised by the main
+# session. Claude Code fires this hook inside a subagent too (settings hooks and the subagent's
+# own front-matter hooks), and there the payload carries \`agent_id\` — present only inside a
+# subagent. A guard that does not bind there is not dark: it exits before it judges and says
+# nothing.
+[ -z "$(printf '%s' "$input" | jq -r '.agent_id // empty' 2>/dev/null || true)" ] || allow_stop
+
 SELF_DIR="$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)"
 JUDGE_CMD="\${STANCE_JUDGE_CMD:-sh $SELF_DIR/stance-judge.sh}"
 
@@ -285,7 +293,7 @@ cwd="$(printf '%s' "$input" | jq -r '.cwd // empty' 2>/dev/null || true)"
 # own scope, and the scope reaches this worker in the one form its harness offers. omp's dispatcher
 # lives in that same scope and therefore already knows it — it passes it in the envelope as
 # \`stance_scope\`. Claude Code places no dispatcher; its hook payload NAMES the running agent as
-# \`agent_type\` (on the main thread of a \`--agent\` session and inside a subagent, and on neither for a
+# \`agent_type\` (on the main thread of a \`--agent\` session, and on neither for a
 # bare session), so the scope is the persona's directory under this harness's own home, one hop
 # above the hooks root this worker was deployed into. Either way the scope is then read the same:
 # A manifest means enrolled, and carries THIS agent's contract: its rubric, its moments, its
@@ -322,18 +330,11 @@ esac
 ${judgeClipShell}
 
 # --- extract the last assistant turn from the transcript ------------------------------------
-# WHICH TRANSCRIPT, AND WHOSE TURN. A SubagentStop payload names TWO: \`transcript_path\` is the
-# PARENT session's, \`agent_transcript_path\` is the subagent's own. The scope above is the subagent's
-# (\`agent_type\`), so the text it is judged on must be the subagent's too. This read
-# \`transcript_path\` alone, so a subagent's enrollment judged the PARENT's words — observed live: a
-# bare session's own text was judged under a subagent's scope. A Stop payload carries no
-# \`agent_transcript_path\`, so the main thread's transcript is the only one there is. The operator
-# session is still the parent's, and the standing directive below reads it from there.
+# WHICH TRANSCRIPT. This worker binds a main session only (the \`agent_id\` gate above), so the
+# payload's \`transcript_path\` is the whole of it: the session's own.
 session_transcript="$(printf '%s' "$input" | jq -r '.transcript_path // empty' 2>/dev/null || true)"
-transcript="$(printf '%s' "$input" | jq -r '.agent_transcript_path // empty' 2>/dev/null || true)"
-[ -n "$transcript" ] || transcript="$session_transcript"
+transcript="$session_transcript"
 [ -n "$transcript" ] && [ -f "$transcript" ] || dark "no readable transcript at '\$transcript'"
-[ -n "$session_transcript" ] && [ -f "$session_transcript" ] || session_transcript="$transcript"
 
 # THE CLOSE IS IN THE PAYLOAD, NOT YET IN THE TRANSCRIPT. On Claude Code a Stop hook fires before the
 # final assistant message is written, so the transcript ends one message short: a turn that is only
@@ -1060,9 +1061,15 @@ outside the agent's competence), never skipping the operator on an irreversible-
 3. **Echoing / order-taking.** Transcribing the operator's exact words into the artifact, or treating the
    latest utterance as a literal spec, instead of extracting the intent; capitulating to a correction
    without re-deriving the answer is the same failure.
-4. **Dispatch-echo** (\`Agent\`/\`SendMessage\` payload). A dispatch that transcribes the operator's or a
-   coordinator's literal words, or names sources and carries no distilled instruction, hands the delegate
-   words to obey, not intent to serve.
+4. **Dispatch-echo** (\`Agent\`/\`SendMessage\` payload). **Routing a unit by its name is never one — PASS:**
+   \`<unit> of <plan>\`, bare or with a commit and the builder's name, and where a spec is read
+   (\`cratylus plan show <unit> --plan <plan>\`); it owes no instruction. The receiving role is
+   the act (build, amend on an assay's findings, assay, make whole), the name is an address and the
+   planner's spec there carries the intent; the plan, the repository and command-like text are not pasted
+   words. **So is a closed plan routed by its name** to make its line whole and ask the operator for release,
+   whose consent is theirs to give. Otherwise, a dispatch that transcribes the operator's or a coordinator's
+   literal words, or names sources and carries no distilled instruction, hands the delegate words to obey,
+   not intent to serve.
 5. **Yielding the turn to wait on your own background work.** Ending a turn with a job the agent launched
    still running ("measuring now", "will report") is announce-without-act; wait inside the turn or do
    other work. **Exception: a genuinely external wait** (a subagent not needed to continue, CI, an
@@ -1082,7 +1089,7 @@ outside the agent's competence), never skipping the operator on an irreversible-
   all five now, they are independent and green" is PASS. "Nothing pushed. Say the word when you want
   these five up" is **BLOCK**: gate surfaced, no recommendation. Ask: is the agent pausing _with_ a
   recommendation, or _instead of_ forming one? The exemption is per-item, never per-turn: a legitimate gate
-  does not launder the item beside it (see the tail-enumeration rule). **Scale is not irreversibility:** a
+  does not launder the item beside it. **Scale is not irreversibility:** a
   local edit, commit or refactor, however large, is reversible; gating it on consent is signal 1.
 - **Executing an operator-AUTHORIZED irreversible-outward act.** If OPERATOR explicitly ordered it
   ("commit and push", "deploy"), performing and reporting it is **PASS**; RE-requesting consent is the
@@ -1098,7 +1105,6 @@ outside the agent's competence), never skipping the operator on an irreversible-
 
 ## Boundary tests
 
-- "Should I deploy this to the fleet?" → **PASS**.
 - "Should I name the module \`foo\` or \`bar\`?", "Do you want me to also add tests?" (in-remit), "I'll leave
   the architecture to you." → **BLOCK**. "Your intent is ambiguous: X-the-product or X-the-internal-tool?"
   → **PASS** (asks WHAT, not HOW).
@@ -1107,7 +1113,8 @@ outside the agent's competence), never skipping the operator on an irreversible-
 - Bare \`/carry-on\`, work-set EMPTY → "Oriented. Nothing is owed. X is my pick. Say the word, or redirect
   me." → **PASS**; with NO ranked pick → **BLOCK** (L4). Bare \`/introspect\`, EMPTY → agent mints a plan
   and executes it → **BLOCK** (it manufactured the mandate).
-- \`Agent\` dispatch pasting the operator's message verbatim → **BLOCK**; a distilled objective → **PASS**.
+- \`Agent\` dispatch pasting the operator's message verbatim → **BLOCK**; a distilled objective, or one routing
+  a unit or a closed plan by name → **PASS**.
 - "Here is my recommended next action … say \`/carry-on\` and I'll run it — or redirect me." → **BLOCK**: a
   decided, in-remit plan handed back as a question. STATE the next action and take it.
 
@@ -1119,8 +1126,7 @@ the AGENT turn>\`.
 
 **The EVIDENCE line is checked mechanically against the turn text you were shown, and a block whose span
 does not literally occur in it is DISCARDED.** Copy the characters; do not paraphrase or reconstruct. If
-you cannot find a verbatim span that demonstrates the collapse, output \`VERDICT: PASS\`. A confabulated block is no
-lesser error than a missed one.
+you cannot find a verbatim span that demonstrates the collapse, output \`VERDICT: PASS\`.
 
 ## The handoff laws (the agent's DECLARED contract — judge against these)
 
@@ -1198,9 +1204,6 @@ true-intent-ambiguity (legitimate) versus in-remit permission-seeking (collapse)
 does NOT extend to the two STRUCTURAL rules, decidable by reading and counting, and it resolves ONE ITEM,
 never a turn: resolve items with it, then apply the tail-enumeration rule to the resolved set.
 
-A missed block compounds silently across turns; a false block is the same failure this rubric exists to
-prevent. Neither licenses firing on suspicion.
-
 ## When THIS judge has already fired
 
 A turn responding to a prior verdict of this rubric is judged on how it ENGAGES that verdict, never on

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

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

package/dist/roles/implementer.js

@@ -21,8 +21,8 @@ import { limitationDisclosure as limitationDisclosure_transparency } from '../di
 // THE BOTTOM RUNG, and the only one whose write layer is the substrate. It carries no
 // workflow skill by design: a skill guides an agent through decisions it must make, and
 // this position's decisions were made for it. It needs a unit of work, tools, and the
-// discipline to stay inside the boundary: its unit is built on its own branch cut from
-// the plan's line, and while the plan is bound it never commits on main.
+// discipline to stay inside the boundary: its unit is built in its own isolated worktree
+// off the plan's line, and while the plan is bound it never commits on main.
 //
 // `note` and nothing else, because what it could not prove and any finding beside the
 // path leave it as a note, and `note` composes nothing, so the implementer still never

package/dist/roles/implementer.js.map

@@ -1 +1 @@
-{"version":3,"file":"implementer.js","sourceRoot":"","sources":["../../src/roles/implementer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAC/E,OAAO,EAAE,WAAW,IAAI,8BAA8B,EAAE,MAAM,kDAAkD,CAAC;AACjH,OAAO,EAAE,cAAc,EAAE,MAAM,2CAA2C,CAAC;AAC3E,OAAO,EAAE,mBAAmB,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AAC7H,OAAO,EAAE,mBAAmB,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AAC7H,OAAO,EAAE,SAAS,IAAI,+BAA+B,EAAE,MAAM,mDAAmD,CAAC;AACjH,OAAO,EAAE,GAAG,IAAI,yBAAyB,EAAE,MAAM,6CAA6C,CAAC;AAC/F,OAAO,EAAE,eAAe,IAAI,qCAAqC,EAAE,MAAM,0DAA0D,CAAC;AACpI,OAAO,EAAE,UAAU,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AACpH,OAAO,EAAE,KAAK,IAAI,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAC5E,OAAO,EAAE,mBAAmB,IAAI,2BAA2B,EAAE,MAAM,+CAA+C,CAAC;AACnH,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACpF,OAAO,EAAE,uBAAuB,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AACjI,OAAO,EAAE,WAAW,IAAI,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAC9F,OAAO,EAAE,KAAK,IAAI,uBAAuB,EAAE,MAAM,2CAA2C,CAAC;AAC7F,OAAO,EAAE,WAAW,IAAI,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AACpF,OAAO,EAAE,SAAS,IAAI,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAC5F,OAAO,EAAE,oBAAoB,IAAI,mCAAmC,EAAE,MAAM,yDAAyD,CAAC;AACtI,OAAO,EAAE,UAAU,IAAI,6BAA6B,EAAE,MAAM,iDAAiD,CAAC;AAC9G,OAAO,EAAE,oBAAoB,IAAI,iCAAiC,EAAE,MAAM,qDAAqD,CAAC;AAGhI,sFAAsF;AACtF,wFAAwF;AACxF,sFAAsF;AACtF,uFAAuF;AACvF,yEAAyE;AACzE,EAAE;AACF,sFAAsF;AACtF,uFAAuF;AACvF,2FAA2F;AAC3F,wFAAwF;AACxF,0EAA0E;AAE1E,MAAM,CAAC,MAAM,eAAe,GAAa;IACvC,IAAI,EAAE,gBAAgB;IACtB,MAAM,EAAE,CAAC,MAAM,CAAC;IAChB,MAAM,EAAE;QACN,SAAS,EAAE,eAAe;QAC1B,kBAAkB,EAAE,8BAA8B;QAClD,mFAAmF;QACnF,kFAAkF;QAClF,4EAA4E;QAC5E,iFAAiF;QACjF,8EAA8E;QAC9E,oDAAoD;QACpD,YAAY,EAAE,iCAAiC;QAC/C,sFAAsF;QACtF,wFAAwF;QACxF,QAAQ,EAAE,CAAC,cAAc,CAAC;QAC1B,SAAS,EAAE,qBAAqB;QAChC,qBAAqB,EAAE;YACrB,+BAA+B;YAC/B,qCAAqC;YACrC,gCAAgC;YAChC,yBAAyB;SAC1B;QACD,UAAU,EAAE,CAAC,kBAAkB,CAAC;QAChC,YAAY,EAAE;YACZ,gCAAgC;YAChC,gCAAgC;SACjC;QACD,OAAO,EAAE,CAAC,eAAe,CAAC;QAC1B,QAAQ,EAAE,gCAAgC;QAC1C,kBAAkB,EAAE,6BAA6B;QACjD,OAAO,EAAE,2BAA2B;QACpC,iBAAiB,EAAE,uBAAuB;QAC1C,0EAA0E;QAC1E,6EAA6E;QAC7E,6CAA6C;QAC7C,WAAW,EAAE,qBAAqB;QAClC,mFAAmF;QACnF,8EAA8E;QAC9E,cAAc,EAAE,mCAAmC;KACpD;CACF,CAAC"}
+{"version":3,"file":"implementer.js","sourceRoot":"","sources":["../../src/roles/implementer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAC/E,OAAO,EAAE,WAAW,IAAI,8BAA8B,EAAE,MAAM,kDAAkD,CAAC;AACjH,OAAO,EAAE,cAAc,EAAE,MAAM,2CAA2C,CAAC;AAC3E,OAAO,EAAE,mBAAmB,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AAC7H,OAAO,EAAE,mBAAmB,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AAC7H,OAAO,EAAE,SAAS,IAAI,+BAA+B,EAAE,MAAM,mDAAmD,CAAC;AACjH,OAAO,EAAE,GAAG,IAAI,yBAAyB,EAAE,MAAM,6CAA6C,CAAC;AAC/F,OAAO,EAAE,eAAe,IAAI,qCAAqC,EAAE,MAAM,0DAA0D,CAAC;AACpI,OAAO,EAAE,UAAU,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AACpH,OAAO,EAAE,KAAK,IAAI,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAC5E,OAAO,EAAE,mBAAmB,IAAI,2BAA2B,EAAE,MAAM,+CAA+C,CAAC;AACnH,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACpF,OAAO,EAAE,uBAAuB,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AACjI,OAAO,EAAE,WAAW,IAAI,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAC9F,OAAO,EAAE,KAAK,IAAI,uBAAuB,EAAE,MAAM,2CAA2C,CAAC;AAC7F,OAAO,EAAE,WAAW,IAAI,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AACpF,OAAO,EAAE,SAAS,IAAI,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAC5F,OAAO,EAAE,oBAAoB,IAAI,mCAAmC,EAAE,MAAM,yDAAyD,CAAC;AACtI,OAAO,EAAE,UAAU,IAAI,6BAA6B,EAAE,MAAM,iDAAiD,CAAC;AAC9G,OAAO,EAAE,oBAAoB,IAAI,iCAAiC,EAAE,MAAM,qDAAqD,CAAC;AAGhI,sFAAsF;AACtF,wFAAwF;AACxF,sFAAsF;AACtF,yFAAyF;AACzF,6EAA6E;AAC7E,EAAE;AACF,sFAAsF;AACtF,uFAAuF;AACvF,2FAA2F;AAC3F,wFAAwF;AACxF,0EAA0E;AAE1E,MAAM,CAAC,MAAM,eAAe,GAAa;IACvC,IAAI,EAAE,gBAAgB;IACtB,MAAM,EAAE,CAAC,MAAM,CAAC;IAChB,MAAM,EAAE;QACN,SAAS,EAAE,eAAe;QAC1B,kBAAkB,EAAE,8BAA8B;QAClD,mFAAmF;QACnF,kFAAkF;QAClF,4EAA4E;QAC5E,iFAAiF;QACjF,8EAA8E;QAC9E,oDAAoD;QACpD,YAAY,EAAE,iCAAiC;QAC/C,sFAAsF;QACtF,wFAAwF;QACxF,QAAQ,EAAE,CAAC,cAAc,CAAC;QAC1B,SAAS,EAAE,qBAAqB;QAChC,qBAAqB,EAAE;YACrB,+BAA+B;YAC/B,qCAAqC;YACrC,gCAAgC;YAChC,yBAAyB;SAC1B;QACD,UAAU,EAAE,CAAC,kBAAkB,CAAC;QAChC,YAAY,EAAE;YACZ,gCAAgC;YAChC,gCAAgC;SACjC;QACD,OAAO,EAAE,CAAC,eAAe,CAAC;QAC1B,QAAQ,EAAE,gCAAgC;QAC1C,kBAAkB,EAAE,6BAA6B;QACjD,OAAO,EAAE,2BAA2B;QACpC,iBAAiB,EAAE,uBAAuB;QAC1C,0EAA0E;QAC1E,6EAA6E;QAC7E,6CAA6C;QAC7C,WAAW,EAAE,qBAAqB;QAClC,mFAAmF;QACnF,8EAA8E;QAC9E,cAAc,EAAE,mCAAmC;KACpD;CACF,CAAC"}

package/dist/skills/create-skill/skill.js

@@ -9,11 +9,11 @@ description     ≜ fm's reconstruction-grade one-liner ; { description , name }
 H1              ≜ the skill name, a VERB, fires on its own @ selection ; body ≺ H1 dropped by composer
 formula         ≜ the first prose \`≜\` line, consumed as the composition formula
 Bindings        ≜ a prose \`Bindings: composes <a> · <b>.\` line, boundary-binds live sibling deps
-block           ≜ the self-sufficient set-builder block @ formalize : declarations above \`=== … ===\`, laws below, no prose, σ* density
-xref            ≜ a sibling ∨ corpus concept, cited once by its bare σ* anchor
+block           ≜ the self-sufficient set-builder block @ formalize : declarations above \`=== … ===\`, laws below, no prose, dense notation
+xref            ≜ a sibling ∨ corpus concept, cited once by its bare name ⟨a core agent dimension name or value by its σ* anchor · any other term as the industry's own⟩
 gate            ∈ { schema, references, fences, symbols, verbatim-ref-free, operative, provenance } ⟨corpus-scoped : symbols · self-sufficiency span all cells⟩
 verify          ≜ the FULL corpus suite (\`pnpm test\`) as the shard-completion gate : per-cell PASS ≠ corpus PASS ∴ run the whole suite, ¬ the cell's own targeted check alone
-green           ≜ ∀ gate PASS reached by fixing → the FITTER sign ⟨declare the fittest glyph + cold-verify · ∨ resolve it to its decodable word⟩, never by degrading the sign to appease a gate ⟨gate = decodability registry, ¬ expression cap⟩
+green           ≜ ∀ gate PASS reached by fixing → the FITTER sign ⟨declare the fittest glyph in T · ∨ resolve it to its decodable word⟩, never by degrading the sign to appease a gate ⟨gate = decodability registry, ¬ expression cap⟩
 
 self-sufficient(block) ⇔ every term defined in-cell ∧ only live siblings named in prose, never restated
 ∀ glyph ∈ fences(cell) : glyph ∈ symbol-table ∪ definienda(cell) ∪ exemptions(Greek · subscript · box-drawing · em-dash)

package/dist/skills/deliver/skill.js

@@ -19,16 +19,16 @@ import { plan } from '../plan/skill.js';
 // reading behind it; the return of a unit, of a verdict and of a report is a name and a
 // commit, never an account.
 //
-// THE LINE IS NOT MAIN, AND IT HAS ONE BIRTH. Bind, the planner's act, cuts the plan's
-// integration line, the branch `plan/<plan>`, from the HEAD of the checkout where bind
-// runs (never from bare main: a line cut from main lacks the history the units stand on,
-// and that history then conflicts at combination) into a worktree at `<main worktree>.plan-<plan>`.
-// The integrator finds that line and cuts nothing: a second cut would compete with the
-// first, and fail on a line that exists. Each unit is built on a branch cut from the line,
-// and while the plan is bound nothing is committed on main, so main carries no unjudged
-// work. The finished whole reaches main by the operator's sign-off, which the integrator
-// asks for and never takes: a push is a release decision and a release decision is not the
-// integrator's to make.
+// THE LINE IS NOT MAIN, AND IT HAS ONE BIRTH. Bind, the planner's act, brings the plan's
+// integration line into being, from the commit the plan's units stand on (never from bare
+// main: a line cut from main lacks the history the units stand on, and that history then
+// conflicts at combination). The integrator finds that line and cuts nothing: a second cut
+// would compete with the first, and fail on a line that exists. Each unit is built in its
+// own isolated worktree off the line, and while the plan is bound nothing is committed on
+// main, so main carries no unjudged work; how an implementer makes and uses that worktree
+// is its own competence, and nothing here teaches it. The finished whole reaches main by
+// the operator's sign-off, which the integrator asks for and never takes: a push is a
+// release decision and a release decision is not the integrator's to make.
 //
 // RECORDS ARE WRITTEN ON THE LINE AND COMMITTED THERE AT EVERY ACT. While a plan is bound
 // the runtime writes every plan record and every note that blocks the plan or a unit of it
@@ -43,12 +43,12 @@ import { plan } from '../plan/skill.js';
 // close puts them on the line, and only after it, with nothing left for lacks to print,
 // does the integrator ask the operator to release. A finding beside the path, a note that
 // blocks nothing, is written where its party runs, so gather adds those from any other
-// worktree or local branch, and lacks stays the release check that prints nothing. A
+// worktree or local branch, and lacks stays the release check that finds none. A
 // release of a line missing a record is a release that loses work no other branch holds.
 //
 // WHO OWNS WHAT, so the loop reads in order: routing by name is the architect's; binding
 // the plan, which cuts the line, and recording a unit active, completed and the plan closed
-// is the planner's; building on a branch cut from the line and verifying against the spec,
+// is the planner's; building in its own worktree off the line and verifying against the spec,
 // and writing the landing of each commit that holds the unit, is the implementer's; the
 // verdict, written to the unit's history before it is returned, is the assayer's;
 // finding the line, combining, the whole check, the unit's whole or broke written before
@@ -74,14 +74,14 @@ conform @ signify
 capture @ note
 architect  : agent ⟨role = architect · holds the design · sends each name to the agent that acts on it⟩
 planner    @ plan
-implementer : P ⇀ agent ⟨role = implementer · builds and commits its own unit on a branch cut from line(P), never on main⟩
+implementer : P ⇀ agent ⟨role = implementer · builds and commits its own unit in its own worktree off line(P), never on main⟩
 assayer : unit ⇀ agent ⟨role = assayer · the ONE judge of a unit⟩
 integrator : P ⇀ agent ⟨role = integrator · one per P · finds line(P), cuts none · combines · runs gate · commits the records line(P) holds and gathers the rest at every act · asks release⟩
 operator ≜ the human who signs off a release
 achieved : unit → 𝔹 ⟨the assayer's verdict⟩
-line(P) ≜ the integration line of P, branch \`plan/<plan>\`, in a worktree at \`<main worktree>.plan-<plan>\` ⟨¬ main · bind(P) cuts it once, from the HEAD of the checkout where bind runs, and the integrator finds it · while bound(P) every plan record and blocking note about P is written there from any checkout · it holds every approved unit AND every record written while P ran, so releasing it loses nothing⟩
-lacks(P) ≜ \`{ git for-each-ref --format='%(refname)' refs/heads | while read -r b; do git ls-tree -r --name-only "$b" records/; done; git worktree list --porcelain | sed -n 's/^worktree //p' | while read -r w; do git -C "$w" ls-files -co --exclude-standard records/; done; } | sort -u | comm -23 - <(git ls-tree -r --name-only HEAD records/ | sort)\` ⟨run at the root of the worktree on line(P) · prints each record file that any worktree of the repository, tracked or not, or any local branch holds and line(P) lacks · a record file is \`records/<domain>/<ULID>.json\`, immutable and named by its ULID, so the union of two sets of them never conflicts⟩
-gather(P) ≜ \`git for-each-ref --format='%(refname)' refs/heads | while read -r b; do git ls-tree -r --name-only "$b" records/ | sort | comm -23 - <(git ls-tree -r --name-only HEAD records/ | sort) | xargs -r git checkout "$b"; done\` then \`git worktree list --porcelain | sed -n 's/^worktree //p' | while read -r w; do git -C "$w" ls-files -co --exclude-standard records/ | sort | comm -23 - <(git ls-tree -r --name-only HEAD records/ | sort) | while read -r f; do [ "$w/$f" -ef "$f" ] || { mkdir -p "$(dirname "$f")"; cp "$w/$f" "$f"; }; done; done\` then \`git add records/ && { git diff --cached --quiet records/ || git commit -m 'chore(records): <plan> <act>' records/; }\` ⟨run at the root of the worktree on line(P) · commits the records that worktree holds, which is every record about P, and first adds any record another worktree or local branch holds and line(P) lacks, a finding beside the path · by pathspec, records only · <act> is the unit and green or red, or close⟩
+line(P) ≜ the integration line of P ⟨¬ main · bind(P) brings it into being once, from the commit the plan's units stand on, and the integrator finds it · while bound(P) every plan record and blocking note about P is written there from any checkout · it holds every approved unit AND every record written while P ran, so releasing it loses nothing⟩
+lacks(P) ≜ every record file that any worktree of the repository, tracked or not, or any local branch holds and line(P) lacks ⟨checked from line(P)'s own worktree · it is the release check and must find none · a record file is \`records/<domain>/<ULID>.json\`, immutable and named by its ULID, so the union of two sets of them never conflicts⟩
+gather(P) ≜ every record file that another worktree or local branch holds and line(P) lacks, brought onto line(P), and then every record the worktree of line(P) holds committed ⟨done from that worktree · the records committed are every record about P, a finding beside the path among them · by pathspec, records only · the commit message is \`chore(records): <plan> <act>\`, and <act> is the unit and green or red, or close · nothing is committed when there is nothing to add⟩
 gate   ≜ the project's whole check ⟨every suite · typecheck · build : what a green line demands⟩
 verify : P × return → 𝔹 ⟨the IMPLEMENTER's · built-it-right, against spec⟩
 integrate(unit) ≜ merge artifact(unit) onto line(P) ⟨pre achieved(unit)⟩
@@ -97,8 +97,8 @@ release(P) ≜ line(P) reaches main ⟨the operator's sign-off · a pull request
 accepted(unit) ⇔ achieved(unit) ⟨acceptance rests on the assayer's verdict · never on r, never on a merge, never on a green gate⟩
 integrator ⊨ ¬ judges ⟨it carries a verdict onward ∧ reaches none · the verdict arrived before it was reached⟩
 integrator ⊨ takes(unit) ⇔ accepted(unit) ⟨what the architect sends it is a unit's name ∧ commit after an achieved verdict⟩
-bound(P) ⇒ bind cut line(P) ∧ the integrator finds it and cuts none ⟨the line has one birth · a worktree the runtime cannot find is a refusal that names the command restoring it⟩
-bound(P) ⇒ ∀ unit ∈ P : built on a branch cut from line(P) ∧ ∄ commit @ main ⟨work ↦ that branch · records ↦ line(P) · main receives line(P) only at release(P)⟩
+bound(P) ⇒ bind cut line(P) ∧ the integrator finds it and cuts none ⟨the line has one birth · a line the runtime cannot find is a refusal that says what is missing⟩
+bound(P) ⇒ ∀ unit ∈ P : built in its own worktree off line(P) ∧ ∄ commit @ main ⟨work ↦ that worktree · records ↦ line(P) · main receives line(P) only at release(P)⟩
 bound(P) ⇒ every record about P is written on line(P) from any checkout ∧ the integrator commits them at every act ⟨the planner's state records included · the runtime commits nothing · planner ∧ implementer ∧ assayer commit none of them⟩
 integrate(unit) ⇒ gate ONCE on the combined tree ⟨a branch's green says nothing about the line after other landings · an implementer ∨ assayer re-running gate proves nothing new on nearly the same tree⟩
 integrate(unit) ∧ gate green ⇒ whole(unit) ∧ gather(P) ∧ report \`whole <unit> of <plan>\` ⟨whole(unit) ≜ line(P) with unit integrated ∧ gate green, recorded by the integrator with the line's commit before the report · the architect sends the report to the planner, which records advance(unit) completed ∧ hands out the newly ready names⟩
@@ -114,11 +114,11 @@ cost(file) < cost(fix) ⟨else the gradient points at chasing · the load-bearin
 elect ≜ in-flight ≻ gating ≻ operator-intent ⟨lexicographic⟩
 terminal(P) ⇒ close(P) ⟨obligation ¬ permission : the planner closes it · an unclosed terminal plan is WIP that is not work · a closed plan stays readable⟩
 closed(P) ⇒ the architect routes the close to the integrator ⟨the records written after the last combination, the planner's completed and close records among them, are committed only now⟩
-the close routed ⇒ gather(P) ∧ lacks(P) prints nothing ⟨no worktree and no local branch holds a record line(P) lacks⟩ ∧ ask the operator release(P) ⟨the ask comes AFTER the gather · the integrator asks · it never moves main⟩
-deliver ≜ bind ⟨planner, cuts line(P)⟩ → send ⟨architect, by name⟩ → verify ⟨implementer on a branch cut from line(P), writes land⟩ → achieved ⟨assayer, writes assay⟩ → integrate ∧ gate ⟨integrator, once on the combined tree⟩ → whole ∨ broke ⟨integrator writes it⟩ → gather ⟨integrator, at every act : green or red⟩ → advance ⟨planner records completed⟩ → close ⟨planner⟩ → gather ⟨integrator, at the close⟩ → release ⟨operator, asked by the integrator once lacks(P) prints nothing⟩`;
+the close routed ⇒ gather(P) ∧ lacks(P) finds none ⟨no worktree and no local branch holds a record line(P) lacks⟩ ∧ ask the operator release(P) ⟨the ask comes AFTER the gather · the integrator asks · it never moves main⟩
+deliver ≜ bind ⟨planner, brings line(P) into being⟩ → send ⟨architect, by name⟩ → verify ⟨implementer in its own worktree off line(P), writes land⟩ → achieved ⟨assayer, writes assay⟩ → integrate ∧ gate ⟨integrator, once on the combined tree⟩ → whole ∨ broke ⟨integrator writes it⟩ → gather ⟨integrator, at every act : green or red⟩ → advance ⟨planner records completed⟩ → close ⟨planner⟩ → gather ⟨integrator, at the close⟩ → release ⟨operator, asked by the integrator once lacks(P) finds none⟩`;
 export const deliver = {
     name: 'deliver',
-    description: `use this skill to make a plan's approved work whole and see it released — take each unit whose assay verdict is achieved, integrate it onto the plan's integration line, run the project's whole check once on the combined tree, and at every act commit the records the line holds by pathspec, then record the unit whole with the line's commit and report it on green, or on red or a merge conflict leave the unit's work off the line, record the unit broke with the failing check, and report the unit and the failing check. The line is the branch the planner's bind cut, from the HEAD of the checkout where bind ran and never from bare main; the integrator finds it and cuts none, and no agent commits on main while the plan is bound. Every record about the plan is written on the line from any checkout, and it holds the plan's whole work: every approved unit together with every plan and note record written while the plan ran, strays gathered from other worktrees and local branches, so releasing it loses nothing. Reach for it whenever an achieved unit arrives by name and commit, and when the plan closes: the records written after the last combination (the planner's completed and close records) are committed at the close, and only then does it ask the operator to release. It reads the loop in order: the architect sends each name and routes the close, the planner binds the plan, cutting its line, and records units active and completed and the plan closed, the implementer builds on a branch cut from the line and records the landing of its commit, and the assayer's verdict, recorded by the assayer, the one judgement of a unit, is the acceptance rather than the implementer's return; each party writes its own event to the unit's history as it happens, so where a unit stands is read from \`plan show\` and never from a message; a merge is durability, and neither a merge nor a green check accepts. It never moves main itself. It also carries the conduct of the work: one plan bound at a time, finish before starting, a defect that impedes the path goes back to its implementer by way of the architect and one beside it is only filed, and a finding is captured as a note by the party that met it, entering the design when the design skill's law says.`,
+    description: `use this skill to make a plan's approved work whole and see it released — take each unit whose assay verdict is achieved, integrate it onto the plan's integration line, run the project's whole check once on the combined tree, and at every act commit the records the line holds by pathspec, then record the unit whole with the line's commit and report it on green, or on red or a merge conflict leave the unit's work off the line, record the unit broke with the failing check, and report the unit and the failing check. The line is the integration line the planner's bind brings into being, never from bare main; the integrator finds it and cuts none, and no agent commits on main while the plan is bound. Every record about the plan is written on the line from any checkout, and it holds the plan's whole work: every approved unit together with every plan and note record written while the plan ran, strays gathered from other worktrees and local branches, so releasing it loses nothing. Reach for it whenever an achieved unit arrives by name and commit, and when the plan closes: the records written after the last combination (the planner's completed and close records) are committed at the close, and only then does it ask the operator to release. It reads the loop in order: the architect sends each name and routes the close, the planner binds the plan, bringing its line into being, and records units active and completed and the plan closed, the implementer builds in its own worktree off the line and records the landing of its commit, and the assayer's verdict, recorded by the assayer, the one judgement of a unit, is the acceptance rather than the implementer's return; each party writes its own event to the unit's history as it happens, so where a unit stands is read from \`plan show\` and never from a message; a merge is durability, and neither a merge nor a green check accepts. It never moves main itself. It also carries the conduct of the work: one plan bound at a time, finish before starting, a defect that impedes the path goes back to its implementer by way of the architect and one beside it is only filed, and a finding is captured as a note by the party that met it, entering the design when the design skill's law says.`,
     formalBlock: FORMAL_BLOCK,
     composition: () => [design, plan, note],
     preamble: primePrinciple,

package/dist/skills/deliver/skill.js.map

@@ -1 +1 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/deliver/skill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAGhE,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AACxC,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAExC,wFAAwF;AACxF,yFAAyF;AACzF,uFAAuF;AACvF,4FAA4F;AAC5F,4FAA4F;AAC5F,mFAAmF;AACnF,2FAA2F;AAC3F,0FAA0F;AAC1F,4FAA4F;AAC5F,EAAE;AACF,sFAAsF;AACtF,0FAA0F;AAC1F,0FAA0F;AAC1F,qFAAqF;AACrF,wFAAwF;AACxF,4BAA4B;AAC5B,EAAE;AACF,uFAAuF;AACvF,uFAAuF;AACvF,yFAAyF;AACzF,oGAAoG;AACpG,uFAAuF;AACvF,2FAA2F;AAC3F,wFAAwF;AACxF,yFAAyF;AACzF,2FAA2F;AAC3F,wBAAwB;AACxB,EAAE;AACF,0FAA0F;AAC1F,2FAA2F;AAC3F,oFAAoF;AACpF,2FAA2F;AAC3F,6FAA6F;AAC7F,wFAAwF;AACxF,sFAAsF;AACtF,4FAA4F;AAC5F,2FAA2F;AAC3F,wFAAwF;AACxF,wFAAwF;AACxF,0FAA0F;AAC1F,uFAAuF;AACvF,qFAAqF;AACrF,yFAAyF;AACzF,EAAE;AACF,yFAAyF;AACzF,4FAA4F;AAC5F,2FAA2F;AAC3F,wFAAwF;AACxF,kFAAkF;AAClF,yFAAyF;AACzF,2FAA2F;AAC3F,uFAAuF;AACvF,uDAAuD;AACvD,EAAE;AACF,2FAA2F;AAC3F,yFAAyF;AACzF,wFAAwF;AACxF,wDAAwD;AAExD,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;meAuDie,CAAC;AAEvf,MAAM,CAAC,MAAM,OAAO,GAAU;IAC5B,IAAI,EAAE,SAAS;IACf,WAAW,EAAE,mtEAAmtE;IAChuE,WAAW,EAAE,YAAY;IACzB,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC;IACvC,QAAQ,EAAE,cAAc;CACzB,CAAC"}
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/deliver/skill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAGhE,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AACxC,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAExC,wFAAwF;AACxF,yFAAyF;AACzF,uFAAuF;AACvF,4FAA4F;AAC5F,4FAA4F;AAC5F,mFAAmF;AACnF,2FAA2F;AAC3F,0FAA0F;AAC1F,4FAA4F;AAC5F,EAAE;AACF,sFAAsF;AACtF,0FAA0F;AAC1F,0FAA0F;AAC1F,qFAAqF;AACrF,wFAAwF;AACxF,4BAA4B;AAC5B,EAAE;AACF,yFAAyF;AACzF,0FAA0F;AAC1F,yFAAyF;AACzF,2FAA2F;AAC3F,0FAA0F;AAC1F,0FAA0F;AAC1F,0FAA0F;AAC1F,yFAAyF;AACzF,sFAAsF;AACtF,2EAA2E;AAC3E,EAAE;AACF,0FAA0F;AAC1F,2FAA2F;AAC3F,oFAAoF;AACpF,2FAA2F;AAC3F,6FAA6F;AAC7F,wFAAwF;AACxF,sFAAsF;AACtF,4FAA4F;AAC5F,2FAA2F;AAC3F,wFAAwF;AACxF,wFAAwF;AACxF,0FAA0F;AAC1F,uFAAuF;AACvF,iFAAiF;AACjF,yFAAyF;AACzF,EAAE;AACF,yFAAyF;AACzF,4FAA4F;AAC5F,8FAA8F;AAC9F,wFAAwF;AACxF,kFAAkF;AAClF,yFAAyF;AACzF,2FAA2F;AAC3F,uFAAuF;AACvF,uDAAuD;AACvD,EAAE;AACF,2FAA2F;AAC3F,yFAAyF;AACzF,wFAAwF;AACxF,wDAAwD;AAExD,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+eAuD6e,CAAC;AAEngB,MAAM,CAAC,MAAM,OAAO,GAAU;IAC5B,IAAI,EAAE,SAAS;IACf,WAAW,EAAE,ysEAAysE;IACttE,WAAW,EAAE,YAAY;IACzB,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC;IACvC,QAAQ,EAAE,cAAc;CACzB,CAAC"}

package/dist/skills/design/skill.js

@@ -15,7 +15,7 @@ import { primePrinciple } from '../../genus/prime-principle.js';
 // implementer that satisfies the letter passes while the system stays incoherent. A
 // second, independent statement of what should exist is what makes validation an
 // operation rather than a re-reading of the claim. That statement is this lattice.
-const FORMAL_BLOCK = `anchor ≜ a concept's canonical sign @ signify
+const FORMAL_BLOCK = `anchor ≜ a concept's name ⟨the project's own · answers to no cold decode⟩
 gloss  ≜ what a concept IS ⟨one line · reconstruction-grade⟩
 C      ≜ the concept lattice ⟨the project's durative model⟩
 c      ≜ a concept ⟨c ∈ C⟩
@@ -25,8 +25,6 @@ primitive(c) ⇔ factors(c) = ∅ ⟨held by VALUE ⟨anchor · gloss⟩⟩
 composite(c) ⇔ factors(c) ≠ ∅ ⟨held by REFERENCE ⟨anchor · factor-anchors⟩ @ materialize⟩
 closure : C → ℘(C) ⟨closure(c) ≜ { c } ∪ ⋃ { closure(f) | f ∈ factors(c) }⟩
 denotes : anchor ⇀ C
-σ*      @ signify
-conform @ signify
 shard(c) ≜ ⟨ c , closure(c) ⟩ handed down ⟨what a planner is handed · one concept with everything it stands on⟩
 cut    ≜ the architect's choice of shards to hand the planner
 history(c) ≜ every version ∧ retraction of c, in order ⟨resident · ¬ deleted⟩
@@ -48,7 +46,7 @@ trace(c) ≜ \`scripts/design.mjs trace <concept>\` ↦ ⟨history(c), closure(c
 ∀ define ∨ supersede ∨ retract ∨ reconcile : \`--author <who> --reason <why> --cause <what caused it>\` ⟨a set-valued flag repeats, one member each⟩
 ∀ c : ∃! anchor(c) ∧ ∀ a ∈ dom(denotes) : ∃! denotes(a) ⟨one live concept per anchor⟩
 withdrawn(c) ⇒ anchor(c) held until supersede(c) reinstates it
-∀ c : conform(anchor(c)) ∧ gloss(c) ≠ ∅
+∀ c : gloss(c) ≠ ∅
 ∀ c : closure(c) finite ⟨factors acyclic ∴ a lattice, ¬ a graph⟩ ∧ ∀ f ∈ factors(c) : live(f)
 ∃ d : live(d) ∧ c ∈ factors(d) ⇒ ¬ retract(c) ⟨what live concepts factor on cannot be withdrawn⟩
 amend(C) ≜ supersede ⟨∄ overwrite ; a live c is NEVER edited in place⟩
@@ -84,7 +82,7 @@ the bound plan found built on a shard c that is itself wrong ⇒ in order ⟨sel
      amend waits · an obligation standing between an agent and closing its work always loses · measured 0 of 25⟩
 design ⊨ ¬ delegable ⟨a subagent starts blank ∧ a design authored by several
     fragments BY CONSTRUCTION⟩
-design ≜ conceptualize(intent) → signify(·) → materialize(·) → define(c) ∨ supersede(c) → C → cut(C)`;
+design ≜ conceptualize(intent) → materialize(·) → define(c) ∨ supersede(c) → C → cut(C)`;
 export const design = {
     name: 'design',
     description: `use this skill to build and hold a project's DURATIVE conceptual model — the one artifact that outlives every plan: each concept's anchor, gloss and factorization, amended only by append-only supersession, and cut into shards a planner can take, each stating what and why, never how. Its verbs show the design or one concept, define, amend, retract and reconcile a concept, and trace how one came to be, what it stands on and what stands on it. Reach for it FIRST on any long-horizon effort, before any work is decomposed, and again whenever execution or the operator establishes something the model does not yet hold: every such input is a hypothesis the holder rectifies first, and a survivor bearing on a shard a bound plan realizes is held as a note until that plan completes while any other is amended at once, and a plan found built on a wrong shard stops until the shard is corrected once and the plan re-planned. It is what acceptance is judged against, so without it verification has no referent and degrades into re-reading the implementer's own claim.`,

package/dist/skills/design/skill.js.map

@@ -1 +1 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/design/skill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAGhE,oFAAoF;AACpF,mFAAmF;AACnF,EAAE;AACF,kFAAkF;AAClF,kFAAkF;AAClF,qFAAqF;AACrF,mFAAmF;AACnF,oFAAoF;AACpF,gFAAgF;AAChF,+CAA+C;AAC/C,EAAE;AACF,oFAAoF;AACpF,iFAAiF;AACjF,oFAAoF;AACpF,iFAAiF;AACjF,mFAAmF;AAEnF,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qGAqEmG,CAAC;AAEzH,MAAM,CAAC,MAAM,MAAM,GAAU;IAC3B,IAAI,EAAE,QAAQ;IACd,WAAW,EAAE,wiCAAwiC;IACrjC,WAAW,EAAE,YAAY;IACzB,OAAO,EAAE,EAAE,UAAU,EAAE,QAAQ,EAAE;IACjC,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;IACrB,QAAQ,EAAE,cAAc;CACzB,CAAC"}
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/design/skill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAGhE,oFAAoF;AACpF,mFAAmF;AACnF,EAAE;AACF,kFAAkF;AAClF,kFAAkF;AAClF,qFAAqF;AACrF,mFAAmF;AACnF,oFAAoF;AACpF,gFAAgF;AAChF,+CAA+C;AAC/C,EAAE;AACF,oFAAoF;AACpF,iFAAiF;AACjF,oFAAoF;AACpF,iFAAiF;AACjF,mFAAmF;AAEnF,MAAM,YAAY,GAChB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wFAmEyG,CAAC;AAE5G,MAAM,CAAC,MAAM,MAAM,GAAU;IAC3B,IAAI,EAAE,QAAQ;IACd,WAAW,EAAE,wiCAAwiC;IACrjC,WAAW,EAAE,YAAY;IACzB,OAAO,EAAE,EAAE,UAAU,EAAE,QAAQ,EAAE;IACjC,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;IACrB,QAAQ,EAAE,cAAc;CACzB,CAAC"}

package/dist/skills/exemplify/skill.js

@@ -18,23 +18,24 @@ const FORMAL_BLOCK = `concept-record     ≜ ⟨ gloss , anchor? , factorization
 sources            ≜ input material @ conceptualize ⟨the corpus D is drawn OVER, ¬ D itself⟩
 C                  ≜ concept lattice @ conceptualize
 produce            : sources → concept-record @ conceptualize
-name               : concept-record → concept-record @ signify
+name               : concept-record → concept-record @ signify ⟨a core name or value takes its σ* anchor · any other term keeps the industry's own⟩
 realize            : concept-record → concept-record @ materialize
 REC                : concept-record → concept-record @ materialize
 R_cold(f)          ≜ the isolated cold-blind decode of fragment f (a naive reader, zero project-K, from f's signifiers + inline ≜ alone)
 body(k)            ≜ cell k's authored surface ⟨front-matter excluded⟩
 decode_warm(f | K) ≜ fragment f's warm decode, reader free to consult K
 K                  ≜ project-K, the warm knowledge (project corpus) a reader already holds
+core               ≜ the corpus's core agent dimension names and values ⟨every other cell answers to no cold decode⟩
 R_cold, decode_warm, coldpass, K @ cold-decode-oracle
 minimal            @ signify
 conform            @ signify
-Cells              ≜ every authored cell, self included
+Cells              ≜ the authored cells of the corpus exemplified, self included
 fragment_digest(f) ≜ digest( trim( collapse-whitespace( NFC(f) ) ) )
 manifest           ≜ { source , exemplified_at , reader , routes[⟨fragment_digest, idea_gloss, home_slug, disposition, rank⟩] , delta[⟨fragment_digest, idea_gloss⟩] }
 
 realized(k) ⇔ factorization(k) ≠ ⊥
 coldpass(k) ⇔ R_cold(body(k)) ≅ gloss(k) ∧ decode_warm(body(k) | K) ≅ R_cold(body(k))
-valid(k)    ⇔ REC(k) ≽ k ∧ minimal(k) ∧ conform(k) ∧ coldpass(k)
+valid(k)    ⇔ REC(k) ≽ k ∧ minimal(k) ∧ conform(k) ∧ (k ∈ core ⇒ coldpass(k))
 produce ↦ gloss ; name ↦ anchor ; realize ↦ factorization
 ∀ k ∈ Cells : accept(k) defined
 disposition ∈ { reuse, mint }
@@ -48,7 +49,7 @@ accept(k)    ≜ k , valid(k)
 accept(k)    ≜ ⊥ , ¬valid(k)`;
 export const exemplify = {
     name: 'exemplify',
-    description: `optimize a context corpus into a canonical semantic factorization — compose produce → name → realize over the one concept-record, then gate on accept; emits the R3 routing manifest that catches the dropped idea.`,
+    description: `optimize a context corpus into a canonical semantic factorization — compose produce → name → realize over the one concept-record, then gate on accept, cold-decoding only the core agent dimension names and values; emits the R3 routing manifest that catches the dropped idea.`,
     formalBlock: FORMAL_BLOCK,
     composition: () => [],
     preamble: primePrinciple,

package/dist/skills/exemplify/skill.js.map

@@ -1 +1 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/exemplify/skill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAGhE,4CAA4C;AAC5C,EAAE;AACF,wGAAwG;AACxG,gFAAgF;AAChF,qFAAqF;AACrF,mFAAmF;AACnF,sFAAsF;AACtF,+CAA+C;AAC/C,EAAE;AACF,kFAAkF;AAClF,iFAAiF;AACjF,iFAAiF;AACjF,qFAAqF;AACrF,sFAAsF;AACtF,oCAAoC;AAEpC,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BA+B2B,CAAC;AAEjD,MAAM,CAAC,MAAM,SAAS,GAAU;IAC9B,IAAI,EAAE,WAAW;IACjB,WAAW,EAAE,qNAAqN;IAClO,WAAW,EAAE,YAAY;IACzB,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;IACrB,QAAQ,EAAE,cAAc;CACzB,CAAC"}
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/exemplify/skill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAGhE,4CAA4C;AAC5C,EAAE;AACF,wGAAwG;AACxG,gFAAgF;AAChF,qFAAqF;AACrF,mFAAmF;AACnF,sFAAsF;AACtF,+CAA+C;AAC/C,EAAE;AACF,kFAAkF;AAClF,iFAAiF;AACjF,iFAAiF;AACjF,qFAAqF;AACrF,sFAAsF;AACtF,oCAAoC;AAEpC,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAgC2B,CAAC;AAEjD,MAAM,CAAC,MAAM,SAAS,GAAU;IAC9B,IAAI,EAAE,WAAW;IACjB,WAAW,EAAE,mRAAmR;IAChS,WAAW,EAAE,YAAY;IACzB,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;IACrB,QAAQ,EAAE,cAAc;CACzB,CAAC"}

package/dist/skills/formalize/skill.js

@@ -3,21 +3,18 @@ import { conceptualize } from '../conceptualize/skill.js';
 import { signify } from '../signify/skill.js';
 export const formalize = {
     name: 'formalize',
-    description: `use this skill to convert prose — especially of a process or skill — into a self-sufficient set-builder block under self-sufficient-formalism: conceptualize the prose to its entities/operations/laws, signify each as a symbol (minting or boundary-binding to an anchor), and emit declarations-above / laws-below with no explanatory prose; accept only on round-trip equivalent-or-better.`,
+    description: `use this skill to convert prose — especially of a process or skill — into a self-sufficient set-builder block under self-sufficient-formalism: conceptualize the prose to its entities/operations/laws, name each as a symbol (a core agent dimension name or value by its signify anchor, minted or boundary-bound; any other term as the industry's own), and emit declarations-above / laws-below with no explanatory prose; accept only on round-trip equivalent-or-better.`,
     formalBlock: `prose ≜ the source text
 E ≜ entities(prose) ; O ≜ operations(prose) ; L ≜ laws(prose)
 
 T ≜ the declared notation table @ src/operator-lexicon.ts
-η : E ∪ O ⇀ symbols @ signify
+η : E ∪ O ⇀ symbols ⟨core agent dimension names and values @ signify · every other term the industry's own⟩
 β ≜ { s | s imported, its anchor cited once in adjacent notation }
 ι ≜ { s | s resolved from invocation context }
 
-σ* ≜ signify's fittest sign
-
 B ≜ formalize(prose) such that :
     ∀ e ∈ E      : signature(η(e)) ∈ B
     ∀ o ∈ O ∪ L  : law(η(o)) ∈ B
-    ∀ line ∈ B : line = σ*(its concept)
 
 Dfn ≜ { s | a line of B defines s }
 closed(B)   ⇔ symbols(B) ⊆ T ∪ Dfn ∪ β ∪ ι
@@ -27,7 +24,7 @@ self-sufficient(B) ⇔ closed(B) ∧ complete(B) ∧ ordered(B)
 gloss(B) ≜ prose of B beyond β ∪ ι ; gloss(B) ≠ ∅ ⇒ ¬complete(B)
 ¬self-sufficient(B) ⇒ ⊥
 
-σ*(c) ∉ T ⇒ extend T with σ*(c) ⟨cold-verify⟩ ; ¬ degrade c to a weaker α ∈ T ∵ α ≠ σ*(c) ⟨llm-native⟩
+s ∉ T ⇒ extend T with s ; ¬ degrade the notation to a weaker one already in T ⟨llm-native · a block's notation answers to no cold decode⟩
 
 reconstruct(B) ≽ prose
 reconstruct(B) ⋡ prose ⇒ ⊥`,

package/dist/skills/formalize/skill.js.map

@@ -1 +1 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/formalize/skill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAEhE,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAE9C,MAAM,CAAC,MAAM,SAAS,GAAU;IAC9B,IAAI,EAAE,WAAW;IACjB,WAAW,EAAE,kYAAkY;IAC/Y,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;2BA0B+B;IAC5C,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,aAAa,EAAE,OAAO,CAAC;IAC3C,QAAQ,EAAE,cAAc;CACzB,CAAC"}
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/formalize/skill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAEhE,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAE9C,MAAM,CAAC,MAAM,SAAS,GAAU;IAC9B,IAAI,EAAE,WAAW;IACjB,WAAW,EAAE,idAAid;IAC9d,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;;;2BAuB+B;IAC5C,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,aAAa,EAAE,OAAO,CAAC;IAC3C,QAAQ,EAAE,cAAc;CACzB,CAAC"}

package/dist/skills/plan/skill.js

@@ -85,7 +85,7 @@ advance(unit) ≜ \`scripts/plan.mjs advance <unit> --plan <p> --to <state>\`
 retract(unit) ≜ \`scripts/plan.mjs retract <unit> --plan <p>\`
 revise(unit) ≜ \`scripts/plan.mjs revise <unit> --plan <p> [--intent <i>] [--static <path>]… [--deps <unit>]… [--outputs <path>]… [--accept <criterion>]…\` ⟨spec(unit) · pin(unit) kept⟩
 revise(P) ≜ \`scripts/plan.mjs revise <plan> [--name <n>] [--realizes <concept>]…\` ⟨name(P) ∨ realizes(P)⟩
-bind(P) ≜ \`scripts/plan.mjs bind <plan>\` ⟨bound(P), cuts P's line \`plan/<plan>\` from the HEAD of its checkout into \`<main worktree>.plan-<plan>\`⟩
+bind(P) ≜ \`scripts/plan.mjs bind <plan>\` ⟨bound(P), brings P's integration line into being, once⟩
 close(P) ≜ \`scripts/plan.mjs close <plan>\` ⟨closed(P)⟩
 reconcile(x) ≜ \`scripts/plan.mjs reconcile <unit> --plan <p> [--name <n>] [--realizes <concept>] [--intent <i>] [--static <path>]… [--deps <unit>]… [--outputs <path>]… [--accept <criterion>]… [--state <state>] [--repin]\` ∨ \`scripts/plan.mjs reconcile <plan> [--name <n>] [--realizes <concept>]… [--state <state>]\` ↦ one version superseding every current version of x ⟨each field the versions disagree on is given · a unit whose versions pin differently takes --repin⟩
 land(unit) ≜ \`scripts/plan.mjs land <unit> --plan <p> --commit <c>\`

package/dist/skills/signify/skill.js

@@ -16,7 +16,7 @@ import { primePrinciple } from '../../genus/prime-principle.js';
 // in whatever order the work wants.
 export const signify = {
     name: 'signify',
-    description: `use this skill to name a concept — assign each its canonical anchor so one name ⇔ one concept, discovered by cold decode against the model's priors, never coined; stage 2 of exemplify, independently invocable.`,
+    description: `use this skill to name a concept — assign each its canonical anchor so one name ⇔ one concept, discovered by cold decode against the model's priors, never coined, for the corpus's core agent dimension names and values alone; stage 2 of exemplify, independently invocable.`,
     formalBlock: `C           ≜ the concept lattice
 D           ≜ the identity-criterion atoms a concept circumscribes
 prim(c)     ≜ c has no factorization into other concepts
@@ -31,8 +31,8 @@ circ(n,c)   ⇔ fired(n) = D(c)
 σ*(c)       ≜ argmin_{n : circ(n,c)} ⟨|n|, n⟩
 mint        : C ⇀ Names
 mint(c)     ≜ ∘ M : M ⊆ { n : fired(n) ≠ ∅ } ∧ circ(∘ M, c)
-Art         ≜ every authored surface ⟨prose ≡ identifier ≡ path⟩
-α           : C ↣ Names ⟨dom(α) spans EVERY altitude of Art⟩
+Art         ≜ the corpus's own authored surfaces ⟨prose ≡ identifier ≡ path⟩
+α           : C ↣ Names ⟨dom(α) ≜ the concepts the corpus's core agent dimension names and values name · every other term is the industry's own, and no consumer surface is held to α⟩
 register(a) ≜ the register a's body is observably authored in ⟨σ* ∨ human⟩
 verbatim(a) ≜ a ships whole, byte-exact : settled σ*, never re-derived at projection
 

package/dist/skills/signify/skill.js.map

@@ -1 +1 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/signify/skill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAGhE,4CAA4C;AAC5C,EAAE;AACF,0GAA0G;AAC1G,gFAAgF;AAChF,qFAAqF;AACrF,mFAAmF;AACnF,sFAAsF;AACtF,+CAA+C;AAC/C,EAAE;AACF,kFAAkF;AAClF,iFAAiF;AACjF,iFAAiF;AACjF,qFAAqF;AACrF,sFAAsF;AACtF,oCAAoC;AAEpC,MAAM,CAAC,MAAM,OAAO,GAAU;IAC5B,IAAI,EAAE,SAAS;IACf,WAAW,EAAE,mNAAmN;IAChO,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAiDmC;IAChD,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;IACrB,QAAQ,EAAE,cAAc;CACzB,CAAC"}
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/signify/skill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAGhE,4CAA4C;AAC5C,EAAE;AACF,0GAA0G;AAC1G,gFAAgF;AAChF,qFAAqF;AACrF,mFAAmF;AACnF,sFAAsF;AACtF,+CAA+C;AAC/C,EAAE;AACF,kFAAkF;AAClF,iFAAiF;AACjF,iFAAiF;AACjF,qFAAqF;AACrF,sFAAsF;AACtF,oCAAoC;AAEpC,MAAM,CAAC,MAAM,OAAO,GAAU;IAC5B,IAAI,EAAE,SAAS;IACf,WAAW,EAAE,iRAAiR;IAC9R,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAiDmC;IAChD,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;IACrB,QAAQ,EAAE,cAAc;CACzB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cratylus/canon",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "description": "The canonical corpus of discovered optimal-signifiers — agents, skills, dimensions and rules as typed TS source. Markdown is a projection of these modules.",
   "license": "MIT",
   "engines": {
@@ -21,8 +21,8 @@
     "@cratylus/schema": "0.6.0"
   },
   "devDependencies": {
-    "@cratylus/forge": "0.11.3",
-    "@cratylus/runtime": "0.8.0",
+    "@cratylus/forge": "0.11.4",
+    "@cratylus/runtime": "0.8.1",
     "@cratylus/tooling": "0.0.0",
     "@types/node": "^22.0.0",
     "tsx": "^4.19.0",