@cratylus/canon 0.1.2 → 0.2.0

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.2",
+  "version": "0.2.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.5.0",
     "@cratylus/runtime": "0.2.0",
     "@cratylus/tooling": "0.0.0",
     "@types/node": "^22.0.0",

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

@@ -1,2 +0,0 @@
-export const checkIn = `check-in ⟨conclusion-first · owed ↦ recommendation-bearing-tail⟩`;
-//# sourceMappingURL=check-in.js.map

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,MAAM,CAAC,MAAM,OAAO,GAAa,kEAAkE,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/skills/praxis/skill.js

@@ -1,193 +0,0 @@
-// The plan-layout state canon (one home) — the `States` set below derives from it;
-// a project template sources its `planStates` from the same home (DRY). Lives in a
-// sibling module, not exported here: a skill module has exactly ONE export (its Skill).
-import { PLAN_STATES } from '../../plan-states.js';
-const FORMAL_BLOCK = `intent          ≜ the stated goal
-States          ≜ { ${PLAN_STATES.join(', ')} }
-P               ≜ a plan : a set of task-files
-content : P → text
-static  : P → ℘(path)
-constraints : P → ℘(invariant)
-outputs : P → ℘(artifact)
-inputs(t) ≜ static(t) ∪ { content(u) | (t, u) ∈ R }
-deps(t)   ≜ { u | (t, u) ∈ R }
-accept  : P → (return → 𝔹)
-pre     : P → return
-spec(t) ≜ ⟨ intent(t), inputs(t), constraints(t), deps(t), outputs(t), accept(t) ⟩
-census  : intent → ⟨scope, static, deps⟩
-executor : P ⇀ agent
-self     ≜ session⟨the harness's own session identity⟩
-owner   : P ⇀ session
-bound    : P → 𝔹 ⟨plan-level commitment · persists across sessions · ¬ shard-state⟩
-gates    : P × P → 𝔹
-electable ≜ { P ∈ Plans | ¬ terminal(P) ∧ ¬ occupied(P) }
-act      ≜ a thing the executor does
-serves   : act × P → 𝔹
-cost     : act → effort
-defect   ≜ ⟨symptom, locus, provenance⟩
-owns     : defect ⇀ P
-impedes  : defect × P → 𝔹
-refs     : P → ℘(path) ⟨what a shard's outputs compile against⟩
-sign     ≜ a name the corpus bears
-rewrites : P → ℘(sign) ⟨the signs t re-signifies⟩
-occurs   : sign → ℘(path) ⟨every site SPELLING it · the site DEFINING it is ONE of them⟩
-footprint : P → ℘(path) ⟨the paths landing t changed⟩
-origin   : P ⇀ P ⟨the shard t was CUT OUT of · borne by no plan datum⟩
-cross(S) ≜ |R ∩ ⋃ { sᵢ × sⱼ | sᵢ, sⱼ ∈ S ∧ i ≠ j }|
-admissible(S) ⇔ ∀ s ∈ S : 3 ≤ |s| ≤ 1.5 · |P| / |S| ⟨a slice under 3 is a label ¬ a lane · a slice far above the mean cannot be fanned out against its siblings · both bounds are COMPUTED from |P| ∵ a fixed pair encodes |P| at the moment someone wrote it down⟩
-swap(S,t,u) ≜ S with t and u exchanging slices
-dir      : P → path
-state   : P → States
-truth   : P → States
-R ⊆ P × P
-slices  : P → ℘(℘(P))
-mirror  : (state, R, content) → document
-PLAN.md ≜ mirror(state, R, content)
-depalimpsest(c) ≜ c ↾ live-strata
-conform @ signify
-Phase    ≜ { proposed, in-flight, landed, superseded, retired }
-Plans    ≜ { P | P a plan on disk }
-commit   ≜ a VCS commit
-commits  : P → ℘(commit)
-lands    : commit × P → 𝔹
-landing  : P ⇀ commit
-retires  : commit × P → 𝔹
-retirement : P ⇀ commit
-stored   : P → ℘(commit)
-retired  : P → 𝔹
-superseded : P → 𝔹
-terminal : P → 𝔹
-phase    : P → Phase
-
-blocked(t)  ⇔ ∃ u : (t, u) ∈ R ∧ state(u) ≠ completed
-ruling-owed(t) ⇔ a decision nobody has taken stands between t and its acceptance ⟨¬ a dep ∵ a dep is mechanical sequencing an executor can wait out⟩
-occupied(P) ⇔ owner(P) defined ∧ owner(P) ≠ self ⟨liveness is ¬ DECIDABLE here ∵ the owner is another session and no harness lets this one interrogate it · ∴ occupancy is read off the RECORD, ¬ off a registry⟩
-retires(c, P) ⇔ c deletes dir(P) ⟨the twin of lands · retirement is VCS-carried, ¬ residence-carried⟩
-retired(P)  ⇔ retirement(P) defined
-superseded(P) ⇔ .superseded-by @ dir(P)
-frontier(P) ≜ { t | t ∈ P ∧ state(t) ∈ { ready, active } } ⟨where the plan IS · ¬ only what is dispatchable⟩
-sharded(P)  ⇔ P ≠ ∅
-promote(u)  ≜ { t | (t, u) ∈ R ∧ state(t) = pending ∧ ¬blocked(t) ∧ ¬ruling-owed(t) }
-next        ≜ { pending ↦ ready, ready ↦ active, active ↦ completed, completed ↦ completed }
-W(n)        ≜ ⋃ { wave(i) | i <= n }
-wave(0)     ≜ { t | ∄ u : (t, u) ∈ R }
-wave(n+1)   ≜ { t | t ∉ W(n) ∧ ∀ u : (t, u) ∈ R ⇒ u ∈ W(n) }
-waves       ≜ (wave(0), wave(1), …)
-dispatched(P) ⇔ ∃ t ∈ P : state(t) ∈ { active, completed }
-done(P)       ⇔ ∀ t ∈ P : state(t) = completed
-landed(P)     ⇔ landing(P) defined ∧ frontier(P) = ∅ ∧ pending(P) = ∅ ∧ ¬ retired(P) ⟨landing is HISTORICAL ∧ monotone ; done is NOT absorbing ∴ landing alone reports a REOPENED plan as terminal, and terminal ⇒ retire is an OBLIGATION ∴ the readout demands retiring open work⟩
-terminal(P)   ⇔ landed(P) ∨ superseded(P)
-nextPhase     ≜ { proposed ↦ in-flight, in-flight ↦ landed, landed ↦ retired, superseded ↦ retired, retired ↦ retired }
-
-∀ t ∈ P : t @ dir(P)/state(t)
-owner(P) @ dir(P)/.owner
-owner(P) released @ unbind ∨ land ∨ retire ⟨an abandoned .owner reads as occupied until then · the cost is paid ONCE ∧ VISIBLY by an operator deleting a file they can see ≺ every session ∧ INVISIBLY by a registry swearing a dead pid was live⟩
-∀ t : content(t) ⊨ spec(t)
-∀ t : ∀ p ∈ static(t) : p exists at authoring
-∀ t : ∀ p ∈ outputs(t) : p exists ∨ the directory holding p exists ⟨a shard MAY create a file ∴ a non-resolving output is ¬ automatically a typo · the PARENT discriminates a creation target from a misspelling⟩
-∀ t : ∃ r : ¬accept(t)(r)
-∀ t : ¬accept(t)(pre(t))
-∀ t : accept(t)(pre(t)) ⇒ ¬(content(t) ⊨ spec(t))
-∀ t : content(t) grounded-by census(intent(t))
-∀ t : ¬(content(t) grounded-by census(intent(t))) ⇒ ¬(content(t) ⊨ spec(t))
-∀ t : census(intent(t)) delegable-to agent
-∀ t : measurement ∈ content(t) ⇒ measurement = claim⟨timestamp⟩ ∴ re-derive ≺ cite-as-evidence
-    ⟨a count in a shard is CENSUS OUTPUT, ¬ a datum · the tree moves under it ∧ nothing reds⟩
-    ⟨measured : one plan carried 413 ids ⟨irreproducible under 12 definitions⟩ · 192/413 ⟨ratio EXACT ∧ both absolutes wrong⟩ · 26 sites ⟨14 at HEAD⟩ · 53.5% reach ⟨36.7%⟩⟩
-    ⟨an exact RATIO over wrong ABSOLUTES = computed once ∧ remembered ∴ the tell⟩
-    ⟨∴ a shard reaching a NEGATIVE conclusion ⟨"unbuildable" · "nothing gates X"⟩ on quoted counts is unfalsified, ¬ established⟩
-∀ t : reach-leg(t) ⊨ print(denominator) ⟨∄ denominator ⇒ found-nothing ≡ could-not-look⟩
-state(t) = ready ⇒ ¬ blocked(t) ∧ ¬ ruling-owed(t) ⟨ready PROMISES an executor can pick t up and FINISH · conflating a dep with a ruling stalls a fan-out with every agent blocked on the same unanswered question⟩
-⋃ slices(P) = P
-∀ s₁, s₂ ∈ slices(P) : s₁ ≠ s₂ ⇒ s₁ ∩ s₂ = ∅
-admissible(slices(P)) ∧ ∄ t, u ∈ P : admissible(swap(slices(P),t,u)) ∧ cross(swap(slices(P),t,u)) < cross(slices(P))
-argmin over an UNNAMED admissible ⇒ unfalsifiable ∧ global argmin over every assignment ¬ decidable ∴ argmin ↾ LOCAL ⟨no admissible swap improves the cut · exhaustive ∧ deterministic⟩
-waves = (wave(0), …, wave(m))
-∀ n < m : |wave(n)| = 1 ⇒ slices mis-cut ⟨a singleton non-terminal wave is a chain, ¬ a cut⟩
-∀ t, u ∈ wave(n) : t ≠ u ⇒ outputs(t) ∩ outputs(u) = ∅ ⟨the concurrency precondition⟩
-∃ t, u ∈ wave(n) : t ≠ u ∧ outputs(t) ∩ outputs(u) ≠ ∅ ⇒ slices mis-cut
-∀ t, u ∈ wave(n) : t ≠ u ⇒ outputs(t) ∩ refs(u) = ∅ ⟨disjoint outputs is NECESSARY ¬ sufficient : a deletion in t dangles a reference in u⟩
-⊨ disjoint-outputs ⇒ dispatch(wave(n)) needs-no-isolation ⟨a correctly cut wave never contends⟩
-∀ t : footprint(t) ⊆ outputs(t) ⟨outputs IS the contention set ∴ an under-declared array silently voids every disjointness proof above · a shorter array is still an array of resolving globs⟩
-∀ t : ⋃ { occurs(s) | s ∈ rewrites(t) } ⊆ outputs(t) ⟨a shard's footprint is its REFERENCE set, ¬ its definition site · a rename touches every speller · giving a name its first home makes every existing spelling interpolate it · resolve occurs BEFORE declaring outputs⟩
-⟨measured 6 under-declared arrays across one plan, ONE cause ⟨footprint read off where a sign is DEFINED while the work was bounded by where it is USED⟩ · declared 1 glob and wrote 15 paths · 1 and 12 · 8 and 20⟩
-origin(t) defined ⇒ outputs(t) re-derived from rewrites(t) ⟨SPLITTING A SHARD DOES NOT SPLIT ITS BLAST RADIUS · the child's array is its own, ¬ the topical part of outputs(origin(t)) · so a split understates BY CONSTRUCTION, ¬ by oversight⟩
-∄ origin borne by any plan datum ⇒ ¬ gateable ∴ this law rides the CELL ⟨the seam nearest the defect is the only one left when the datum a check would need was never captured⟩
-(state, R, content) ≽ PLAN.md
-mirror(state, R, content) emits R ∧ waves
-depalimpsest(depalimpsest(c)) = depalimpsest(c)
-retired(P)                               ⇒ phase(P) = retired
-superseded(P) ∧ ¬ retired(P)             ⇒ phase(P) = superseded
-landed(P) ∧ ¬ superseded(P)              ⇒ phase(P) = landed
-dispatched(P) ∧ ¬ landed(P) ∧ ¬ superseded(P) ∧ ¬ retired(P) ⇒ phase(P) = in-flight
-¬ dispatched(P) ∧ ¬ superseded(P) ∧ ¬ retired(P) ⇒ phase(P) = proposed
-landing(P) = c ⇔ lands(c, P)
-retirement(P) = c ⇔ retires(c, P)
-∀ c, c' : lands(c, P) ∧ lands(c', P) ⇒ c = c'
-∀ c, c' : retires(c, P) ∧ retires(c', P) ⇒ c = c'
-retired(P) ⇒ P ∉ Plans ⟨retire removes the member · Plans is disk, ∴ phase reads the commit, ¬ a residence⟩
-∀ P : stored(P) = ∅ ⟨landing ∧ retirement alike : recomputed from VCS every call, written nowhere⟩
-list = Plans
-yield(P)  ≜ what EXECUTING P established ∧ ¬ derivable from intent(P) @ ENGINE ⟨enters as Intent, ¬ as a Sign : execution establishes what needs naming, ¬ the name⟩
-drained(y) ⇔ ∀ i ∈ y : i authored into its strongest seam ⟨gate ≻ cell ≻ governing-doc @ retire⟩ ∨ i filed as a canon-candidate ⟨¬ agent-private store : a private home is where the NEXT agent re-derives it⟩
-retire(P) defined ⇔ terminal(P) ∧ drained(yield(P))
-supersede(P, Q) ⇒ superseded(P)
-∀ t : conform(content(t))
-⊨ conform(PLAN.md)
-∀ t, r : ¬conform(r) ⇒ ¬accept(t)(r)
-
-bound(P) @ dir(P)/.bound ⟨persistent · survives session-end · ¬ derived from shard-state⟩
-∃ P ∈ Plans : ¬ terminal(P) ⇒ ∃! P : bound(P) ⟨always-bind ∧ WIP=1 · one law⟩
-bound(P) ⇒ ¬ occupied(P)
-bound(P) ∧ ¬ sharded(P) ⇒ start(P) ≺ dispatch(P) ⟨binding an unsharded plan obliges the cut⟩
-bound(P) ∧ sharded(P) ∧ ¬ done(P) ⇒ frontier(P) ≠ ∅ ⟨the ¬ done antecedent is LOAD-BEARING · dropped, the law reds a plan for FINISHING ∧ the cheapest green is filing work nobody needs⟩
-done(P) ⇒ frontier(P) = ∅ ⟨TAUTOLOGY ∵ frontier(P) ⊆ the open states · carries no content and is the first thing anyone writes here⟩
-done(P) ⇒ ∀ t ∈ P : t @ dir(P)/completed ⟨done is witnessed by RESIDENCE · a task-file that VANISHED empties frontier(P) exactly as finishing does, ∧ only residence tells the two apart⟩
-sharded(P) ∧ ¬ done(P) ∧ frontier(P) = ∅ ⇒ R ill-formed ⟨cycle ∨ unsatisfiable dep ∨ AN EDGELESS NODE⟩ · SURFACE
-    ⟨read the third disjunct FIRST : \`file\` writes its stub with ¬ census ∧ ¬ re-slice ∴ the filed t has NO edge in R, ∴ ∄ u : t ∈ promote(u), ∴ t is unreachable BY CONSTRUCTION ∧ it still counts against done(P)⟩
-    ⟨∴ any bound plan carrying a filed defect and no live shard reds this law, and the cause is the FILING, ¬ a cycle · only \`upsert\` gets it out · measured twice, in two plans, two weeks apart⟩
-gates(P, Q) ⇔ ∃ t ∈ Q : landing(P) ∈ deps(t)
-elect ≜ in-flight ≻ gating ≻ operator-intent ⟨lexicographic · finish before starting⟩
-terminal(P) ⇒ retire(P) ⟨obligation ¬ permission · an unretired terminal plan is WIP that is not work⟩
-yield(P) ≠ ∅ ∧ ¬ drained(yield(P)) ⇒ ¬ retire(P) ⟨ENGINE intake, realized HERE : deletion is where a law dies⟩
-    ⟨measured : 16 retired plans, 25 laws, 0 in the canon ∴ every anchor re-derived privately, per agent, forever⟩
-impedes(d, t) ⇔ d standing ⇒ ∄ r : accept(t)(r)
-impedes(d, t) ⇒ fix(d) ∧ ¬ check-in-owed ⟨a regression in the path is repaired, ¬ surfaced⟩
-¬ impedes(d, t) ⇒ file(owns(d), 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⟩
-dispatch(P) ∧ ¬ serves(a, P) ⇒ a ∈ { file, triage } ⟨scope-bound⟩
-advance ⊨ mirror ⟨state moves ∴ PLAN.md moves · drift is ¬ a later chore⟩
-
-start     : intent ↦ (P, slices(P), waves)
-upsert    : (P, intent) ↦ P' ≜ author census-grounded t(s) ∧ P' = P ∪ {t} ∧ re-slice ∧ re-mirror
-list      : ↦ ℘(P)
-elect     : ↦ P ≜ the ≻-greatest of electable ; pre electable ≠ ∅
-bind      : P ↦ P ≜ write .bound @ dir(P) ; pre ∀ Q ≠ P : ¬ bound(Q) ; post ∃! bound
-unbind    : P ↦ P ≜ remove .bound @ dir(P) ∧ remove .owner @ dir(P) ; pre done(P) ∨ terminal(P) ∨ operator-redirect
-file      : (P, d) ↦ P' ≜ stub t @ dir(P)/pending : ⟨symptom(d), locus(d), provenance(d)⟩ ;
-            ¬ census ∧ ¬ re-slice ∧ ¬ re-mirror ; post P' = P ∪ { t }
-triage    : d ↦ impedes(d, t) ⇒ fix(d) ; ¬ impedes(d, t) ⇒ file(owns(d), d)
-dispatch   ≜ ∀ t ∈ frontier(P) : state(t) = ready ⇒ concurrently ⟨ state(t) := active ∧ owner(P) := self ∧ executor(t) runs content(t) ⟩
-dispatch(P) ⇒ ¬occupied(P) ∧ bound(P)
-judge(t, r) ≜ accept(t)(r) ⇒ advance(t) ; ¬accept(t)(r) ⇒ r rejected back to executor(t), state(t) stays active
-              ⟨r lands VERBATIM ≺ any verdict on it : the loss mode is read-reason-discard, and it takes everything exactly when a run dies mid-judgement⟩
-              ⟨fan-in is as order-sensitive as fan-out : ∀ t dispatched in the wave, confirm executor(t) RETURNED ; outputs(t) exist ≠ executor(t) returned⟩
-advance(t) ≜ state(t) := next(state(t)) ; state(t) = completed ⇒ ∀ d ∈ promote(t) : state(d) := ready ;
-             PLAN.md := mirror(state, R, content)
-update(t)  ≜ content(t) := depalimpsest(content(t)) ; PLAN.md := mirror(state, R, content)
-merge     : { P₁, P₂, … } ↦ ⋃ Pᵢ
-sync       ≜ ∀ t ∈ P : state(t) ≠ truth(t) ⇒ state(t) := truth(t) ;
-             ∀ u ∈ P : ∀ d ∈ promote(u) : state(d) := ready ;
-             PLAN.md ≠ mirror(state, R, content) ⇒ PLAN.md := mirror(state, R, content)
-             post : state = truth ∧ PLAN.md = mirror(state, R, content)
-supersede : (P, Q) ↦ P ≜ write .superseded-by @ dir(P) := Q ⟨staged⟩ ; pre Q ∈ Plans ∧ Q ≠ P ; post superseded(P)
-retire    : P ↦ ⊥ ≜ delete dir(P) ; pre terminal(P) ∧ drained(yield(P)) ; post P ∉ Plans
-landingOf : P ↦ landing(P)
-retirementOf : P ↦ retirement(P)`;
-export const praxis = {
-    name: 'praxis',
-    description: `use this skill to create a plan decomposed into MECE execution shards, where each shard is a self-contained task execution specification with objective, inputs, constraints, dependencies, outputs, and completion criteria.`,
-    formalBlock: FORMAL_BLOCK,
-    composition: () => [],
-};
-//# sourceMappingURL=skill.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/praxis/skill.ts"],"names":[],"mappings":"AACA,mFAAmF;AACnF,mFAAmF;AACnF,wFAAwF;AACxF,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEnD,MAAM,YAAY,GAAG;sBACC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAoLQ,CAAC;AAErD,MAAM,CAAC,MAAM,MAAM,GAAU;IAC3B,IAAI,EAAE,QAAQ;IACd,WAAW,EAAE,+NAA+N;IAC5O,WAAW,EAAE,YAAY;IACzB,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;CACtB,CAAC"}