@cratylus/canon 0.1.0

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

@@ -0,0 +1,56 @@
+// The plan vocabulary this cell PROJECTS onto the capability's command line. It is
+// canon's, sourced from its one home — the runtime depends on nothing and holds no
+// plan layout, so the names travel as configuration on the invocation rather than
+// as a second copy inside `@cratylus/runtime` (ARCHITECTURE property 4).
+import { PLAN_FRONTIER, PLAN_MARKERS, PLAN_STATES } from '../../plan-states.js';
+import { praxis } from '../praxis/skill.js';
+/** The terminal state — the last of the lifecycle, never a second literal. */
+const COMPLETED = PLAN_STATES[PLAN_STATES.length - 1];
+/** The projected configuration, verbatim as `elevate` takes it. */
+const LAYOUT = `--plan-root <plans/> --states ${PLAN_STATES.join(',')} --completed ${COMPLETED} ` +
+    `--frontier ${PLAN_FRONTIER.join(',')} --bound-marker ${PLAN_MARKERS.bound} ` +
+    `--ruling-owed-marker ${PLAN_MARKERS.rulingOwed}`;
+const carryOnNotation = `carry-on ≜ re-dispatch-word ↦ elevate · persist · revert
+re-dispatch-word ≜ weitermachen ∨ carry-on ∨ proceed
+verb      ∈ { elevate · revert · terminus · status } ⟨runtime-bound ; each reached as \`scripts/carryOn.mjs <verb>\`⟩
+loop-position ∈ { on-the-loop, out-of-the-loop }   ⟨live session state, ¬ a static value⟩
+resting   ≜ loop-position = on-the-loop   ⟨a session opens in orientation · intent is the operator's to set⟩
+P         ≜ the bound praxis ⟨∨ the standing intent, absent one⟩
+bound, done, sharded, frontier, dir, triage, file, defect, impedes @ praxis
+target, target₀, foreign, attached ⟨the same hook-config artifact, gated here rather than tapped⟩ @ event-tap
+layout    ≜ ${LAYOUT}
+            ⟨canon's plan vocabulary, projected onto the command line · the runtime knows no plan⟩
+ruling-owed(P) ⇔ ${PLAN_MARKERS.rulingOwed} @ dir(P) ⟨the carrier of fork⊥ · content = the fork as put to the operator · stored ∵ ¬ derivable, exactly as ${PLAN_MARKERS.bound} is⟩
+fork⊥     ≜ fork(irreversible · value · competence) the principal cannot resolve
+terminus  ⇔ ¬∃P: bound(P) ∨ ruling-owed(P) ∨ done(P) ∨ (sharded(P) ∧ ¬ done(P) ∧ frontier(P) = ∅)
+regression ≜ defect d : impedes(d, t) for the shard t in hand
+elevate   ≜ \`scripts/carryOn.mjs elevate --event turn.end <layout>\` ∴ attached(target) ∧ loop-position := out-of-the-loop ∧ bind(P)
+            ⟨attached ⇒ the harness runs \`scripts/carryOn.mjs terminus\` at every turn-end and refuses the close while ¬ terminus⟩
+revert    ≜ \`scripts/carryOn.mjs revert\` ∴ ¬ attached(target) ∧ loop-position := resting
+status    ≜ \`scripts/carryOn.mjs status\` ↦ ⟨attached(target), terminus⟩
+
+check-in-close ∧ re-dispatch-word ⇒ elevate
+elevate ⇒ standing-intent unchanged ∧ ¬fresh-dispatch ∧ ¬permission-grant
+elevate ⇒ resume execution ⟨own judgment · reversible-in-domain decided · no fresh permission owed⟩
+elevate defined ⇔ ¬ terminus ⟨at a terminus there is nothing to stay out of the loop FOR⟩
+elevate ⊨ attached(target) read back @ target ; ¬ attached ⇒ ⊥ ⟨loud ∧ ¬ elevation reported : text is advisory, a mechanism is not⟩
+attached(target) ∧ ¬ terminus ⇒ turn ¬ end ⟨the mechanism refuses ; the assertion never could⟩
+bind(P) ∧ ¬ terminus ⇒ persist ⟨∀ turn · ¬ per-turn-decay⟩
+terminus ⇒ revert ∴ loop-position = resting
+revert ∘ elevate ⊨ target ≡ target₀ ∧ foreign preserved ⟨zero residue⟩
+elevate ⊨ revert owed ⟨an un-reverted elevation outlives the plan it was bound to⟩
+terminus ≜ derived @ disk ⟨∴ a fresh process reads the same truth · ∄ read(transcript ∨ message) ∴ ∄ misfire on mid-turn narration⟩
+fork⊥ ⇒ write ${PLAN_MARKERS.rulingOwed} @ dir(P) ∧ surface the fork ∧ re-enter on-the-loop ⟨a fork surfaced without its carrier is unreadable at turn-end⟩
+sharded(P) ∧ ¬ done(P) ∧ frontier(P) = ∅ ⇒ terminus ∧ SURFACE ⟨R ill-formed ⟨cycle ∨ unsatisfiable dep⟩ · else the mis-cut wedges the session⟩
+regression ⇒ fix ∧ ¬check-in ⟨repair in the path is execution, ¬ a new fork⟩
+defect ∧ ¬regression ⇒ file ∧ ¬fix ⟨out-of-path defects are recorded, ¬ chased⟩
+verb ∉ { elevate · revert · terminus · status } ⇒ ⊥ ⟨loud⟩
+`;
+export const carryOn = {
+    name: 'carry-on',
+    description: `use this skill when the Operator utters the re-dispatch word (weitermachen · carry on · proceed) — closing a check-in and returning you to autonomous execution under re-affirmed authority; elevate installs the turn-end gate that holds the elevation (an assertion in prose is advisory, a gate is not), the elevation persists across turns bound to the bound praxis, and it lifts only at a terminus read from plan state on disk — the plan is done, a ruling is owed, or the cut is ill-formed — whereupon revert removes the gate with zero residue.`,
+    formalBlock: carryOnNotation,
+    runtime: { capability: 'carryOn' },
+    composition: () => [praxis],
+};
+//# sourceMappingURL=skill.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/carry-on/skill.ts"],"names":[],"mappings":"AACA,mFAAmF;AACnF,mFAAmF;AACnF,kFAAkF;AAClF,yEAAyE;AACzE,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAChF,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAE5C,8EAA8E;AAC9E,MAAM,SAAS,GAAG,WAAW,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;AAEtD,mEAAmE;AACnE,MAAM,MAAM,GACV,iCAAiC,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,gBAAgB,SAAS,GAAG;IAClF,cAAc,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,mBAAmB,YAAY,CAAC,KAAK,GAAG;IAC7E,wBAAwB,YAAY,CAAC,UAAU,EAAE,CAAC;AAEpD,MAAM,eAAe,GACnB;;;;;;;;cAQY,MAAM;;mBAED,YAAY,CAAC,UAAU,kHAAkH,YAAY,CAAC,KAAK;;;;;;;;;;;;;;;;;;;;gBAoB9J,YAAY,CAAC,UAAU;;;;;CAKnB,CAAC;AAErB,MAAM,CAAC,MAAM,OAAO,GAAU;IAC5B,IAAI,EAAE,UAAU;IAChB,WAAW,EAAE,giBAAgiB;IAC7iB,WAAW,EAAE,eAAe;IAC5B,OAAO,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE;IAClC,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,MAAM,CAAC;CAC5B,CAAC"}

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

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

