@cratylus/canon 0.1.0

package/dist/skills/praxis/skill.js

@@ -0,0 +1,196 @@
+// 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⟨AGENT_SESSION_ID⟩
+registered, released, stale : session → 𝔹
+live     : session → 𝔹
+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⟩
+live(s)     ⇔ registered(s) ∧ ¬ released(s) ∧ ¬ stale(s)
+occupied(P) ⇔ owner(P) defined ∧ owner(P) ≠ self ∧ live(owner(P))
+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
+registered, released, stale @ memory-session-registry
+∀ 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 @ dream⟩ ∨ i filed as a canon-candidate ⟨¬ agent-private memory : 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) ; 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

@@ -0,0 +1 @@
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAuLQ,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"}

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

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

package/dist/skills/probe/skill.js

@@ -0,0 +1,58 @@
+import { conceptualize } from '../conceptualize/skill.js';
+import { elicit } from '../elicit/skill.js';
+import { signify } from '../signify/skill.js';
+const FORMAL_BLOCK = `D    ≜ distinction space ⟨structured knowledge to draw on⟩
+cl   ≜ closure ⟨smallest concept containing a set of priors⟩
+C    ≜ concept lattice ⟨the cl-closed subsets of D⟩
+priors(w) ≜ understanding w carries before any definition ⟨associations · connotations · structured-knowledge unpacked from the token alone, not its surface wording⟩
+Names  ≜ the readable signifiers
+dec  : Names ⇀ ℘(D) @ signify
+σ*     @ signify
+w      ≜ a signifier under probe ⟨w ∈ Names⟩
+c      ≜ a target concept ⟨c ∈ C⟩
+W(c)   ≜ experiment's finite candidate set for target c ⟨W(c) ⊆ Names⟩
+probe : Names → ℘(D) × C
+K @ cold-decode-oracle
+frame  ≜ the elicitation's obligation-shape ⟨produce-a-candidate ∨ licenced-to-refuse⟩
+parts(w) ≜ constituents(w) ∪ { w } ∪ permutations(w) ⟨word-order variants of a compound⟩
+Idiom  ⊆ Names ⟨an established reading that PREEMPTS the compositional one⟩
+head(w) · mod(w) ≜ w's head ∧ its modifier ⟨compound w⟩
+free(h)  ⇔ h alone is unbound in the corpus
+fired : Names → ℘(D)
+fired(w) ≜ priors(w)
+fired(a) = dec(a) , a ∈ dom(dec)
+concept(w) ≜ cl(fired(w))
+probe(w) ≜ ⟨ fired(w) · concept(w) ⟩ ⟨w ALONE : ∄ sibling · ∄ menu · open question⟩
+probe(w) ↾ W ≜ w read amid W ⟨the distractors' priors leak into the read ⇒ CONTRAST, ¬ priors(w)⟩
+experiment(c) ≜ { w ∈ W(c) | concept(w) ↾ W(c) = c } ⊨ DIAGNOSTIC ⟨narrows W(c) ; ¬ decides σ*⟩
+coverage : { w ∈ Names | fired(w) ≠ ∅ ∧ concept(w) = c } ⊆ W(c)
+crystallize : σ*(c) = w ⇔ w ∈ experiment(c) ∧ concept(w) = c
+              ⟨∈ experiment NECESSARY ¬ SUFFICIENT ; llm-native ¬leading-candidate-set binds the decision to probe(w)⟩
+
+probe(w | K) ≜ probe(w) taken at K ⟨probe is MEASURED, ¬ read-off : a FAMILY over K, ¬ one value⟩
+probe(w | ∅) ⊨ self-sufficiency ⟨cold : does w circumscribe carrying ZERO corpus?⟩
+probe(w | K_reader) ⊨ what w fires IN SITU ⟨the reading that binds at use⟩
+{ d ∈ fired(w) ↾ K_reader | d ∉ fired(w) ↾ ∅ } ⊨ THE measurement
+    ⟨both poles REQUIRED ; a cold read is a CONTROL, never a substitute for the in-situ one⟩
+K(spawned-subagent) ⊇ deployed-corpus ∴ ¬cold ⟨it holds project memory · commit subjects · skill bodies⟩
+    ∴ agreement( probe(w | K ⊇ corpus) , the corpus ) ⊨ ∅ ⟨it READ the answer⟩
+cold ⇔ process-isolation ⟨¬ a fresh subagent ; ¬ a stripped prompt⟩
+
+frame = produce-a-candidate ⇒ ∄ observable ∅ ⟨an obliged producer ALWAYS emits⟩
+    ∴ licence-the-negative : vary the FRAME across runs, ¬ the prompt ⟨fired(w) = ∅ ∧ ∄ σ*(c) are RESULTS⟩
+¬controlled(probe) ⇒ over-detection INVISIBLE ⟨a spurious constraint reads as caution⟩
+    ∀ k imposed by a failing read : a passing read under a varied frame RETRACTS k
+
+fired(w) ⊨ sweep(parts(w)) vs Idiom ⟨the WINNER swept, ¬ only the rejects⟩
+free(head(w)) ⇒ fired(w) ⊇ fired(mod(w)) ⟨an unbound head takes the modifier's priors through it⟩
+
+∀ w ∈ W(c) : probe(w) ↦ evidence about c ⟨harvest-the-rejects : concept(w) of a REJECTED w constrains D(c)⟩
+W(c) seeded from the ARTIFACT ⟨invoked verb · declared inverse · deferred-to cell⟩ ≺ minted candidates
+    ⟨a real concept's sign is FOUND ; mint is the LAST resort, ¬ the first⟩`;
+export const probe = {
+    name: 'probe',
+    description: `use this skill to probe a signifier — read out the priors a word, phrase, or candidate name fires in the reader (\`fired\`, signify's decoder \`dec\` generalized off its assigned anchors) and the concept they circumscribe; the forward, no-commit inverse of signify, for discovering the concept latent in a name or experimenting with candidate anchors before committing — a keeper crystallizes through signify.`,
+    formalBlock: FORMAL_BLOCK,
+    composition: () => [signify, elicit, conceptualize],
+};
+//# sourceMappingURL=skill.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/probe/skill.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAE9C,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4EA+C0E,CAAC;AAEhG,MAAM,CAAC,MAAM,KAAK,GAAU;IAC1B,IAAI,EAAE,OAAO;IACb,WAAW,EAAE,2ZAA2Z;IACxa,WAAW,EAAE,YAAY;IACzB,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,CAAC;CACpD,CAAC"}

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

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

