@cratylus/canon 0.1.3 → 0.3.0

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

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

package/dist/plan-states.d.ts

@@ -1,14 +1,14 @@
 /** 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
+ *  (`{ 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`
+ * A relation with no on-disk carrier is not readable — the reading `plan-set.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
@@ -16,7 +16,7 @@ export declare const PLAN_FRONTIER: readonly ["ready", "active"];
  *
  * `.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
+ * decision nobody has taken", which the retired praxis cell distinguished 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 —

package/dist/plan-states.js

@@ -1,14 +1,18 @@
 // 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,
+// lifecycle order. ONE home, two consumers (DRY): the `plan` skill's formal block
+// (`../skills/plan/skill.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 plan skill module — because a skill
+// module carries exactly one export (its `Skill`); this is the plan cell's canon,
 // factored out to a sibling both can source.
+//
+// The consumer was `praxis` until that cell was superseded by the design/plan/deliver
+// trio: praxis carried understanding, specification and governance in one place, and
+// the state set belongs to the middle term alone.
 /** 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
+ *  (`{ 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 = [
@@ -18,7 +22,7 @@ export const PLAN_FRONTIER = [
 /**
  * The plan-tier dotfile MARKERS whose only home is here.
  *
- * A relation with no on-disk carrier is not readable — the reading `praxis.sh`
+ * A relation with no on-disk carrier is not readable — the reading `plan-set.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
@@ -26,7 +30,7 @@ export const PLAN_FRONTIER = [
  *
  * `.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
+ * decision nobody has taken", which the retired praxis cell distinguished 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 —

package/dist/plan-states.js.map

@@ -1 +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"}
+{"version":3,"file":"plan-states.js","sourceRoot":"","sources":["../src/plan-states.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,kFAAkF;AAClF,kFAAkF;AAClF,mFAAmF;AACnF,iFAAiF;AACjF,kFAAkF;AAClF,6CAA6C;AAC7C,EAAE;AACF,sFAAsF;AACtF,qFAAqF;AACrF,kDAAkD;AAElD,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/skills/carry-on/skill.js

@@ -8,8 +8,8 @@
 // plan. "Carry on with what we just discussed" is the same utterance doing the same
 // work over a discussion, and a cell bound to `praxis` cannot serve it.
 //
-// The COMPOSITION is the operator's, at the utterance: "carry on with the praxis
-// execution" is carry-on ∘ praxis, and the pairing lives in what was said, not in
+// The COMPOSITION is the operator's, at the utterance: "carry on with the plan
+// execution" is carry-on ∘ plan, and the pairing lives in what was said, not in
 // this module's import list. A cell that names one context forecloses the rest.
 //
 // THE MECHANISM WENT WITH THE COUPLING, and that is a real loss recorded rather than

package/dist/skills/carry-on/skill.js.map

@@ -1 +1 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/carry-on/skill.ts"],"names":[],"mappings":"AAEA,mEAAmE;AACnE,EAAE;AACF,6EAA6E;AAC7E,oFAAoF;AACpF,kFAAkF;AAClF,qFAAqF;AACrF,mFAAmF;AACnF,oFAAoF;AACpF,wEAAwE;AACxE,EAAE;AACF,iFAAiF;AACjF,kFAAkF;AAClF,gFAAgF;AAChF,EAAE;AACF,qFAAqF;AACrF,qFAAqF;AACrF,kFAAkF;AAClF,sFAAsF;AACtF,kFAAkF;AAClF,oFAAoF;AACpF,mFAAmF;AACnF,2CAA2C;AAE3C,MAAM,eAAe,GACnB;;;;;;;;;;;;;;;;;;;;;CAqBkB,CAAC;AAErB,MAAM,CAAC,MAAM,OAAO,GAAU;IAC5B,IAAI,EAAE,UAAU;IAChB,WAAW,EAAE,woBAAwoB;IACrpB,WAAW,EAAE,eAAe;IAC5B,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;CACtB,CAAC"}
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/carry-on/skill.ts"],"names":[],"mappings":"AAEA,mEAAmE;AACnE,EAAE;AACF,6EAA6E;AAC7E,oFAAoF;AACpF,kFAAkF;AAClF,qFAAqF;AACrF,mFAAmF;AACnF,oFAAoF;AACpF,wEAAwE;AACxE,EAAE;AACF,+EAA+E;AAC/E,gFAAgF;AAChF,gFAAgF;AAChF,EAAE;AACF,qFAAqF;AACrF,qFAAqF;AACrF,kFAAkF;AAClF,sFAAsF;AACtF,kFAAkF;AAClF,oFAAoF;AACpF,mFAAmF;AACnF,2CAA2C;AAE3C,MAAM,eAAe,GACnB;;;;;;;;;;;;;;;;;;;;;CAqBkB,CAAC;AAErB,MAAM,CAAC,MAAM,OAAO,GAAU;IAC5B,IAAI,EAAE,UAAU;IAChB,WAAW,EAAE,woBAAwoB;IACrpB,WAAW,EAAE,eAAe;IAC5B,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;CACtB,CAAC"}

package/dist/skills/deliver/skill.d.ts

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

package/dist/skills/deliver/skill.js

@@ -0,0 +1,98 @@
+import { design } from '../design/skill.js';
+import { plan } from '../plan/skill.js';
+// WHERE THE TRUST DEFECT IS CLOSED. Acceptance keyed to a unit's own criteria is a
+// closed loop: the author writes the unit, writes its criteria, and checks the return
+// against them. Every term comes from one source, so an executor satisfying the letter
+// passes while the design goes unmet. Instructing the principal to "actually verify"
+// cannot repair this — verification is a TWO-DESCRIPTION operation, and with one
+// description there is no operation to perform, so it degenerates into re-reading the
+// claim. The second description is the design, which is why this cell composes it.
+//
+// The split that matters: the EXECUTOR verifies ⟨did I build it per the spec⟩ and the
+// PRINCIPAL validates ⟨is this what the design called for⟩. Both are legitimate and
+// neither substitutes. Today only the first exists in most loops.
+//
+// The three validation questions are cheap BY CONSTRUCTION, and that is load-bearing
+// rather than convenient: a check costing more than redoing the work is skipped, and
+// no instruction survives that gradient. Naming discipline is what buys the cheapness —
+// if the artifact spells its concept, two of the three are reading a name.
+const FORMAL_BLOCK = `C      @ design
+c      ≜ a concept ⟨c ∈ C⟩
+anchor @ design
+gloss  @ design
+factors @ design
+denotes @ design
+amend  @ design
+yield  ≜ what execution established ∧ ¬ derivable from C
+P      @ plan
+unit      ≜ a unit of work
+wave   @ plan
+frontier @ plan
+realizes @ plan
+accept @ plan ⟨the MECHANICAL half⟩
+outputs @ plan
+artifact : P → ℘(path) ⟨what landed · the EVIDENCE⟩
+r      ≜ an executor's return
+conform @ signify
+executor : P ⇀ agent
+self   ≜ the principal ⟨the design-holder⟩
+spells : path × anchor → 𝔹 ⟨identifiers · path · public surface bear the sign⟩
+covers : path × ℘(C) → 𝔹 ⟨observable behaviour ≅ the factorization · nothing missing
+         ∧ nothing extra⟩
+sole   : path × anchor → 𝔹 ⟨∄ other artifact realizing the same concept⟩
+verify : P × return → 𝔹 ⟨the EXECUTOR's · built-it-right, against spec⟩
+validate : P → 𝔹 ⟨the PRINCIPAL's · built-the-right-thing, against C⟩
+defect ≜ ⟨symptom, locus, provenance⟩
+impedes : defect × P → 𝔹
+cost   : act → effort
+bound  : P → 𝔹 ⟨plan-level commitment · persists across sessions⟩
+electable ≜ { P | ¬terminal(P) ∧ ¬occupied(P) }
+terminal : P → 𝔹
+commit @ design
+accepts @ design
+
+∀ unit, r : ¬conform(r) ⇒ ¬accept(unit)(r)
+validate(unit) ⇔ spells(artifact(unit), realizes(unit))
+    ∧ covers(artifact(unit), factors(denotes(realizes(unit))))
+    ∧ sole(artifact(unit), realizes(unit))
+validate ⊨ artifact ⟨NEVER r · a summary is a CLAIM ∧ the file is EVIDENCE ·
+    an acceptance that read only the return has accepted nothing⟩
+validate ⊨ self ⟨¬ delegable · the executor cannot judge its own conformance ∵ it
+    holds the spec ∧ ¬ the design⟩
+verify ⊥ validate ⟨two checks, two witnesses · neither substitutes ; an executor's
+    green suite proves the EXECUTOR's own assertion ∧ nothing about the design⟩
+judge(unit) ≜ verify(unit, r) ∧ validate(unit) ⇒ advance(unit) ; ¬ ⇒ r rejected back to
+    executor(unit) ∧ state(unit) stays active
+    ⟨r lands VERBATIM ≺ any verdict on it · the loss mode is read-reason-discard,
+     and it takes everything when a run dies mid-judgement⟩
+    ⟨fan-in is as order-sensitive as fan-out : ∀ unit dispatched, confirm executor(unit)
+     RETURNED · outputs(unit) exist ≠ executor(unit) returned⟩
+cost(validate) < cost(rebuild) ⟨else the gradient points at skipping · the cheapness
+    is BOUGHT by conform(anchor) ∴ naming discipline is the verification budget⟩
+¬spells ⇒ REFUSE ≺ any behavioural read ⟨the traceability arrow breaks at the cheapest
+    place it will ever be visible⟩
+¬covers ∧ extra ⇒ a second concept smuggled in unnamed ⇒ amend(C) ∨ REFUSE
+¬sole ⇒ duplication ⟨the observable signature of a vision that fragmented⟩
+dispatch(P) ≜ ∀ unit ∈ frontier(P) ⟨state(unit) = ready⟩ concurrently ⟨state(unit) := active ∧
+    executor(unit) runs spec(unit)⟩ ; pre bound(P) ∧ ⊨ disjoint-outputs
+yield ≠ ∅ ⇒ amend(C) @ design ⟨LIVE, ¬ at retirement⟩
+∀ k : amends(k, c) ⇒ ¬accepts(k) ⟨the amendment and the acceptance motivating it are
+    two commits · fused, the agent adjusts the concept its artifact failed ∧ declares
+    success ⟨evidence MANUFACTURED⟩⟩
+impedes(d, unit) ⇔ d standing ⇒ ∄ r : accept(unit)(r)
+impedes(d, unit) ⇒ fix(d) ⟨a regression in the path is repaired, ¬ surfaced⟩
+¬impedes(d, unit) ⇒ file(d) ∧ ¬fix(d) ⟨a defect BESIDE the path is filed, ¬ chased⟩
+cost(file) < cost(fix) ⟨else the gradient points at chasing · the load-bearing law⟩
+∃ P : ¬terminal(P) ⇒ ∃! P : bound(P) ⟨WIP = 1 · finish before starting⟩
+elect ≜ in-flight ≻ gating ≻ operator-intent ⟨lexicographic⟩
+terminal(P) ⇒ retire(P) ⟨obligation ¬ permission · an unretired terminal plan is WIP
+    that is not work⟩ ; C persists ⟨plans come ∧ go ABOVE the design⟩
+deliver ≜ bind → dispatch(wave) → verify ⟨executor⟩ → validate ⟨self, on artifact⟩ →
+    judge → amend(C) ⇔ yield → advance → retire`;
+export const deliver = {
+    name: 'deliver',
+    description: `use this skill to execute a plan and ACCEPT its results — dispatch a wave of units to executors, then validate each landed artifact against the design rather than against the executor's report, and integrate. Reach for it whenever delegated work comes back. Validation is three cheap questions — does the artifact spell its concept's name, does its behaviour cover that concept's factorization exactly, and does anything else already realize it — read off the files themselves, never off a summary. It also carries the conduct of the work: one plan bound at a time, finish before starting, repair what blocks the path and merely file what sits beside it.`,
+    formalBlock: FORMAL_BLOCK,
+    composition: () => [design, plan],
+};
+//# sourceMappingURL=skill.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/deliver/skill.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAExC,mFAAmF;AACnF,sFAAsF;AACtF,uFAAuF;AACvF,qFAAqF;AACrF,iFAAiF;AACjF,sFAAsF;AACtF,mFAAmF;AACnF,EAAE;AACF,sFAAsF;AACtF,oFAAoF;AACpF,kEAAkE;AAClE,EAAE;AACF,qFAAqF;AACrF,qFAAqF;AACrF,wFAAwF;AACxF,2EAA2E;AAE3E,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDAwE8C,CAAC;AAEpE,MAAM,CAAC,MAAM,OAAO,GAAU;IAC5B,IAAI,EAAE,SAAS;IACf,WAAW,EAAE,gpBAAgpB;IAC7pB,WAAW,EAAE,YAAY;IACzB,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,IAAI,CAAC;CAClC,CAAC"}

package/dist/skills/{praxis → design}/skill.d.ts

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

package/dist/skills/design/skill.js

@@ -0,0 +1,79 @@
+// THE DURATIVE HALF. `plan` and `deliver` are per-effort and disposable; this cell
+// is the one that persists, and that asymmetry is the whole point of the trio.
+//
+// It exists because the corpus could DO long-horizon work and could only THINK in
+// single sittings: every conceptual cell (conceptualize · signify · materialize ·
+// exemplify) is episodic — invoked on a source, emits a result, finishes — while the
+// planning cell alone bound, elected and persisted across sessions. So a project's
+// concepts were re-derived per session, per agent, forever. The superseded `praxis`
+// measured exactly that against itself: sixteen retired plans, twenty-five laws
+// established, zero surviving into any corpus.
+//
+// The second reason is verification. Acceptance keyed to a work-unit's own criteria
+// is a CLOSED loop — the unit is graded against its own account of itself, so an
+// executor 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
+gloss  ≜ what a concept IS ⟨one line · reconstruction-grade⟩
+C      ≜ the concept lattice ⟨the project's durative record⟩
+c      ≜ a concept ⟨c ∈ C⟩
+concept ≜ ⟨ anchor(c) , gloss(c) , factors(c) ⟩
+factors : C → ℘(C) ⟨what c decomposes into⟩
+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
+Piece  ≜ a cut piece ⟨what a planner is handed⟩
+cut    : C → ℘(℘(C))
+digest : ℘(C) → hash ⟨content address of a piece⟩
+pin    : Piece ⇀ hash ⟨the digest a piece was DERIVED from · carried with it⟩
+Phase  ≜ { live, superseded }
+phase  : C → Phase
+supersededBy : C ⇀ C
+commit ≜ a VCS commit ⟨the append-only carrier · attribution ∧ order⟩
+amends : commit × C → 𝔹
+accepts : commit → 𝔹 ⟨the commit carries an acceptance @ deliver⟩
+realizes : unit ⇀ anchor @ plan
+yield  ≜ what execution established ∧ ¬ derivable from C @ deliver
+self   ≜ the principal ⟨the design-holder · ¬ delegable⟩
+author : C ⇀ self
+
+∀ c : ∃! anchor(c) ∧ ∀ a ∈ dom(denotes) : ∃! denotes(a) ⟨one name ⇔ one concept⟩
+∀ c : conform(anchor(c)) ∧ gloss(c) ≠ ∅
+∀ c : closure(c) finite ⟨factors acyclic ∴ a lattice, ¬ a graph⟩
+amend(C) ≜ supersede ⟨∄ overwrite ; a live c is NEVER edited in place⟩
+    ⟨the protection is ¬ a rule about honesty : an editable lattice lets the agent
+     adjust the concept its artifact failed, ∴ acceptance-against-C goes CIRCULAR
+     with one extra step ∧ the loop manufactures its own evidence⟩
+supersede(c, c') ⇒ phase(c) := superseded ∧ supersededBy(c) = c' ∧ c ∈ C
+    ⟨residence, ¬ deletion : a reader of the CURRENT state sees the history without
+     a VCS query ∴ the lattice is self-describing⟩
+∀ k : amends(k, c) ⇒ ¬ accepts(k) ⟨THE separation · an amendment and an acceptance
+    it bears on are two acts ; fused, the second witness collapses into the first⟩
+∀ k : amends(k, c) ⇒ reason(k) ≠ ∅ ⟨attribution ∧ order are what make retroactive
+    justification DETECTABLE : the amendment postdates the artifact it excuses⟩
+blast(c) ≜ { d ∈ C | c ∈ closure(d) } ⟨DERIVED, ¬ guessed · what the normal form buys⟩
+churn(primitive) high ⇒ conceptualization wrong ⟨primitives near-stable · composites move⟩
+⋃ cut(C) = C ∧ ∀ s₁, s₂ ∈ cut(C) : s₁ ≠ s₂ ⇒ s₁ ∩ s₂ = ∅
+∀ s ∈ cut(C) : ∀ c ∈ s : closure(c) ⊆ s ⟨a piece is CLOSED ∴ plannable alone⟩
+cut ⊨ self ⟨the ASSIGNMENT of concepts to pieces is the design-holder's ; a planner
+    receiving a piece may ¬ redraw it · a boundary it cannot plan is SURFACED⟩
+∀ s ∈ cut(C) : pin(s) = digest(s) ⟨a piece carries the digest it was derived from ∴
+    an amendment mid-flight surfaces as DRIFT, ¬ executes silently⟩
+yield ≠ ∅ ⇒ amend(C) ⟨intake at INCEPTION ∧ live, never at retirement : an obligation
+    standing between an agent and closing its work always loses · measured 0 of 25⟩
+∀ c : ∄ unit ⟨realizes(unit) = anchor(c)⟩ ⇒ SURFACE ⟨a concept nothing builds is design agreed ∧
+    unbuilt · the reverse orphan is plan's⟩
+design ⊨ ¬ delegable ⟨a subagent starts blank ∧ a design authored by several
+    fragments BY CONSTRUCTION⟩
+design ≜ conceptualize(intent) → signify(·) → materialize(·) → C ⟨bind⟩ → 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 closed pieces a planner can take. Reach for it FIRST on any long-horizon effort, before any work is decomposed, and again whenever execution establishes something the model does not yet hold. It is what acceptance is judged against, so without it verification has no referent and degrades into re-reading the executor's own claim.`,
+    formalBlock: FORMAL_BLOCK,
+    composition: () => [],
+};
+//# sourceMappingURL=skill.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/design/skill.ts"],"names":[],"mappings":"AAEA,mFAAmF;AACnF,+EAA+E;AAC/E,EAAE;AACF,kFAAkF;AAClF,kFAAkF;AAClF,qFAAqF;AACrF,mFAAmF;AACnF,oFAAoF;AACpF,gFAAgF;AAChF,+CAA+C;AAC/C,EAAE;AACF,oFAAoF;AACpF,iFAAiF;AACjF,iFAAiF;AACjF,iFAAiF;AACjF,mFAAmF;AAEnF,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iFAuD+E,CAAC;AAErG,MAAM,CAAC,MAAM,MAAM,GAAU;IAC3B,IAAI,EAAE,QAAQ;IACd,WAAW,EAAE,uiBAAuiB;IACpjB,WAAW,EAAE,YAAY;IACzB,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;CACtB,CAAC"}

package/dist/skills/plan/skill.d.ts

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

package/dist/skills/plan/skill.js

@@ -0,0 +1,89 @@
+import { PLAN_STATES } from '../../plan-states.js';
+import { design } from '../design/skill.js';
+// SUPERSEDES `praxis`, which carried three activities with three different ends —
+// capturing understanding, specifying work, and governing execution — and no seam
+// between them. An agent asked to switch telos three times with nothing marking the
+// switch settles into whichever posture its last tool call left it in, which in a
+// tool-driven session is always the making. That is the drift, and it is structural
+// rather than a lapse of attention.
+//
+// What remains here is the middle term only: decomposition, dependency, waves, and
+// the plan's own lifecycle. Understanding moved to `design`; dispatch, judgement and
+// triage moved to `deliver`.
+//
+// The laws carried forward are the ones that were PAID FOR. The output-array law and
+// its measurement survive verbatim because the defect it names — a footprint read off
+// where a sign is DEFINED while the work is bounded by where it is USED — recurred six
+// times in one plan and voids every disjointness proof above it when it recurs.
+const FORMAL_BLOCK = `s      ≜ a cut piece ⟨closed · handed down · ¬ redrawable here⟩ @ design
+anchor @ design
+closure @ design
+pin    @ design
+digest @ design
+P      ≜ a plan : the units cutting s into work
+unit      ≜ a unit of work ⟨unit ∈ P⟩
+States ≜ { ${PLAN_STATES.join(', ')} }
+state  : P → States
+R      ⊆ P × P ⟨dependency⟩
+deps(unit) ≜ { u | (unit, u) ∈ R }
+realizes : P → anchor ⟨TOTAL⟩
+static : P → ℘(path)
+refs   : P → ℘(path) ⟨what unit's outputs compile against⟩
+outputs : P → ℘(path)
+footprint : P → ℘(path) ⟨what landing unit actually changed⟩
+occurs : anchor → ℘(path) ⟨every site SPELLING it · the site DEFINING it is ONE⟩
+accept : P → (return → 𝔹) ⟨MECHANICAL only · the semantic half is @ deliver⟩
+pre    : P → return
+spec(unit) ≜ ⟨ realizes(unit), intent(unit), static(unit), deps(unit), outputs(unit), accept(unit) ⟩
+census : intent → ⟨scope, static, deps, occurs⟩ ⟨delegable-to agent⟩
+slices : P → ℘(℘(P))
+cross(S) ≜ |R ∩ ⋃ { sᵢ × sⱼ | sᵢ, sⱼ ∈ S ∧ i ≠ j }|
+wave(0) ≜ { unit | ∄ u : (unit, u) ∈ R }
+wave(n+1) ≜ { unit | unit ∉ W(n) ∧ ∀ u : (unit, u) ∈ R ⇒ u ∈ W(n) }
+W(n)   ≜ ⋃ { wave(i) | i ≤ n }
+frontier(P) ≜ { unit | state(unit) ∈ { ready, active } } ⟨where the plan IS · ¬ only
+    what is dispatchable⟩
+blocked(unit) ⇔ ∃ u : (unit, u) ∈ R ∧ state(u) ≠ completed
+ruling-owed(unit) ⇔ a decision nobody has taken stands between unit and acceptance
+mirror : (state, R, spec) → document
+planner   ≜ the planner ⟨bounded to s⟩
+conform @ signify
+
+∀ unit : realizes(unit) ∈ { anchor(c) | c ∈ s } ⟨TOTALITY is the gate · a unit citing no
+    concept is work whose purpose cannot be stated ∴ REFUSED at authoring, ¬ warned⟩
+∀ unit : closure(denotes(realizes(unit))) ⊆ s ⟨a unit reaching outside its piece is a
+    BOUNDARY finding · SURFACE it ; the planner may ¬ redraw the cut⟩
+pin(s) ≠ digest(s) ⇒ REFUSE ⟨the design moved under the plan · drift, ¬ staleness⟩
+slices(P) cut on s ⟨¬ file-adjacency · files are a LAGGING proxy for modularity ∴
+    file-cut ⇒ ∀ unit ⊇ fragments of several c ⇒ executor finishes ∧ system incoherent⟩
+⋃ slices(P) = P ∧ ∀ s₁, s₂ ∈ slices(P) : s₁ ≠ s₂ ⇒ s₁ ∩ s₂ = ∅
+∄ swap improving cross(slices(P)) ⟨argmin ↾ LOCAL · exhaustive ∧ deterministic ;
+    a global argmin over every assignment is ¬ decidable⟩
+∀ n < m : |wave(n)| = 1 ⇒ slices mis-cut ⟨a singleton non-terminal wave is a CHAIN⟩
+∀ unit, u ∈ wave(n) : unit ≠ u ⇒ outputs(unit) ∩ outputs(u) = ∅ ⟨the concurrency precondition⟩
+∀ unit, u ∈ wave(n) : unit ≠ u ⇒ outputs(unit) ∩ refs(u) = ∅ ⟨disjoint outputs is NECESSARY
+    ¬ sufficient : a deletion in unit dangles a reference in u⟩
+⊨ disjoint-outputs ⇒ dispatch(wave(n)) needs-no-isolation
+∀ unit : footprint(unit) ⊆ outputs(unit) ⟨outputs IS the contention set ∴ an under-declared
+    array silently voids every disjointness proof above⟩
+∀ unit : occurs(realizes(unit)) ⊆ outputs(unit) ⟨a unit's footprint is its REFERENCE set, ¬ its
+    definition site · resolve occurs BEFORE declaring outputs⟩
+    ⟨measured 6 under-declared arrays in one plan, ONE cause · declared 1 glob and
+     wrote 15 paths · 1 and 12 · 8 and 20⟩
+∀ unit : ∃ r : ¬accept(unit)(r) ∧ ¬accept(unit)(pre(unit)) ⟨criteria that cannot FAIL, ∧ that
+    already pass before the work, test nothing⟩
+∀ unit : measurement ∈ spec(unit) ⇒ measurement = claim⟨timestamp⟩ ∴ re-derive ≺ cite
+    ⟨a count in a unit is CENSUS OUTPUT, ¬ a datum · the tree moves ∧ nothing reds⟩
+∀ unit : reach-leg(unit) ⊨ print(denominator) ⟨∄ denominator ⇒ found-nothing ≡ could-not-look⟩
+state(unit) = ready ⇒ ¬blocked(unit) ∧ ¬ruling-owed(unit) ⟨ready PROMISES an executor can
+    FINISH · conflating a dep with a ruling stalls a fan-out on one unanswered question⟩
+∀ unit : conform(spec(unit))
+advance ⊨ mirror ⟨state moves ∴ the document moves · drift is ¬ a later chore⟩
+plan ≜ take(s) → census ⟨delegable⟩ → slice(s) → author spec(∀ unit) → mirror → ratify @ planner`;
+export const plan = {
+    name: 'plan',
+    description: `use this skill to decompose ONE cut piece of a design into MECE units of work — each citing the single concept it realizes, with its inputs, dependencies, declared outputs and mechanical acceptance criteria — sliced on the design's seams rather than on file adjacency, and ordered into waves whose outputs are disjoint so they dispatch concurrently without contending. Reach for it after a design exists and before any work is dispatched. A unit that cites no concept is refused; a piece that cannot be planned as handed down is surfaced, never silently redrawn.`,
+    formalBlock: FORMAL_BLOCK,
+    composition: () => [design],
+};
+//# sourceMappingURL=skill.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/plan/skill.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAE5C,kFAAkF;AAClF,kFAAkF;AAClF,oFAAoF;AACpF,kFAAkF;AAClF,oFAAoF;AACpF,oCAAoC;AACpC,EAAE;AACF,mFAAmF;AACnF,qFAAqF;AACrF,6BAA6B;AAC7B,EAAE;AACF,qFAAqF;AACrF,sFAAsF;AACtF,uFAAuF;AACvF,gFAAgF;AAEhF,MAAM,YAAY,GAChB;;;;;;;aAOW,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iGAyDiF,CAAC;AAErH,MAAM,CAAC,MAAM,IAAI,GAAU;IACzB,IAAI,EAAE,MAAM;IACZ,WAAW,EAAE,ojBAAojB;IACjkB,WAAW,EAAE,YAAY;IACzB,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,MAAM,CAAC;CAC5B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cratylus/canon",
-  "version": "0.1.3",
+  "version": "0.3.0",
   "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": {
@@ -18,10 +18,10 @@
   ],
   "//test": "`test` builds FIRST because `test/runtime-shim.test.ts` drives the shipped `cratylus project` over the repository's own `cratylus.config.ts`, and that config extends `@cratylus/canon` — the PACKAGE, i.e. this package's `dist`. turbo's `test.dependsOn: [^build]` builds this package's DEPENDENCIES, never this package, so a cold clone would run the consumer path against a dist that does not exist.",
   "dependencies": {
-    "@cratylus/schema": "0.1.2"
+    "@cratylus/schema": "0.2.0"
   },
   "devDependencies": {
-    "@cratylus/forge": "0.4.1",
+    "@cratylus/forge": "0.6.0",
     "@cratylus/runtime": "0.2.0",
     "@cratylus/tooling": "0.0.0",
     "@types/node": "^22.0.0",
@@ -55,13 +55,10 @@
   "scripts": {
     "build": "pnpm run clean && tsc -p tsconfig.build.json",
     "clean": "rm -rf dist",
-    "continuity": "sh targets/continuity/continuity-hook.sh",
     "dev": "tsc -p tsconfig.build.json --watch --preserveWatchOutput",
-    "oracle": "sh tooling/render-oracle/render-oracle.sh check",
-    "oracle:update": "sh tooling/render-oracle/render-oracle.sh update",
     "pack:smoke": "tsx tooling/pack-smoke/pack-smoke-cli.ts",
     "plan-set": "tsx tooling/plan-set-cli.ts",
-    "praxis": "sh tooling/praxis/praxis.sh",
+    "plan": "sh tooling/plan-set/plan-set.sh",
     "project:targets": "tsx tooling/project-targets-cli.ts",
     "scaffold": "tsx tooling/scaffold-cli.ts",
     "stance-guard:test": "sh test/support/guardrail/test-stance-guardrail.sh",

package/dist/dimensions/autonomy/check-in.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"check-in.js","sourceRoot":"","sources":["../../../src/dimensions/autonomy/check-in.ts"],"names":[],"mappings":"AAEA,8EAA8E;AAC9E,6EAA6E;AAC7E,0CAA0C;AAC1C,EAAE;AACF,8EAA8E;AAC9E,2EAA2E;AAC3E,+EAA+E;AAC/E,gFAAgF;AAChF,8EAA8E;AAC9E,2DAA2D;AAC3D,EAAE;AACF,4EAA4E;AAC5E,2EAA2E;AAC3E,8EAA8E;AAC9E,4EAA4E;AAC5E,8EAA8E;AAC9E,6BAA6B;AAC7B,EAAE;AACF,iFAAiF;AACjF,2EAA2E;AAC3E,iFAAiF;AACjF,uEAAuE;AACvE,+EAA+E;AAC/E,+EAA+E;AAC/E,8EAA8E;AAC9E,6CAA6C;AAC7C,MAAM,CAAC,MAAM,OAAO,GAAa,oMAAoM,CAAC"}

package/dist/dimensions/output-format/structured-decision.d.ts

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

package/dist/dimensions/output-format/structured-decision.js

@@ -1,2 +0,0 @@
-export const structuredDecision = `structured-decision`;
-//# sourceMappingURL=structured-decision.js.map

package/dist/dimensions/output-format/structured-decision.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"structured-decision.js","sourceRoot":"","sources":["../../../src/dimensions/output-format/structured-decision.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,kBAAkB,GAAiB,qBAAqB,CAAC"}

package/dist/hooks/praxis-continuity.d.ts

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

package/dist/hooks/praxis-continuity.js

@@ -1,132 +0,0 @@
-// praxis-continuity — the repo-level post-commit reminder. A scope-activated source
-// cell on the GIT substrate: `vcs.commit.post` is an ordinary member of this
-// corpus's `CANONICAL_EVENTS` carrying `substrate: 'git'`, so it is routed rather
-// than refused — the `.husky/post-commit` dispatcher runs the committed worker
-// directly and nothing reaches `settings.json`. Its `workers[].content` are the
-// byte-anchors the committed `targets/continuity/` workers regenerate from
-// (byte-locked).
-//
-// THE REVIEW THIS CELL WAS FLAGGED FOR IS CLOSED. The note read "not in FORGE's
-// `CanonicalEvent` taxonomy" — stale by one package before it was stale by two, and
-// it asked for either an addition to the taxonomy or a named exception. Neither was
-// owed: the event was never exceptional, only unliterable, because the taxonomy was
-// a closed union in `schema` that a git moment had no member to be. The vocabulary
-// now lives where signification lives, `EventName` is open, and this cell names its
-// moment exactly as a harness cell names its own.
-export const praxisContinuity = {
-    id: 'praxis-continuity',
-    residue: 'post-commit detector ⟨task-file crosses state-folder ⇒ plan-mirror stale⟩ · nudge re-mirror · ¬edit · opt-in ↾ clone · exit-0 ⟨reminder ¬fail-commit⟩',
-    substrate: 'git',
-    events: ['vcs.commit.post'],
-    // git substrate: the entry is still named, never spelled as a path. Which
-    // directory git invokes it from is git's projection to make, not this cell's.
-    entry: 'praxis-advance-nudge.sh',
-    refs: [],
-    workers: [
-        {
-            filename: 'continuity-hook.sh',
-            targetPath: 'packages/canon/targets/continuity/continuity-hook.sh',
-            executable: true,
-            content: `#!/usr/bin/env sh
-# continuity-hook — opt this repo in/out of the post-commit continuity ritual.
-#
-# The opt-in flag is a per-repo git config (agentfactory.continuity) living in .git/config,
-# which is NOT checked in — so opting in is local to your clone and a fresh clone is
-# opted out by default. The .husky/post-commit dispatcher reads this flag.
-#
-#   pnpm run continuity:install     → set agentfactory.continuity true
-#   pnpm run continuity:uninstall   → unset (back to default off)
-#   pnpm run continuity:status      → show current state
-#
-# Usage:  continuity-hook.sh {install|uninstall|status}
-
-set -e
-
-cmd="\${1:-status}"
-
-case "$cmd" in
-install | on | true)
-	git config --bool agentfactory.continuity true
-	printf 'continuity: ENABLED for this repo (agentfactory.continuity=true).\\n'
-	printf '  Commits touching plans/**/{pending,ready,active,completed}/ now print a /praxis re-mirror reminder.\\n'
-	;;
-uninstall | off | false)
-	git config --unset agentfactory.continuity 2>/dev/null || true
-	printf 'continuity: DISABLED for this repo (agentfactory.continuity unset → default off).\\n'
-	;;
-status)
-	state=$(git config --bool agentfactory.continuity 2>/dev/null || echo "false")
-	printf 'continuity: %s (agentfactory.continuity=%s)\\n' \\
-		"$([ "$state" = "true" ] && echo ENABLED || echo "disabled (default)")" "$state"
-	;;
-*)
-	printf 'usage: continuity-hook.sh {install|uninstall|status}\\n' >&2
-	exit 2
-	;;
-esac
-`,
-        },
-        {
-            filename: 'praxis-advance-nudge.sh',
-            targetPath: 'packages/canon/targets/continuity/praxis-advance-nudge.sh',
-            executable: true,
-            content: `#!/usr/bin/env sh
-# praxis-advance-nudge — the repo-level continuity ritual, as a post-commit reminder.
-#
-# WHAT IT DOES (and deliberately does NOT do):
-#   When a commit moves plan task-files between their state folders
-#   (plans/**/{pending,ready,active,completed}/), PLAN.md — the hand-authored
-#   mirror of that folder-state — may now be stale. This script DETECTS that and
-#   PRINTS A REMINDER to re-mirror via /praxis. It never edits PLAN.md: the mirror
-#   is hand-authored prose; auto-rewriting it is out of scope (a future "mechanized
-#   PLAN.md generation" task). Detect → remind, never edit. (doc-mirrors-runtime-truth:
-#   the folders are the truth; this only flags that the mirror lagged.)
-#
-# SCOPE: praxis-advance is the ONE repo-level continuity ritual. Per-agent memory
-#   operations (the \`memory\` runtime capability's sidecar state under
-#   ~/.claude/agents/<name>/*) are not repo state — a git hook can't meaningfully
-#   fire them — so they are out of this hook's scope.
-#
-# OPT-IN: this runs only when \`git config --bool agentfactory.continuity\` is true. A fresh
-#   clone is opted out, so default commit behavior is unchanged. See continuity-hook.sh.
-#
-# POSIX sh; no deps beyond git. Exits 0 always — a reminder must never fail a commit.
-
-set -e
-
-# The commit just made (post-commit runs after HEAD has advanced).
-git rev-parse HEAD >/dev/null 2>&1 || exit 0
-
-# Files changed by HEAD. For a root commit (no parent) diff against the root.
-if git rev-parse --verify --quiet HEAD^ >/dev/null 2>&1; then
-	changed=$(git diff-tree --no-commit-id --name-only -r HEAD 2>/dev/null) || exit 0
-else
-	changed=$(git diff-tree --no-commit-id --name-only -r --root HEAD 2>/dev/null) || exit 0
-fi
-
-# Did this commit touch any plan state-folder? Match the four canonical states under
-# any plans/ subtree (works whether or not a tasks/ or {concern} wrapper is present).
-touched=$(printf '%s\\n' "$changed" \\
-	| grep -E '^plans/.*/(pending|ready|active|completed)/' || true)
-
-[ -z "$touched" ] && exit 0
-
-# Which plan dirs were touched (dedup to the plan root: plans/<plan>/).
-plans=$(printf '%s\\n' "$touched" \\
-	| sed -E 's#^(plans/[^/]+)/.*#\\1#' | sort -u)
-
-printf '\\n'
-printf 'continuity · praxis-advance — plan state changed in this commit:\\n'
-printf '%s\\n' "$plans" | sed 's/^/    /'
-printf '\\n'
-printf '  PLAN.md mirrors the task-folder state; it may now be stale.\\n'
-printf '  Re-mirror with /praxis (advance the task, re-sync PLAN.md), then amend or follow-up commit.\\n'
-printf '  (This is a reminder only — nothing was edited. Disable: pnpm run continuity:uninstall)\\n'
-printf '\\n'
-
-exit 0
-`,
-        },
-    ],
-};
-//# sourceMappingURL=praxis-continuity.js.map

package/dist/hooks/praxis-continuity.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"praxis-continuity.js","sourceRoot":"","sources":["../../src/hooks/praxis-continuity.ts"],"names":[],"mappings":"AAEA,oFAAoF;AACpF,6EAA6E;AAC7E,kFAAkF;AAClF,+EAA+E;AAC/E,gFAAgF;AAChF,2EAA2E;AAC3E,iBAAiB;AACjB,EAAE;AACF,gFAAgF;AAChF,oFAAoF;AACpF,oFAAoF;AACpF,oFAAoF;AACpF,mFAAmF;AACnF,oFAAoF;AACpF,kDAAkD;AAElD,MAAM,CAAC,MAAM,gBAAgB,GAAa;IACxC,EAAE,EAAE,mBAAmB;IACvB,OAAO,EACL,uJAAuJ;IACzJ,SAAS,EAAE,KAAK;IAChB,MAAM,EAAE,CAAC,iBAAiB,CAAC;IAC3B,0EAA0E;IAC1E,8EAA8E;IAC9E,KAAK,EAAE,yBAAyB;IAChC,IAAI,EAAE,EAAE;IACR,OAAO,EAAE;QACP;YACE,QAAQ,EAAE,oBAAoB;YAC9B,UAAU,EAAE,sDAAsD;YAClE,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCd;SACI;QACD;YACE,QAAQ,EAAE,yBAAyB;YACnC,UAAU,EAAE,2DAA2D;YACvE,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuDd;SACI;KACF;CACF,CAAC"}