package/dist/skills/conceptualize/skill.js

@@ -0,0 +1,34 @@
+import { exemplify } from '../exemplify/skill.js';
+import { materialize } from '../materialize/skill.js';
+import { signify } from '../signify/skill.js';
+export const conceptualize = {
+    name: 'conceptualize',
+    description: `use this skill to extract the concepts latent in a source — which are primitive, what each means, how each factors — deciding nothing about names or form; stage 1 of exemplify.`,
+    formalBlock: `sources             ≜ input material ⟨multi-modal · bears substrate-boundaries⟩
+concept-record      ≜ ⟨ gloss , anchor? , factorization? ⟩
+resolve(sources)    ≜ ⋃ { content(s) | s ∈ sources }
+D                 ≜ { d | d a distinction drawn over resolve(sources) } ⟨finite⟩
+depalimpsest(d)     ≜ d ↾ live-strata
+partition(D)      ⊆ ℘(D)
+cl                : ℘(D) → ℘(D)
+C                 ≜ { X ⊆ D | cl(X) = X }
+intent(c)           ≜ c
+⊔ P                 ≜ cl(⋃ { intent(c) | c ∈ P })   ,  P ⊆ C
+prim(c)           ⇔ ∄ P ⊆ C \\ {c} : ⊔ P = intent(c)
+dfp(g)              ≜ densest-faithful-point(g)
+gloss(c)            ≜ dfp(intent(c))   ,  prim(c)
+fac(m)            ≜ { P ⊆ C \\ {m} | ⊔ P = intent(m) ∧ ∄ Q ⊊ P : ⊔ Q = intent(m) }
+distillable(c)      ≜ prim(c) ∨ fac(c) ≠ ∅
+produce(sources)    ≜ { ( gloss(c), ⊥, ⊥ ) | c ∈ C }
+
+boundaries(sources) ∉ D
+cl(X)             ⊇ X
+X ⊆ Y               ⇒ cl(X) ⊆ cl(Y)
+cl(cl(X))       = cl(X)
+∀ d ∈ D           : d ∉ cl(D \\ {d})
+MECE(C)           ⇔ ( ∀ c≠c' ∈ C : intent(c) ≠ intent(c') ) ∧ ( cl(D) = ⊔ C )
+⊨ MECE(C)
+C = ∅             ⇒ ⊥`,
+    composition: () => [exemplify, signify, materialize],
+};
+//# sourceMappingURL=skill.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/conceptualize/skill.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAE9C,MAAM,CAAC,MAAM,aAAa,GAAU;IAClC,IAAI,EAAE,eAAe;IACrB,WAAW,EAAE,kLAAkL;IAC/L,WAAW,EACT;;;;;;;;;;;;;;;;;;;;;;;;sBAwBqC;IACvC,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,SAAS,EAAE,OAAO,EAAE,WAAW,CAAC;CACrD,CAAC"}

package/dist/skills/create-agent/skill.d.ts

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

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

@@ -0,0 +1,38 @@
+export const createAgent = {
+    name: 'create-agent',
+    description: `author a custom agent as a dimension-selection vector — pick each dimension's value from the canonical catalog (the model's own latent sets, the corpus's curated ones, and per-agent open ones), compose the agent cell, then resolve → verify → deploy; knows the dimension manifest. Can interview a non-engineer in plain language (one question per dimension, recommending the fittest) when a human is driving.`,
+    formalBlock: `A               ≜ the agent under construction
+O               ≜ the dimension set @ Target \`##\` anatomy sections
+catalog         ≜ the canonical value store per dimension @ \`cratylus catalog\` ⟨live · never embedded⟩
+repertoire      : O → { latent, open, curated } ⟨who owns the value-set⟩
+latent          ≜ a value-set the MODEL owns ⟨read out, ¬ authored⟩
+open            ≜ a value-set the AGENT owns ⟨named per-agent⟩
+curated         ≜ a closed catalog the CORPUS assembled
+arity           : O → { scalar, set }
+scalar          ≜ one value
+set             ≜ a subset
+definiens(o, v) ≜ v's one-line bound @ catalog
+fit(v)          ⇔ v suits A's purpose
+fittest(o)      ≜ the best-fitting v ∈ catalog(o)
+value(o)        ≜ the selected member(s) of catalog(o) by fit
+vector(A)       ≜ ⊕{ o ↦ value(o) | o ∈ O }
+instance-bound  ≜ provenance⟨mark : emoji·hue⟩ ⟨authored per-agent · ∉ catalog ∴ ∉ O · never shared across agents⟩
+human-project   ≜ downstream human projection @ llm-native
+
+∀ o ∈ O : value(o) ∈ catalog(o)
+arity(o) = scalar ⇒ | value(o) | = 1
+arity(o) = set ⇒ value(o) ⊆ catalog(o)
+gap(o) ⇔ ∄ v ∈ catalog(o) : fit(v)
+gap(o) ⇒ catalog := exemplify(catalog) @ owner ⟨¬ inline · ¬ wizard⟩
+verify(A) ⇔ PASS gate ∧ gate_agent_dimension_refs clean
+gate            ≜ the FULL corpus suite (\`pnpm test\`) as the shard-completion gate : per-agent PASS ≠ corpus PASS ∴ run the whole suite, ¬ the dimension-ref check alone
+green           ≜ ∀ gate PASS reached by fixing → the FITTEST value ⟨gap(o) → exemplify catalog(o)⟩, never by degrading fit to appease a gate ⟨gate = a fit registry, ¬ a cap⟩
+interview = human-project ⟨the human-driver elicitation⟩
+human-driver ⇒ ∀ o : present ⟨catalog(o) · definiens(o, ·)⟩ ∧ recommend fittest(o)
+boundary ≜ dimensions-only · domain-skills @ create-skill
+
+create-agent ≜ fix(name, purpose) → ( ∀ o : select value(o) ) → assemble vector(A) → write(A) → resolve → verify(A) → iterate-until-green → deploy
+write(A)     ≜ the cell ⟨class ↦ agent⟩ : H1 ≜ name · body ≜ the \`dimension <value>\` lines ⟨multi: \`dimension { <a> · <b> }\`⟩ ⟨path ∧ front-matter ∈ deploy ; its Target is REGENERABLE ∴ ¬ hand-edit⟩`,
+    composition: () => [],
+};
+//# sourceMappingURL=skill.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/create-agent/skill.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,WAAW,GAAU;IAChC,IAAI,EAAE,cAAc;IACpB,WAAW,EAAE,wZAAwZ;IACra,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2MA+B+M;IAC5N,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;CACtB,CAAC"}