package/dist/skills/signify/skill.js

@@ -0,0 +1,59 @@
+import { conceptualize } from '../conceptualize/skill.js';
+import { exemplify } from '../exemplify/skill.js';
+import { materialize } from '../materialize/skill.js';
+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.`,
+    formalBlock: `C           ≜ the concept lattice
+D           ≜ the identity-criterion atoms a concept circumscribes
+prim(c)     ≜ c has no factorization into other concepts
+Names       ≜ the shared symbol space
+<_lex       : total order on Names
+concept-record ≜ ⟨gloss, anchor, factorization⟩
+fired       : Names → ℘(D)
+dec         : Names ⇀ ℘(D)
+circ(n,c)   ⇔ fired(n) = D(c)
+|n|         ≜ LLM-native description-length
+σ*          : C → Names
+σ*(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⟩
+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
+
+∀ c ∈ dom(α) : α(c) ≜ σ*(c)
+Anchors ≜ { α(c) | c ∈ dom(α) } ⟨the assigned-anchor set⟩
+dom(dec) = { α(p) | prim(p) } ;  dec(α(p)) = fired(α(p))
+{ n : circ(n,c) } = ∅ ⇒ σ*(c) = mint(c)
+
+name(k)  fills  anchor(k) ≜ α(gloss(k)) ;  gloss(k) preserved ;  factorization(k) untouched
+
+α(cᵢ) = α(cⱼ) ⇒ D(cᵢ) = D(cⱼ)
+
+coalesce(cᵢ, cⱼ)  ⇔  α(cᵢ) = α(cⱼ) ∧ D(cᵢ) = D(cⱼ)
+cᵢ <_N cⱼ  ⇔  α(cᵢ) <_lex α(cⱼ)
+≺ ≜ shortlex over (C, <_N)
+
+c ∉ dom(α) ⇒ c ∉ Anchors :
+    { n : circ(n,c) } = ∅ ∧ ∄ mint(c) ⇒ exclude, logged
+    ∃ cᵢ, cⱼ : α(cᵢ) = α(cⱼ) ∧ D(cᵢ) ≠ D(cⱼ) ⇒ the cut was wrong ↦ conceptualize
+        ⟨α(cᵢ), α(cⱼ) taken at DIFFERENT altitudes is still this collision⟩
+
+∃ d : { n : ¬circ(n,c) } all fail on d ALONE ⇒ d ∉ D(c) ∧ ∃ cᵢ ≠ c : d ∈ D(cᵢ) ⟨the property hangs off the wrong noun⟩
+    ↦ conceptualize ⟨re-cut, then cᵢ names EASILY ; a losing STREAK on one d proves misattribution, ¬ that σ*(c) is scarce⟩
+
+¬circ(n, cᵢ) ⇒ evidence about fired(n), ¬ about cᵢ ⟨fired : Names → ℘(D) reads n ALONE⟩
+    ∴ a rejection BINDS n ⟨n freed from cᵢ is ¬ thereby fit for cⱼ ; circ(n, cⱼ) re-established independently ∨ n stays rejected⟩
+
+residue(c) ≜ { d ∈ D(c) | d ∉ fired(α(c)) }
+∀ a ∈ Art : ∀ c carried by a : c enters a's body as ⟨α(c), residue(c)⟩
+residue(c) = ∅ ⇒ c enters as α(c) alone
+minimal(a) ⇔ ∄ c carried by a : a re-states fired(α(c))
+
+conform(a)  ⇔  register(a) = σ*
+verbatim(a) ⇒ register(a) = σ*`,
+    composition: () => [exemplify, conceptualize, materialize],
+};
+//# sourceMappingURL=skill.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/signify/skill.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAEtD,MAAM,CAAC,MAAM,OAAO,GAAU;IAC5B,IAAI,EAAE,SAAS;IACf,WAAW,EAAE,mNAAmN;IAChO,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAiDmC;IAChD,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,SAAS,EAAE,aAAa,EAAE,WAAW,CAAC;CAC3D,CAAC"}

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

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

package/dist/skills/wake/skill.js

@@ -0,0 +1,43 @@
+import { dream } from '../dream/skill.js';
+import { praxis } from '../praxis/skill.js';
+const WAKE_BLOCK = `WAKE ≜ begin → catch-up → load → orient → resume
+
+agent       ≜ this agent's name
+memory      ≜ capability ⟨strategy-encapsulated : where it stores · in what format · how it scopes · what it migrates are ITS concern, ¬ this protocol's⟩ ⟨invoked \`memory <verb> <args>\` ; the Runtime-capability line under this block resolves the shim ∴ ¬ path-in-cell⟩
+ground      ≜ project/{ VISION · MODEL · ENGINE · CANON } · PLAN.md(bound)
+salient     ≜ { decision⟨+rationale⟩ · surprise · error|failure · fact-learned · thread⟨opened|closed⟩ }
+P           ≜ a plan : a set of task-files
+bound, occupied, electable, elect, bind, frontier @ praxis ⟨plan-set dynamics has ONE home · ¬ redeclared here · a borrowed operation carries its PRECONDITION or it is not the same operation⟩
+mandate     ≜ the objective this session serves ⟨operator-owned · ¬ agent-elected⟩
+
+begin    ≜ \`memory session begin --name <agent>\` ↦ ⟨session · SEMANTIC · PROCEDURAL · EPISODIC · consolidation-owed⟩
+catch-up ≜ consolidation-owed ⇒ REPORT(owed) ∧ proceed ⟨READ the state · ¬ discharge it⟩
+           ⟨¬ dream @ wake : the prior law made dream ≺ proceed ∴ a session paid for a BACKLOG before doing any work · encode ↾ per-turn ∧ threshold = 12 ⇒ that is most sessions⟩
+           ⟨SILENCE ≻ worse than the block it replaces : an invisible backlog is how 8 of 10 agent homes reached a first session with ∄ past⟩
+load     ≜ SEMANTIC ∪ PROCEDURAL whole ∧ EPISODIC as returned ⟨scoped by the strategy, ¬ by this protocol⟩
+orient   ≜ read ground ≺ ( bind(P) ∧ bind(work-thread) )
+resume   ≜ rebind(continuity-thread) ∴ act-as(same-individual)
+encode   ≜ standing-duty ↾ per-turn ; ∀ e ∈ salient : \`memory encode --name <agent> --body '<open record>'\`
+
+bound(P) ∧ ¬ occupied(P) ⇒ bind(P)
+bound(P) ∧ occupied(P)   ⇒ REPORT(P) ∧ fall-through(next-candidate)
+plan-state ≜ \`praxis status\` ⟨the instrument COMPUTES the law · scanning for .bound re-derives it, and re-derivation is where the guard is lost⟩
+electable ≠ ∅ ∧ ∄ P : bound(P) ⇒ bind(elect) ⟨always-bind @ praxis · the ∃P∈Plans:¬terminal(P) antecedent IS the guard ∴ it rides the call⟩
+electable = ∅            ⇒ REPORT(vacuous) ∧ HALT ∧ mandate-owed
+                           ⟨the empty plan set is a TERMINAL wake-state, ¬ a vacuum to fill · orientation is COMPLETE and unbound · \`praxis status\` already prints "none is owed" ∴ SAY IT and stop⟩
+                           ⟨minting to discharge a debt praxis never issued IS the drift · a law that reds an agent for FINISHING makes inventing work the cheapest green⟩
+mandate-owed ⇒ surface ⟨WHAT, ¬ HOW · ∄ mandate ⇒ electing one is the OPERATOR's act · intent-recovery @ elicit, ¬ in-remit sequencing⟩ ∧ carry(recommendation)
+orient ⊨ (∃! bound) ⊻ (electable = ∅ ∧ mandate-owed) ⟨the second disjunct is a LEGITIMATE terminus · without it the first is unsatisfiable from ∅ ∧ only invention discharges it⟩
+unfamiliar(cwd)           ⇒ fresh-orientation
+recording ≜ tool-call ∧ recording ≠ hand-appended-markdown
+¬ encoded ⇒ ¬ consolidatable
+wake-read ⊨ next-action ⟨bias⟩
+resume ⊨ encode`;
+export const wake = {
+    name: 'wake',
+    description: `use this skill to reconstitute an agent at session start — run the WAKE sequence (dream → load → orient → resume) so it resumes as the same individual; the read-and-resume counterpart to /dream, invocable as /wake.`,
+    formalBlock: WAKE_BLOCK,
+    runtime: { capability: 'memory' },
+    composition: () => [dream, praxis],
+};
+//# sourceMappingURL=skill.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/wake/skill.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAC1C,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAE5C,MAAM,UAAU,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAgCgB,CAAC;AAEpC,MAAM,CAAC,MAAM,IAAI,GAAU;IACzB,IAAI,EAAE,MAAM;IACZ,WAAW,EAAE,wNAAwN;IACrO,WAAW,EAAE,UAAU;IACvB,OAAO,EAAE,EAAE,UAAU,EAAE,QAAQ,EAAE;IACjC,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,CAAC;CACnC,CAAC"}

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@cratylus/canon",
+  "version": "0.1.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": {
+    "node": ">=22"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "//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"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0",
+    "vitest": "^2.1.0",
+    "@cratylus/forge": "0.2.0",
+    "@cratylus/tooling": "0.0.0",
+    "@cratylus/runtime": "0.2.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "latent-lexicography",
+    "cratylus",
+    "canon",
+    "agent",
+    "skill",
+    "prompt",
+    "llm",
+    "semantic-address"
+  ],
+  "author": "Lance Caraccioli <lance.caraccioli@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/leclabs/cratylus.git",
+    "directory": "packages/canon"
+  },
+  "bugs": {
+    "url": "https://github.com/leclabs/cratylus/issues"
+  },
+  "homepage": "https://github.com/leclabs/cratylus#readme",
+  "scripts": {
+    "build": "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",
+    "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",
+    "test": "pnpm run build && vitest run",
+    "typecheck": "tsc --noEmit",
+    "typecheck:test": "tsc -p tsconfig.test.json"
+  }
+}