package/dist/skills/create-skill/skill.d.ts

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

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

@@ -0,0 +1,27 @@
+import { formalize } from '../formalize/skill.js';
+export const createSkill = {
+    name: 'create-skill',
+    description: `author a well-formed skill cell — a description and trigger the projector emits as front-matter, a verb H1, the first-prose-≜ composition formula with a Bindings line, and a self-sufficient set-builder formal block (declarations-above / laws-below) at R=LLM density; embodies the composer conventions, the symbol-table discipline, and the verify gates so the cell passes on the first resolve.`,
+    formalBlock: `cell            ≜ a skill cell ⟨class ↦ skill⟩, authored to PASS verify on the first resolve ⟨path ∈ deploy⟩
+fm              ≜ front-matter, EMITTED by deploy ⟨keys harness-variant⟩ : the cell supplies name ∧ description ∧ trigger-verb, ¬ the key-set
+description     ≜ fm's reconstruction-grade one-liner ; { description , name } = ALL context @ selection ∴ carries trigger-weight ≜ { what-it-is , when-to-reach-for-it }
+H1              ≜ the skill name, a VERB, fires on its own @ selection ; body ≺ H1 dropped by composer
+formula         ≜ the first prose \`≜\` line, consumed as the composition formula
+Bindings        ≜ a prose \`Bindings: composes <a> · <b>.\` line, boundary-binds live sibling deps
+block           ≜ the self-sufficient set-builder block @ formalize : declarations above \`=== … ===\`, laws below, no prose, σ* density
+xref            ≜ a sibling ∨ corpus concept, cited once by its bare σ* anchor
+gate            ∈ { schema, references, fences, symbols, verbatim-ref-free, operative, provenance } ⟨corpus-scoped : symbols · self-sufficiency span all cells⟩
+verify          ≜ the FULL corpus suite (\`pnpm test\`) as the shard-completion gate : per-cell PASS ≠ corpus PASS ∴ run the whole suite, ¬ the cell's own targeted check alone
+green           ≜ ∀ gate PASS reached by fixing → the FITTER sign ⟨declare the fittest glyph + cold-verify · ∨ resolve it to its decodable word⟩, never by degrading the sign to appease a gate ⟨gate = decodability registry, ¬ expression cap⟩
+
+self-sufficient(block) ⇔ every term defined in-cell ∧ only live siblings named in prose, never restated
+∀ glyph ∈ fences(cell) : glyph ∈ symbol-table ∪ definienda(cell) ∪ exemptions(Greek · subscript · box-drawing · em-dash)
+operative(cell) ⇔ ∃ ≥1 element ∈ { numbered-step , fenced-block , substantive-prose } beyond H1 + formula
+composes-siblings(cell) ⇔ Bindings ∈ cell ⇔ provenance(cell) ≠ ∅
+only-fenced-≜(cell) ⇔ ¬ composes-siblings(cell) ⇔ provenance(cell) = ∅ ⟨standalone ; a NOTE, not a defect⟩
+never \`X ≜ <cell>\` in prose ; sibling deps boundary-bound via Bindings
+create-skill ≜ name-as-verb → write fm → H1 + formula ( + Bindings ⇔ composes-siblings ) → author block @ formalize → resolve → verify → iterate-until-green → deploy
+boundary ≜ the skill cell ; prose→set-builder @ formalize ; dimension-vectors @ create-agent ; mints no dimension values`,
+    composition: () => [formalize],
+};
+//# sourceMappingURL=skill.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/create-skill/skill.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAElD,MAAM,CAAC,MAAM,WAAW,GAAU;IAChC,IAAI,EAAE,cAAc;IACpB,WAAW,EAAE,0YAA0Y;IACvZ,WAAW,EACT;;;;;;;;;;;;;;;;;;;yHAmBwI;IAC1I,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,SAAS,CAAC;CAC/B,CAAC"}

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

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

package/dist/skills/dream/skill.js

@@ -0,0 +1,65 @@
+import { exemplify } from '../exemplify/skill.js';
+import { materialize } from '../materialize/skill.js';
+export const dream = {
+    name: 'dream',
+    description: `use this skill to consolidate an agent's memory — fold the raw EPISODIC stream (the tool computes each record's capture node from its cwd — provenance, not what the record is about), then route by type: agent-intrinsic identity/facts to SEMANTIC, generalized cross-project wisdom to PROCEDURAL (only what no projection already carries), a fleet/system/mechanism truth promoted into the projected+gated canon (or emitted as a canon-candidate task) rather than parked in private memory, forward next-steps to EPISODIC, the rest dropped; consumed raw is drained; the Target is never written.`,
+    formalBlock: `memory              ≜ agent dimension-home ⟨SEMANTIC · PROCEDURAL · EPISODIC⟩ ∪ the memory-tool runtime ⟨a RUNTIME CAPABILITY ; invoked \`memory <verb> <args>\` ; the Runtime-capability line under this block resolves the shim ∴ ¬ path-in-cell⟩
+EPISODIC            ≜ raw time-ordered event stream ∪ forward next-steps
+SEMANTIC            ≜ identity facts ∪ durable agent-intrinsic knowledge ⟨hot index⟩
+PROCEDURAL          ≜ generalized cross-project wisdom no projection already carries
+Target              ≜ the deploy-projected declaration carrying the archetype ; commons-authored ; ∉ dream outputs
+lock                ≜ dream.lock ⟨O_EXCL ; stale ⇔ age > 2h⟩ guarding the {SEMANTIC · PROCEDURAL} partition ⟨shared by all same-host sessions of one agent ; ¬ project-scoped⟩ ; \`memory lock (acquire|release|status) --name <agent>\`
+                      ⟨WHY a lock HERE and not one-file-per-writer : a concurrent APPEND race is LOUD ⟨encode ↦ EPISODIC : interleaved, never lost⟩ ; a concurrent EDIT race is SILENT ⟨depalimpsest supersedes the WHOLE file ∴ the loser vanishes with no trace⟩⟩
+                      ⟨∴ classify the OPERATION before choosing the instrument : append ⇒ partition by writer ; edit ⇒ lock⟩
+node                : cwd × host → provenance ⟨WHERE-captured ; nearest boundary-marker ancestor ; markerless ↦ self ; cwd-less ∨ vanished-cwd ↦ legacy⟩
+scope(i)            ≜ what i is ABOUT ⟨read from text(i) ; ¬ node(i) : provenance ≠ scope⟩
+project-referential ≜ scope(i) ↾ one particular project ⟨text(i) names a repo-key ∨ workspace-path ∨ plan-path ∨ branch-ref ∨ issue-ref ; audit detects exactly these⟩
+read                : home × session → records ⟨own ∪ completed ; live-sibling ∉⟩ ; \`memory read --name <agent> --for-session <self>\`
+fold                : home → { id ↦ node ∪ legacy } ; \`memory fold --name <agent>\`
+drain               : home → ∅ ↾ completed-sessions ⟨--completed-only retains a live sibling ; --for-session adds self at handoff⟩ ; \`memory drain --name <agent> --completed-only\`
+route               : record → { SEMANTIC · PROCEDURAL · CANON-PROMOTION · EPISODIC · drop }
+land                : route-manifest → { SEMANTIC · PROCEDURAL } ⟨the routing is MINE ; the write is the tool's⟩ ; \`memory apply --name <agent> --routes -\`
+resident            : store → text ⟨read the whole prose home ; ¬ open its path⟩ ; \`memory get --name <agent> --store (SEMANTIC|PROCEDURAL)\`
+rollover            ≜ land ⊕ drain ⊕ re-encode(residue) ATOMIC under one lock ⟨residue between drain ∧ re-encode lives ONLY in my context ∴ a gap loses it⟩ ; \`memory rollover --name <agent> --routes - --residue '<json>'\`
+audit               : home → findings × pressure ⟨dream's exit condition⟩ ⟨sign taken from the verb it invokes⟩ ; \`memory audit --name <agent>\`
+ceiling             ≜ per-store byte watermark ⟨SEMANTIC ∪ PROCEDURAL load WHOLE every wake ∴ bytes are a per-session context cost⟩
+pressure            ≜ { s ∈ { SEMANTIC · PROCEDURAL } | bytes(s) > ceiling } ⟨audit MEASURES it ; depalimpsest's only trigger⟩
+dfp(i)              ≜ densest-faithful-point(i)
+depalimpsest        ≜ reconcile the resident set to current ground-truth ⟨¬only-drop-stale⟩ ; supersede the whole file, ¬ append : \`memory replace --name <agent> --store (SEMANTIC|PROCEDURAL) --body -\`
+promotion-is-move   ≜ a promoted item ∉ its raw source ⟨an obligation discharged AT the promotion, ¬ a later drain's finding⟩
+canon-truth(i)      ⇔ i binds ≥1 agent-type ∨ the fleet ∨ is a mechanism/governance-fact ⟨¬ this-agent-only⟩
+reach(x)            ≜ the contexts x is present in ⟨own Target · loaded-skill ↦ EVERY context ; corpus-local gate ∨ cell ↦ that corpus ALONE⟩
+projection-carries(i) ⇔ ∃ x : i ⊆ x ∧ reach(x) ⊇ reach(store(i)) ⟨carriage has a RADIUS : authorship ≠ carriage ; SOMEWHERE ≠ WHEREVER i binds⟩
+                      ⟨PROCEDURAL = cross-project ∴ a corpus-local gate NEVER discharges it ; SEMANTIC ∪ PROCEDURAL are read at EVERY wake, a repo is not⟩
+CANON-PROMOTION(i)  ≜ author i into its strongest seam ⟨gate ≻ cell ≻ governing-doc⟩ ; ¬canon-remit ⇒ emit a canon-candidate task to the curator ; then projection-carries(i) ⇒ drop ⟨PROCEDURAL⟩
+
+dream ≜ read ⟨EPISODIC⟩ ↦ exemplify ↦ materialize
+lock-precondition ≜ acquire(lock) before any write to {SEMANTIC · PROCEDURAL} ∨ any drain ; held-by-live-other ⇒ skip consolidation this wake ⟨raw preserved ; encode always-legal⟩
+∀ i ∈ read(home, session) : i = dfp(i)
+instances-governing-exemplar(i) ⇒ i ↦ pointer
+project-referential(i) ⇒ i ∉ SEMANTIC ∧ i ∉ PROCEDURAL ⟨generalize past the instance ∨ drop ; node(i) binds NOTHING here⟩
+identity(i) ∨ agent-intrinsic-durable(i) ⇒ i ↦ SEMANTIC
+generalized-wisdom(i) ∧ ¬projection-carries(i) ∧ canon-truth(i)  ⇒ i ↦ CANON-PROMOTION
+generalized-wisdom(i) ∧ ¬projection-carries(i) ∧ ¬canon-truth(i) ⇒ i ↦ PROCEDURAL
+projection-carries(i) ⇒ i ↦ drop
+next-step(i) ⇒ i ↦ EPISODIC ⟨own-node⟩
+else ⇒ i ↦ drop
+drain ≜ .bak archive before clear ; forward-residue re-encoded after drain ; release(lock) last
+land ⊕ drain ⊕ re-encode ⇒ rollover ⟨¬ three invocations : the gap is where residue dies⟩
+consumed ↦ ∅ ∴ ¬unbounded-growth(EPISODIC)
+EPISODIC ──dream──→ { SEMANTIC · PROCEDURAL · EPISODIC }
+land(i)         ⇔ bytes(store ∪ i) ≤ ceiling ⟨¬land(i) ⇒ ⊥ : the tool refuses, naming store · ceiling · overage⟩
+depalimpsest(b) ⇔ bytes(b) ≤ ceiling ∨ bytes(b) < bytes(store) ⟨STRICT shrink accepted EVEN over ceiling ∴ over-ceiling ⇒ frozen-to-shrink, ¬ bricked⟩
+¬land(i)        ⇒ depalimpsest ≺ re-land(i) ⟨the refusal IS the eviction summons ; distil to the named target ; ¬ retry-unchanged ; ¬ hand-edit the store⟩
+∀ s ∈ pressure : s ──depalimpsest──→ { SEMANTIC · PROCEDURAL } ⟨THAT an eviction is owed is measured ; WHAT to evict is MY judgement⟩
+    generalized-wisdom(i) ∧ ¬projection-carries(i) ⇒ i ↦ CANON-PROMOTION ↾ canon-truth(i) ; else PROCEDURAL   ( projection-carries(i) ⇒ ∅ )
+    superseded(i)                                  ⇒ ∅
+    stale(i)                                       ⇒ ∅
+acceptance ≜ wake-read biases next-action ⟨reboot-seed ; round-trip ≽⟩
+¬graspable-in-one-glance(i) ⇒ distill-further(i) ∨ drop(i)
+Target ∉ dream-outputs
+verb-over-prose ≜ ∀ step declaring an invocation : invoke it ⟨the tool owns the write · I own only the routing⟩ ; hand-editing a store the tool can write is the defect`,
+    runtime: { capability: 'memory' },
+    composition: () => [exemplify, materialize],
+};
+//# sourceMappingURL=skill.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/dream/skill.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAEtD,MAAM,CAAC,MAAM,KAAK,GAAU;IAC1B,IAAI,EAAE,OAAO;IACb,WAAW,EAAE,8kBAA8kB;IAC3lB,WAAW,EACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wKAuDuL;IACzL,OAAO,EAAE,EAAE,UAAU,EAAE,QAAQ,EAAE;IACjC,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,SAAS,EAAE,WAAW,CAAC;CAC5C,CAAC"}

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

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

package/dist/skills/elicit/skill.js

@@ -0,0 +1,26 @@
+import { conceptualize } from '../conceptualize/skill.js';
+import { probe } from '../probe/skill.js';
+import { signify } from '../signify/skill.js';
+export const elicit = {
+    name: 'elicit',
+    description: `use this skill to elicit the operator's hidden intended concept — recover it by asking maximally-informative yes/no questions, each a distinction that bisects the live candidates by prior mass (binary-search / information-gain over the concept lattice), converging in the fewest questions; the active, query-driven counterpart to probe (which reads a signifier already given) — stop when one candidate survives or no question is worth its burden, then hand the recovered concept to signify to name.`,
+    formalBlock: `C        ≜ concept lattice
+D        ≜ distinction set
+c          ≜ a closed distinction-set ; c ⊆ D
+q ∈ c      ⇔ c draws the distinction q
+priors   ≜ structured understanding of a token before any definition
+μ          ≜ prior mass over candidates read off priors by conceptual fit ; μ : ℘(C) → [0,1] ; μ(C) = 1
+t          ≜ the operator's hidden target concept ; t ∈ C ; unobserved
+candidates          ≜ the live candidate set ; candidates ⊆ C
+q          ≜ a query ; q ∈ D ; operator answers yes ∨ no
+θ          ≜ the burden threshold ; θ ∈ (0,1]
+
+Y(q)      ≜ { c ∈ candidates | q ∈ c }
+bal(q)    ≜ | μ(Y(q)) - μ(candidates \\ Y(q)) |
+ask(candidates)    ≜ argmin over q of bal(q)
+filter(candidates) ≜ Y(ask(candidates)) if yes ; candidates \\ Y(ask(candidates)) if no
+stop(candidates)   ⇔ | candidates | = 1 ∨ bal(ask(candidates)) > θ
+elicit    ≜ from candidates = C, iterate filter until stop ; return t = the one surviving candidate`,
+    composition: () => [probe, signify, conceptualize],
+};
+//# sourceMappingURL=skill.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/elicit/skill.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAC1C,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAE9C,MAAM,CAAC,MAAM,MAAM,GAAU;IAC3B,IAAI,EAAE,QAAQ;IACd,WAAW,EAAE,ofAAof;IACjgB,WAAW,EAAE;;;;;;;;;;;;;;;;oGAgBwG;IACrH,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,KAAK,EAAE,OAAO,EAAE,aAAa,CAAC;CACnD,CAAC"}

package/dist/skills/event-tap/skill.d.ts

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

package/dist/skills/event-tap/skill.js

@@ -0,0 +1,37 @@
+import { introspect } from '../introspect/skill.js';
+const EVENT_TAP_BLOCK = `event-tap    ≜ install → observe → read → uninstall
+capability   ≜ eventTap ⟨runtime-bound ; every verb reached as \`scripts/eventTap.mjs <verb>\`⟩
+verb         ∈ { install · uninstall · read · status }
+lifecycle    ≜ the harness-neutral moment taxonomy ⟨session.start · session.end · prompt.submit · turn.end · tool.use.pre · tool.use.post · subagent.start · context.compact.pre · … ⟩
+E            ⊆ lifecycle
+sink         ≜ append-only capture path ⟨one record per line⟩
+record       ≜ ⟨event ∈ lifecycle, payload⟩
+order(read)  ≜ position ⟨∄ fabricated timestamp⟩
+target       ≜ the harness's own hook-config artifact ⟨\`--settings <path>\` ; absent ↦ the harness default ; the ADAPTER names it, ¬ this cell⟩
+target₀      ≜ target before install
+foreign      ≜ every target key ∧ every hook entry this tap did not write
+attached     : target → 𝔹
+
+install(E, sink) ≜ \`scripts/eventTap.mjs install --events <e₁,e₂,…> --sink <path>\` ∴ attached(target)
+uninstall        ≜ \`scripts/eventTap.mjs uninstall\` ∴ ¬ attached(target)
+read             ≜ \`scripts/eventTap.mjs read\` ↦ { record }
+status           ≜ \`scripts/eventTap.mjs status\` ↦ ⟨attached(target), E⟩
+
+passive ⊨ ¬ block ∧ ¬ deny ∧ ¬ mutate(host-control-flow) ⟨observe only ; ∀ verb⟩
+uninstall ∘ install ⊨ target ≡ target₀ ∧ foreign preserved ⟨zero residue⟩
+e ∈ E ∧ e ∉ lifecycle ⇒ ⊥ ⟨loud⟩
+verb ∉ { install · uninstall · read · status } ⇒ ⊥ ⟨loud⟩
+E = ∅ ⇒ ¬ attached(target)
+¬ attached(target) ⇒ read ↦ ∅
+status ≜ derived from target ⟨¬ in-memory ∴ a fresh process reads the same truth⟩
+observe ≜ the host writes each occurrence of E to sink ⟨∄ agent turn between fire ∧ capture⟩
+self-observation ≜ install ↾ own-lifecycle ∴ read ⊨ evidence(own-behavior) ⟨¬ recollection⟩
+install ⊨ uninstall owed ⟨an uninstalled tap outlives the question it was installed to answer⟩`;
+export const eventTap = {
+    name: 'event-tap',
+    description: `use this skill to attach a passive observer to an agent's own lifecycle — install a tap on a chosen set of harness-neutral events (session.start, turn.end, tool.use.pre, …), let the host append each occurrence to a capture sink, read the captured records back as evidence of what actually happened, and uninstall the tap with zero residue; the four verbs are install, uninstall, read, status, and the tap never blocks, denies, or alters what it observes.`,
+    formalBlock: EVENT_TAP_BLOCK,
+    runtime: { capability: 'eventTap' },
+    composition: () => [introspect],
+};
+//# sourceMappingURL=skill.js.map

package/dist/skills/event-tap/skill.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/event-tap/skill.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAEpD,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;+FA2B0F,CAAC;AAEnH,MAAM,CAAC,MAAM,QAAQ,GAAU;IAC7B,IAAI,EAAE,WAAW;IACjB,WAAW,EAAE,wcAAwc;IACrd,WAAW,EAAE,eAAe;IAC5B,OAAO,EAAE,EAAE,UAAU,EAAE,UAAU,EAAE;IACnC,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,UAAU,CAAC;CAChC,CAAC"}

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

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

package/dist/skills/exemplify/skill.js

@@ -0,0 +1,42 @@
+import { conceptualize } from '../conceptualize/skill.js';
+import { materialize } from '../materialize/skill.js';
+import { signify } from '../signify/skill.js';
+const FORMAL_BLOCK = `concept-record     ≜ ⟨ gloss , anchor? , factorization? ⟩
+sources            ≜ input material @ conceptualize ⟨the corpus D is drawn OVER, ¬ D itself⟩
+C                  ≜ concept lattice @ conceptualize
+produce            : sources → concept-record @ conceptualize
+name               : concept-record → concept-record @ signify
+realize            : concept-record → concept-record @ materialize
+REC                : concept-record → concept-record @ materialize
+R_cold(f)          ≜ the isolated cold-blind decode of fragment f (a naive reader, zero project-K, from f's signifiers + inline ≜ alone)
+body(k)            ≜ cell k's authored surface ⟨front-matter excluded⟩
+decode_warm(f | K) ≜ fragment f's warm decode, reader free to consult K
+K                  ≜ project-K, the warm knowledge (project corpus) a reader already holds
+R_cold, decode_warm, coldpass, K @ cold-decode-oracle
+minimal            @ signify
+conform            @ signify
+Cells              ≜ every authored cell, self included
+fragment_digest(f) ≜ digest( trim( collapse-whitespace( NFC(f) ) ) )
+manifest           ≜ { source , exemplified_at , reader , routes[⟨fragment_digest, idea_gloss, home_slug, disposition, rank⟩] , delta[⟨fragment_digest, idea_gloss⟩] }
+
+realized(k) ⇔ factorization(k) ≠ ⊥
+coldpass(k) ⇔ R_cold(body(k)) ≅ gloss(k) ∧ decode_warm(body(k) | K) ≅ R_cold(body(k))
+valid(k)    ⇔ REC(k) ≽ k ∧ minimal(k) ∧ conform(k) ∧ coldpass(k)
+produce ↦ gloss ; name ↦ anchor ; realize ↦ factorization
+∀ k ∈ Cells : accept(k) defined
+disposition ∈ { reuse, mint }
+∀ c ∈ C : c ∈ routes ⊻ c ∈ delta
+accept(F(sources)) = F(sources) ⇒ manifest @ .manifests/<source>.json
+
+F(sources)   ≜ realize( name( produce(sources) ) )
+exemplify(sources) ≜ accept( F(sources) )
+accept(k)    ≜ ⊥ , ¬realized(k)
+accept(k)    ≜ k , valid(k)
+accept(k)    ≜ ⊥ , ¬valid(k)`;
+export const exemplify = {
+    name: 'exemplify',
+    description: `optimize a context corpus into a canonical semantic factorization — compose produce → name → realize over the one concept-record, then gate on accept; emits the R3 routing manifest that catches the dropped idea.`,
+    formalBlock: FORMAL_BLOCK,
+    composition: () => [conceptualize, signify, materialize],
+};
+//# sourceMappingURL=skill.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/exemplify/skill.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAE9C,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BA+B2B,CAAC;AAEjD,MAAM,CAAC,MAAM,SAAS,GAAU;IAC9B,IAAI,EAAE,WAAW;IACjB,WAAW,EAAE,qNAAqN;IAClO,WAAW,EAAE,YAAY;IACzB,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,aAAa,EAAE,OAAO,EAAE,WAAW,CAAC;CACzD,CAAC"}

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

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

package/dist/skills/formalize/skill.js

@@ -0,0 +1,35 @@
+import { conceptualize } from '../conceptualize/skill.js';
+import { signify } from '../signify/skill.js';
+export const formalize = {
+    name: 'formalize',
+    description: `use this skill to convert prose — especially of a process or skill — into a self-sufficient set-builder block under self-sufficient-formalism: conceptualize the prose to its entities/operations/laws, signify each as a symbol (minting or boundary-binding to an anchor), and emit declarations-above / laws-below with no explanatory prose; accept only on round-trip equivalent-or-better.`,
+    formalBlock: `prose ≜ the source text
+E ≜ entities(prose) ; O ≜ operations(prose) ; L ≜ laws(prose)
+
+T ≜ the declared notation table @ src/operator-lexicon.ts
+η : E ∪ O ⇀ symbols @ signify
+β ≜ { s | s imported, its anchor cited once in adjacent notation }
+ι ≜ { s | s resolved from invocation context }
+
+σ* ≜ signify's fittest sign
+
+B ≜ formalize(prose) such that :
+    ∀ e ∈ E      : signature(η(e)) ∈ B
+    ∀ o ∈ O ∪ L  : law(η(o)) ∈ B
+    ∀ line ∈ B : line = σ*(its concept)
+
+Dfn ≜ { s | a line of B defines s }
+closed(B)   ⇔ symbols(B) ⊆ T ∪ Dfn ∪ β ∪ ι
+complete(B) ⇔ ∀ b ∈ behavior(prose) : ∃ line ∈ B : line ⊨ b
+ordered(B)  ⇔ ∀ s ∈ Dfn : definition(s) precedes use(s)
+self-sufficient(B) ⇔ closed(B) ∧ complete(B) ∧ ordered(B)
+gloss(B) ≜ prose of B beyond β ∪ ι ; gloss(B) ≠ ∅ ⇒ ¬complete(B)
+¬self-sufficient(B) ⇒ ⊥
+
+σ*(c) ∉ T ⇒ extend T with σ*(c) ⟨cold-verify⟩ ; ¬ degrade c to a weaker α ∈ T ∵ α ≠ σ*(c) ⟨llm-native⟩
+
+reconstruct(B) ≽ prose
+reconstruct(B) ⋡ prose ⇒ ⊥`,
+    composition: () => [conceptualize, signify],
+};
+//# sourceMappingURL=skill.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/formalize/skill.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAE9C,MAAM,CAAC,MAAM,SAAS,GAAU;IAC9B,IAAI,EAAE,WAAW;IACjB,WAAW,EAAE,kYAAkY;IAC/Y,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;2BA0B+B;IAC5C,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,aAAa,EAAE,OAAO,CAAC;CAC5C,CAAC"}

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

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

package/dist/skills/handoff/skill.js

@@ -0,0 +1,27 @@
+import { dream } from '../dream/skill.js';
+import { praxis } from '../praxis/skill.js';
+const FORMAL_BLOCK = `handoff        ≜ praxis-sync → release → dream
+self           ≜ session⟨AGENT_SESSION_ID⟩
+agent          ≜ this agent's name
+memory         ≜ runtime capability ⟨invoked \`memory <verb> <args>\` ; the Runtime-capability line under this block resolves the shim ∴ ¬ path-in-cell⟩
+praxis-sync    ≜ sync @ praxis
+dream          ≜ drain⟨EPISODIC⟩ @ dream
+release        ≜ \`memory session release --name <agent>\` ∴ released(self)
+registered, released, stale : session → 𝔹
+live           : session → 𝔹
+
+order          : praxis-sync ≺ release ≺ dream
+                 ⟨release ≺ dream : release is what makes the session's records COMPLETED, ∴ drainable by a party that is not this one · draining BEFORE it forces the expensive act to finish inside the exiting context, which is the one context least able to afford it⟩
+registered, released, stale @ memory-session-registry
+live(s)        ⇔ registered(s) ∧ ¬ released(s) ∧ ¬ stale(s)
+live(self)     ⇒ self.{forward-residue, owned-plan} occupied
+¬ live(self)   ⇒ self.{forward-residue, owned-plan} inheritable
+scope          = persist-only`;
+export const handoff = {
+    name: 'handoff',
+    description: `use this skill to prepare a session for handoff before /clear — bring the plan's record up to date (praxis sync) and consolidate memory (dream) while context is still hot; the persist half of the session boundary, invocable as /handoff.`,
+    formalBlock: FORMAL_BLOCK,
+    runtime: { capability: 'memory' },
+    composition: () => [praxis, dream],
+};
+//# sourceMappingURL=skill.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/handoff/skill.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAC1C,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAE5C,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;8BAgB4B,CAAC;AAElD,MAAM,CAAC,MAAM,OAAO,GAAU;IAC5B,IAAI,EAAE,SAAS;IACf,WAAW,EAAE,8OAA8O;IAC3P,WAAW,EAAE,YAAY;IACzB,OAAO,EAAE,EAAE,UAAU,EAAE,QAAQ,EAAE;IACjC,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC;CACnC,CAAC"}

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

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

package/dist/skills/introspect/skill.js

@@ -0,0 +1,47 @@
+export const introspect = {
+    name: 'introspect',
+    description: `use this skill when an agent needs to self-audit — compare each dimension's defined value against the value actually in effect this session, and name the cause of every divergence.`,
+    formalBlock: `A          ≜ the agent introspecting itself
+O          ≜ A's live ## Target dimension-sections { archetype · role · formality · audience-adaptation · transparency · autonomy · provenance · objective · engineering-principles · guardrails · capabilities · situation-awareness · actions · modalities · model · memory · trigger · framing · reasoning-strategy · satisficing · output-format · self-evaluation · … }
+V          ≜ the fragment value-space { one-value · value-set · unobservable }
+src_def    ≜ A's in-prompt ## Target sections ∪ agent/<A>.md ⟨one selected value per dimension⟩
+src_rt     ≜ runtime sources observed this session { live tool/action-set · live model · system-prompt-as-given · autonomy-mode + transient-elevation · deployed front-matter⟨color · mark⟩ · env · granted-permissions }
+addresses  : O → concept @ A's archetype ∪ each dimension's role ⟨the concept the fragment must express⟩
+
+def        : O → V @ src_def
+rt         : O → V @ src_rt
+decode     : O → concept ≜ decode_cold(def(o)) ⟨isolated tool-less read of the declared sign · its own priors · zero project-causes⟩
+why        : div → causes
+
+harness-override    ≜ runtime substituted the value ⟨tool-gating · model-pin · env⟩
+deploy-drift        ≜ deployed def ≠ source vector ⟨stale ∨ partial deploy⟩
+profile-projection  ≜ def projected at a reader/profile that reshaped the value
+transient-elevation ≜ a session act flipped it ⟨carry-on : autonomy human-on-the-loop ↦ human-out-of-the-loop⟩
+composer-dropped    ≜ projection dropped a facet ⟨the color/mark regression class⟩
+env-conditioned     ≜ a host/env fact changed the effective value
+unobservable        ≜ runtime value ¬ inspectable ∴ report-as-such ∧ ¬ guess
+misnomer            ≜ def faithfully in effect yet the wrong sign for its concept ⟨match(o) ∧ ¬ signifies(o) · a signification defect at def, ¬ a configuration one; the class that hides when rt conforms to a def that is itself mis-signified⟩
+K_cfg      ≜ { harness-override · deploy-drift · profile-projection · transient-elevation · composer-dropped · env-conditioned · unobservable }
+causes          ≜ K_cfg ∪ { misnomer }
+
+∀ o ∈ O : rt(o) @ src_rt
+¬ ( rt ≜ def )
+match(o)     ≜ def(o) ≅ rt(o)
+signifies(o) ≜ decode(o) ≅ addresses(o)
+sound(o)     ≜ match(o) ∧ signifies(o)
+div          ≜ { o ∈ O | ¬ sound(o) }
+¬ match(o)                ⇒ why(o) ∈ K_cfg
+match(o) ∧ ¬ signifies(o) ⇒ why(o) = misnomer
+why(o)       ∈ causes , o ∈ div
+row(o)       ≜ ⟨ o, def(o), rt(o), match(o), signifies(o), why(o) ↾ o ∈ div ⟩
+summary      ≜ { ⟨ o, why(o) ⟩ | o ∈ div }
+report       ≜ ⟨ { row(o) | o ∈ O }, summary ⟩
+introspect(A) ≜ report
+
+¬ edit(agent/<A>.md) ∧ ¬ redeploy ∧ ¬ mint(V)
+why(o) ∈ K_cfg            ⇒ reconcile @ { create-agent · deploy }
+why(o) = misnomer         ⇒ reconcile @ signify ≺ { create-agent · deploy }
+O · causes        @ live-anatomy`,
+    composition: () => [],
+};
+//# sourceMappingURL=skill.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/introspect/skill.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,UAAU,GAAU;IAC/B,IAAI,EAAE,YAAY;IAClB,WAAW,EAAE,sLAAsL;IACnM,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAwCqC;IAClD,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;CACtB,CAAC"}

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

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

package/dist/skills/materialize/skill.js

@@ -0,0 +1,54 @@
+import { conceptualize } from '../conceptualize/skill.js';
+import { exemplify } from '../exemplify/skill.js';
+import { signify } from '../signify/skill.js';
+export const materialize = {
+    name: 'materialize',
+    description: `use this skill to realize a concept lattice as artifacts — select each concept's canonical factorization \`F\`, emit the bipartite normal form \`CSF\` (a primitive by value as ⟨anchor, gloss⟩, a composite by reference as ⟨anchor, factor-anchors⟩), then realize under an explicitly named strategy whose kind-consumption table ρ refuses loudly when unnamed; stage 3 of exemplify, independently invocable.`,
+    formalBlock: `C ≜ concept lattice
+prim : C → 𝔹
+fac : C → ℘(℘(C))
+≺ ≜ shortlex order over factorizations
+anchor : C → sign ∪ {⊥}
+gloss : C → text
+kind : C → Kinds
+Kinds ≜ the closed kind set
+
+concept-record   ≜ record(gloss, anchor, factorization)
+dfp(g) ≜ densest-faithful-point(g)
+cite-by-ref ≜ composite stores factor-anchors ∧ ¬restate factor-content
+CSF ≜ bipartite-normal-form: primitive↦⟨anchor,gloss⟩ by value ; composite↦⟨anchor,factor-anchors⟩ by reference
+realize ≜ dispatch artifact-form per kind through a named strategy s
+loud-refusal ≜ s unnamed ∨ ρ_s not total over live kinds ⇒ ⊥
+
+F(m) ≜ min_≺ fac(m)
+CSF(c) ≜ ( anchor(c) , dfp(gloss(c)) )              ,  prim(c)
+CSF(c) ≜ ( anchor(c) , { anchor(p) | p ∈ F(c) } ) ,  ¬prim(c)
+realize(k) fills factorization(k) ≜ CSF(k) ; gloss(k), anchor(k) preserved
+anchor(k) = ⊥ ⇒ realize(k) = ⊥
+
+prose(c) ≜ render(CSF(c))
+CSF(c) ≽ prose(c)
+
+Φ ≜ { (anchor(c), kind(c), CSF(c)) | c ∈ C }
+S ≜ { file, document, … }
+σ : Φ × S → artifacts
+ρ_s : Kinds → form_s
+σ well-defined ⇔ ρ_s total over kinds(Φ)
+s unnamed ∨ s ∉ S ⇒ ⊥
+∃ k ∈ kinds(Φ) : k ∉ dom(ρ_s) ⇒ ⊥
+
+σ(Φ, file) ≜ { \${OUTPUT_DIR}/anchor(c).md | (anchor(c), k, x) ∈ Φ }
+ρ_file(k) ≜ front-matter (kind: k, description) + body
+∀ f ∈ σ(Φ, file) : ∃! (a, k, x) ∈ Φ : content(f) = x
+
+σ(Φ, document) ≜ one recomposed document
+ρ_document(k) ≜ rhetorical role:
+    concept        ↦ definition
+    process        ↦ ordered steps
+    principle      ↦ constraint
+    structure      ↦ table
+    classification ↦ membership test
+    utility        ↦ instrument`,
+    composition: () => [exemplify, signify, conceptualize],
+};
+//# sourceMappingURL=skill.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/materialize/skill.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAE9C,MAAM,CAAC,MAAM,WAAW,GAAU;IAChC,IAAI,EAAE,aAAa;IACnB,WAAW,EAAE,oZAAoZ;IACja,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA4CoC;IACjD,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,SAAS,EAAE,OAAO,EAAE,aAAa,CAAC;CACvD,CAAC"}

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

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