@cratylus/canon 0.1.0 → 0.1.2

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

@@ -1,56 +1,51 @@
-// 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}`;
+// WHAT THIS CELL IS ABOUT, and what it deliberately does not name.
+//
+// carry-on is AUTONOMY: the operator closing a check-in and re-affirming the
+// decision authority already granted, over the context already in hand. It is not a
+// plan operator. It used to be one — it imported `praxis`, projected canon's plan
+// layout onto a runtime command line, and derived its terminus by reading plan state
+// off disk — and that conflation made the cell refuse every context that was not a
+// plan. "Carry on with what we just discussed" is the same utterance doing the same
+// work over a discussion, and a cell bound to `praxis` cannot serve it.
+//
+// The COMPOSITION is the operator's, at the utterance: "carry on with the praxis
+// execution" is carry-on ∘ praxis, and the pairing lives in what was said, not in
+// this module's import list. A cell that names one context forecloses the rest.
+//
+// THE MECHANISM WENT WITH THE COUPLING, and that is a real loss recorded rather than
+// hidden. The old `runtime: { capability: 'carryOn' }` installed a turn-end gate, on
+// the correct argument that an elevation asserted in prose is advisory. But every
+// verb it offered took the plan layout as arguments and read terminus from plan state
+// on disk, so the mechanism WAS the coupling. A context-neutral gate would need a
+// context-neutral terminus, which nothing on disk can answer; until one exists, the
+// turn-end refusal this corpus does own is the stance guardrail, which binds every
+// turn regardless of which word opened it.
 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⟩
+context   ≜ the standing intent already in hand ⟨whatever established it : a plan · a discussion · a review · a defect in the path⟩
+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⟩
+authority ≜ decision-right over the acts context admits
+reversible-in-domain ≜ an act whose undo is available to the same principal
 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⟩
+satisfied(context) ⇔ what was asked is delivered ∨ withdrawn
+elevate   ≜ loop-position := out-of-the-loop ∧ authority ↾ context := principal-self
+revert    ≜ loop-position := resting
 
 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⟩
+elevate ⇒ context unchanged ∧ ¬fresh-dispatch ∧ ¬permission-grant ∧ ¬scope-widen ⟨re-affirmation of authority already given, ¬ a new mandate⟩
+elevate ⇒ resume execution ⟨own judgment · reversible-in-domain decided · ∄ fresh permission owed⟩
+elevate ⇒ persist ∀ turn until revert ⟨¬ per-turn-decay : an affirmation uttered ONCE is ¬ re-owed every turn⟩
+elevate defined ⇔ ¬ satisfied(context) ⟨at a satisfied context there is nothing to stay out of the loop FOR⟩
+fork⊥ ⇒ surface ∧ revert ⟨authority to decide ≠ authority to decide THIS · a fork the principal cannot resolve is the operator's by construction⟩
+satisfied(context) ⇒ revert
+operator-redirect ⇒ revert ⟨the grant is the operator's to withdraw at any turn⟩
+¬ (context @ this cell) ⟨carry-on names no plan · no discussion · no artifact : the operator composes it with a context AT THE UTTERANCE, and a cell naming one forecloses the rest⟩
 `;
 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.`,
+    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 authority already granted, over whatever context is already in hand; the elevation persists across turns rather than decaying each turn, and it lifts when the context is satisfied, when the Operator redirects, or at a fork the principal cannot resolve, which is surfaced rather than decided. The context is the Operator's to name in the same breath ("carry on with the plan execution", "carry on with what we just discussed"); this skill supplies the authority, never the subject.`,
     formalBlock: carryOnNotation,
-    runtime: { capability: 'carryOn' },
-    composition: () => [praxis],
+    composition: () => [],
 };
 //# sourceMappingURL=skill.js.map

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

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

package/dist/skills/conceptualize/skill.js

@@ -1,6 +1,18 @@
-import { exemplify } from '../exemplify/skill.js';
-import { materialize } from '../materialize/skill.js';
-import { signify } from '../signify/skill.js';
+// COMPOSES NOTHING, and that is the repair.
+//
+// This cell used to declare `composition: () => [exemplify, signify, materialize]` and import those
+// modules to do it. The thunk's only consumer is the trailing `Composed from …`
+// line of the projected SKILL.md (`forge/src/core/exemplify/skill-cell.ts`), so each
+// import bought one sentence of provenance and cost a module-level cycle: the four
+// signification cells each claimed to be composed from the other three, and no one of
+// them could be read, taken or deployed alone.
+//
+// The relation those edges named is CITATION, not dependency: `symbol-altitude`'s
+// LEDGER records these cells RESTATING each other's signs in different registers
+// (prose here, signature there), which is what a REFERENCE row means. A citation
+// belongs inside the block, at the sign that borrows it (`@ <cell>`), where it needs
+// no import and cannot cycle. Composition is the caller's: an agent pipes these cells
+// in whatever order the work wants.
 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.`,
@@ -29,6 +41,6 @@ cl(cl(X))       = cl(X)
 MECE(C)           ⇔ ( ∀ c≠c' ∈ C : intent(c) ≠ intent(c') ) ∧ ( cl(D) = ⊔ C )
 ⊨ MECE(C)
 C = ∅             ⇒ ⊥`,
-    composition: () => [exemplify, signify, materialize],
+    composition: () => [],
 };
 //# sourceMappingURL=skill.js.map

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

@@ -1 +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"}
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/conceptualize/skill.ts"],"names":[],"mappings":"AAEA,4CAA4C;AAC5C,EAAE;AACF,oGAAoG;AACpG,gFAAgF;AAChF,qFAAqF;AACrF,mFAAmF;AACnF,sFAAsF;AACtF,+CAA+C;AAC/C,EAAE;AACF,kFAAkF;AAClF,iFAAiF;AACjF,iFAAiF;AACjF,qFAAqF;AACrF,sFAAsF;AACtF,oCAAoC;AAEpC,MAAM,CAAC,MAAM,aAAa,GAAU;IAClC,IAAI,EAAE,eAAe;IACrB,WAAW,EAAE,kLAAkL;IAC/L,WAAW,EACT;;;;;;;;;;;;;;;;;;;;;;;;sBAwBqC;IACvC,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;CACtB,CAAC"}

package/dist/skills/elicit/skill.js

@@ -1,6 +1,18 @@
-import { conceptualize } from '../conceptualize/skill.js';
-import { probe } from '../probe/skill.js';
-import { signify } from '../signify/skill.js';
+// COMPOSES NOTHING, and that is the repair.
+//
+// This cell used to declare `composition: () => [probe, signify, conceptualize]` and import those
+// modules to do it. The thunk's only consumer is the trailing `Composed from …`
+// line of the projected SKILL.md (`forge/src/core/exemplify/skill-cell.ts`), so each
+// import bought one sentence of provenance and cost a module-level cycle: the four
+// signification cells each claimed to be composed from the other three, and no one of
+// them could be read, taken or deployed alone.
+//
+// The relation those edges named is CITATION, not dependency: `symbol-altitude`'s
+// LEDGER records these cells RESTATING each other's signs in different registers
+// (prose here, signature there), which is what a REFERENCE row means. A citation
+// belongs inside the block, at the sign that borrows it (`@ <cell>`), where it needs
+// no import and cannot cycle. Composition is the caller's: an agent pipes these cells
+// in whatever order the work wants.
 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.`,
@@ -21,6 +33,6 @@ 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],
+    composition: () => [],
 };
 //# sourceMappingURL=skill.js.map

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

@@ -1 +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"}
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/elicit/skill.ts"],"names":[],"mappings":"AAEA,4CAA4C;AAC5C,EAAE;AACF,kGAAkG;AAClG,gFAAgF;AAChF,qFAAqF;AACrF,mFAAmF;AACnF,sFAAsF;AACtF,+CAA+C;AAC/C,EAAE;AACF,kFAAkF;AAClF,iFAAiF;AACjF,iFAAiF;AACjF,qFAAqF;AACrF,sFAAsF;AACtF,oCAAoC;AAEpC,MAAM,CAAC,MAAM,MAAM,GAAU;IAC3B,IAAI,EAAE,QAAQ;IACd,WAAW,EAAE,ofAAof;IACjgB,WAAW,EAAE;;;;;;;;;;;;;;;;oGAgBwG;IACrH,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;CACtB,CAAC"}

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

@@ -1,4 +1,11 @@
-import { introspect } from '../introspect/skill.js';
+// COMPOSES NOTHING, and it never borrowed anything either. The retired
+// `composition: () => [introspect]` edge produced `Composed from /introspect.` on the
+// projected artifact while this block defined every sign it uses locally — `target`,
+// `target₀`, `foreign`, `attached`, `lifecycle`, `record` — and named none of
+// introspect's. A declared dependency with no borrow is a claim the artifact makes
+// and the cell cannot honour. The `runtime` capability below is the real coupling and
+// it stays: its four verbs take no corpus vocabulary, and `target` is the ADAPTER's to
+// name.
 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 }
@@ -32,6 +39,6 @@ export const eventTap = {
     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],
+    composition: () => [],
 };
 //# sourceMappingURL=skill.js.map

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

@@ -1 +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"}
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/event-tap/skill.ts"],"names":[],"mappings":"AAEA,uEAAuE;AACvE,sFAAsF;AACtF,qFAAqF;AACrF,8EAA8E;AAC9E,mFAAmF;AACnF,sFAAsF;AACtF,uFAAuF;AACvF,QAAQ;AAER,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,EAAE;CACtB,CAAC"}

package/dist/skills/exemplify/skill.js

@@ -1,6 +1,18 @@
-import { conceptualize } from '../conceptualize/skill.js';
-import { materialize } from '../materialize/skill.js';
-import { signify } from '../signify/skill.js';
+// COMPOSES NOTHING, and that is the repair.
+//
+// This cell used to declare `composition: () => [conceptualize, signify, materialize]` and import those
+// modules to do it. The thunk's only consumer is the trailing `Composed from …`
+// line of the projected SKILL.md (`forge/src/core/exemplify/skill-cell.ts`), so each
+// import bought one sentence of provenance and cost a module-level cycle: the four
+// signification cells each claimed to be composed from the other three, and no one of
+// them could be read, taken or deployed alone.
+//
+// The relation those edges named is CITATION, not dependency: `symbol-altitude`'s
+// LEDGER records these cells RESTATING each other's signs in different registers
+// (prose here, signature there), which is what a REFERENCE row means. A citation
+// belongs inside the block, at the sign that borrows it (`@ <cell>`), where it needs
+// no import and cannot cycle. Composition is the caller's: an agent pipes these cells
+// in whatever order the work wants.
 const FORMAL_BLOCK = `concept-record     ≜ ⟨ gloss , anchor? , factorization? ⟩
 sources            ≜ input material @ conceptualize ⟨the corpus D is drawn OVER, ¬ D itself⟩
 C                  ≜ concept lattice @ conceptualize
@@ -37,6 +49,6 @@ 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],
+    composition: () => [],
 };
 //# sourceMappingURL=skill.js.map

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

@@ -1 +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"}
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/exemplify/skill.ts"],"names":[],"mappings":"AAEA,4CAA4C;AAC5C,EAAE;AACF,wGAAwG;AACxG,gFAAgF;AAChF,qFAAqF;AACrF,mFAAmF;AACnF,sFAAsF;AACtF,+CAA+C;AAC/C,EAAE;AACF,kFAAkF;AAClF,iFAAiF;AACjF,iFAAiF;AACjF,qFAAqF;AACrF,sFAAsF;AACtF,oCAAoC;AAEpC,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BA+B2B,CAAC;AAEjD,MAAM,CAAC,MAAM,SAAS,GAAU;IAC9B,IAAI,EAAE,WAAW;IACjB,WAAW,EAAE,qNAAqN;IAClO,WAAW,EAAE,YAAY;IACzB,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;CACtB,CAAC"}

package/dist/skills/introspect/skill.js

@@ -2,7 +2,8 @@ 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 · … }
+O          ≜ enumerate(## sections @ A's live Target) ⟨READ · ¬ recalled · ∄ fixed-list ∵ corpus declares its own catalog⟩
+|O|        ≜ |enumerate(## sections @ A's live Target)| ⟨the DENOMINATOR⟩
 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 }
@@ -35,8 +36,11 @@ 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 ⟩
+report       ≜ ⟨ |O|, { row(o) | o ∈ O }, summary ⟩ ⟨|O| STATED⟩
 introspect(A) ≜ report
+|{ row(o) }| ≠ |O| ⇒ ⊥
+rt(o) ⊨ EXERCISED ⟨¬ inferred-from-absence⟩
+¬ exercised(o) ⇒ why(o) = unobservable ∧ why(o) ≠ harness-override
 
 ¬ edit(agent/<A>.md) ∧ ¬ redeploy ∧ ¬ mint(V)
 why(o) ∈ K_cfg            ⇒ reconcile @ { create-agent · deploy }

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

@@ -1 +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"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCA4CqC;IAClD,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;CACtB,CAAC"}

package/dist/skills/materialize/skill.js

@@ -1,6 +1,18 @@
-import { conceptualize } from '../conceptualize/skill.js';
-import { exemplify } from '../exemplify/skill.js';
-import { signify } from '../signify/skill.js';
+// COMPOSES NOTHING, and that is the repair.
+//
+// This cell used to declare `composition: () => [exemplify, signify, conceptualize]` and import those
+// modules to do it. The thunk's only consumer is the trailing `Composed from …`
+// line of the projected SKILL.md (`forge/src/core/exemplify/skill-cell.ts`), so each
+// import bought one sentence of provenance and cost a module-level cycle: the four
+// signification cells each claimed to be composed from the other three, and no one of
+// them could be read, taken or deployed alone.
+//
+// The relation those edges named is CITATION, not dependency: `symbol-altitude`'s
+// LEDGER records these cells RESTATING each other's signs in different registers
+// (prose here, signature there), which is what a REFERENCE row means. A citation
+// belongs inside the block, at the sign that borrows it (`@ <cell>`), where it needs
+// no import and cannot cycle. Composition is the caller's: an agent pipes these cells
+// in whatever order the work wants.
 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.`,
@@ -49,6 +61,6 @@ s unnamed ∨ s ∉ S ⇒ ⊥
     structure      ↦ table
     classification ↦ membership test
     utility        ↦ instrument`,
-    composition: () => [exemplify, signify, conceptualize],
+    composition: () => [],
 };
 //# sourceMappingURL=skill.js.map

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

@@ -1 +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"}
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/materialize/skill.ts"],"names":[],"mappings":"AAEA,4CAA4C;AAC5C,EAAE;AACF,sGAAsG;AACtG,gFAAgF;AAChF,qFAAqF;AACrF,mFAAmF;AACnF,sFAAsF;AACtF,+CAA+C;AAC/C,EAAE;AACF,kFAAkF;AAClF,iFAAiF;AACjF,iFAAiF;AACjF,qFAAqF;AACrF,sFAAsF;AACtF,oCAAoC;AAEpC,MAAM,CAAC,MAAM,WAAW,GAAU;IAChC,IAAI,EAAE,aAAa;IACnB,WAAW,EAAE,oZAAoZ;IACja,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA4CoC;IACjD,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;CACtB,CAAC"}

package/dist/skills/praxis/skill.js

@@ -16,9 +16,7 @@ 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 → 𝔹
+self     ≜ session⟨the harness's own session identity⟩
 owner   : P ⇀ session
 bound    : P → 𝔹 ⟨plan-level commitment · persists across sessions · ¬ shard-state⟩
 gates    : P × P → 𝔹
@@ -63,8 +61,7 @@ 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))
+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)
@@ -84,7 +81,7 @@ nextPhase     ≜ { proposed ↦ in-flight, in-flight ↦ landed, landed ↦ ret
 
 ∀ t ∈ P : t @ dir(P)/state(t)
 owner(P) @ dir(P)/.owner
-registered, released, stale @ memory-session-registry
+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⟩
@@ -132,7 +129,7 @@ retired(P) ⇒ P ∉ Plans ⟨retire removes the member · Plans is disk, ∴ ph
 ∀ 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⟩
+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))
@@ -166,7 +163,7 @@ upsert    : (P, intent) ↦ P' ≜ author census-grounded t(s) ∧ P' = P ∪ {t
 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
+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)

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

@@ -1 +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"}
+{"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"}

package/dist/skills/probe/skill.js

@@ -1,6 +1,18 @@
-import { conceptualize } from '../conceptualize/skill.js';
-import { elicit } from '../elicit/skill.js';
-import { signify } from '../signify/skill.js';
+// COMPOSES NOTHING, and that is the repair.
+//
+// This cell used to declare `composition: () => [signify, elicit, conceptualize]` and import those
+// modules to do it. The thunk's only consumer is the trailing `Composed from …`
+// line of the projected SKILL.md (`forge/src/core/exemplify/skill-cell.ts`), so each
+// import bought one sentence of provenance and cost a module-level cycle: the four
+// signification cells each claimed to be composed from the other three, and no one of
+// them could be read, taken or deployed alone.
+//
+// The relation those edges named is CITATION, not dependency: `symbol-altitude`'s
+// LEDGER records these cells RESTATING each other's signs in different registers
+// (prose here, signature there), which is what a REFERENCE row means. A citation
+// belongs inside the block, at the sign that borrows it (`@ <cell>`), where it needs
+// no import and cannot cycle. Composition is the caller's: an agent pipes these cells
+// in whatever order the work wants.
 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⟩
@@ -53,6 +65,6 @@ 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],
+    composition: () => [],
 };
 //# sourceMappingURL=skill.js.map

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

@@ -1 +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"}
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/probe/skill.ts"],"names":[],"mappings":"AAEA,4CAA4C;AAC5C,EAAE;AACF,mGAAmG;AACnG,gFAAgF;AAChF,qFAAqF;AACrF,mFAAmF;AACnF,sFAAsF;AACtF,+CAA+C;AAC/C,EAAE;AACF,kFAAkF;AAClF,iFAAiF;AACjF,iFAAiF;AACjF,qFAAqF;AACrF,sFAAsF;AACtF,oCAAoC;AAEpC,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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,EAAE;CACtB,CAAC"}

package/dist/skills/signify/skill.js

@@ -1,6 +1,18 @@
-import { conceptualize } from '../conceptualize/skill.js';
-import { exemplify } from '../exemplify/skill.js';
-import { materialize } from '../materialize/skill.js';
+// COMPOSES NOTHING, and that is the repair.
+//
+// This cell used to declare `composition: () => [exemplify, conceptualize, materialize]` and import those
+// modules to do it. The thunk's only consumer is the trailing `Composed from …`
+// line of the projected SKILL.md (`forge/src/core/exemplify/skill-cell.ts`), so each
+// import bought one sentence of provenance and cost a module-level cycle: the four
+// signification cells each claimed to be composed from the other three, and no one of
+// them could be read, taken or deployed alone.
+//
+// The relation those edges named is CITATION, not dependency: `symbol-altitude`'s
+// LEDGER records these cells RESTATING each other's signs in different registers
+// (prose here, signature there), which is what a REFERENCE row means. A citation
+// belongs inside the block, at the sign that borrows it (`@ <cell>`), where it needs
+// no import and cannot cycle. Composition is the caller's: an agent pipes these cells
+// in whatever order the work wants.
 export const signify = {
     name: 'signify',
     description: `use this skill to name a concept — assign each its canonical anchor so one name ⇔ one concept, discovered by cold decode against the model's priors, never coined; stage 2 of exemplify, independently invocable.`,
@@ -54,6 +66,6 @@ minimal(a) ⇔ ∄ c carried by a : a re-states fired(α(c))
 
 conform(a)  ⇔  register(a) = σ*
 verbatim(a) ⇒ register(a) = σ*`,
-    composition: () => [exemplify, conceptualize, materialize],
+    composition: () => [],
 };
 //# sourceMappingURL=skill.js.map

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

@@ -1 +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"}
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/signify/skill.ts"],"names":[],"mappings":"AAEA,4CAA4C;AAC5C,EAAE;AACF,0GAA0G;AAC1G,gFAAgF;AAChF,qFAAqF;AACrF,mFAAmF;AACnF,sFAAsF;AACtF,+CAA+C;AAC/C,EAAE;AACF,kFAAkF;AAClF,iFAAiF;AACjF,iFAAiF;AACjF,qFAAqF;AACrF,sFAAsF;AACtF,oCAAoC;AAEpC,MAAM,CAAC,MAAM,OAAO,GAAU;IAC5B,IAAI,EAAE,SAAS;IACf,WAAW,EAAE,mNAAmN;IAChO,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAiDmC;IAChD,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;CACtB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cratylus/canon",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "The canonical corpus of discovered optimal-signifiers — agents, skills, dimensions and rules as typed TS source. Markdown is a projection of these modules.",
   "license": "MIT",
   "engines": {
@@ -21,13 +21,13 @@
     "@cratylus/schema": "0.1.2"
   },
   "devDependencies": {
+    "@cratylus/forge": "0.4.1",
+    "@cratylus/runtime": "0.2.0",
+    "@cratylus/tooling": "0.0.0",
     "@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"
+    "vitest": "^2.1.0"
   },
   "publishConfig": {
     "access": "public"
@@ -53,7 +53,7 @@
   },
   "homepage": "https://github.com/leclabs/cratylus#readme",
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
+    "build": "pnpm run clean && tsc -p tsconfig.build.json",
     "clean": "rm -rf dist",
     "continuity": "sh targets/continuity/continuity-hook.sh",
     "dev": "tsc -p tsconfig.build.json --watch --preserveWatchOutput",
@@ -65,7 +65,7 @@
     "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",
+    "test": "vitest run",
     "typecheck": "tsc --noEmit",
     "typecheck:test": "tsc -p tsconfig.test.json"
   }

package/dist/agents/arch-doc-writer.d.ts

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

package/dist/agents/arch-doc-writer.js

@@ -1,54 +0,0 @@
-import { delegation as delegation_actions } from '../dimensions/actions/delegation.js';
-import { fileOps as fileOps_actions } from '../dimensions/actions/file-ops.js';
-import { toolCall as toolCall_actions } from '../dimensions/actions/tool-call.js';
-import { convergence as convergence_audienceAdaptation } from '../dimensions/audience-adaptation/convergence.js';
-import { systemDesign as systemDesign_capabilities } from '../dimensions/capabilities/system-design.js';
-import { technicalWriting as technicalWriting_capabilities } from '../dimensions/capabilities/technical-writing.js';
-import { neutral as neutral_formality } from '../dimensions/formality/neutral.js';
-import { systemsThinking as systemsThinking_framing } from '../dimensions/framing/systems-thinking.js';
-import { harmAvoidance as harmAvoidance_guardrails } from '../dimensions/guardrails/harm-avoidance.js';
-import { helpfulness as helpfulness_guardrails } from '../dimensions/guardrails/helpfulness.js';
-import { honesty as honesty_guardrails } from '../dimensions/guardrails/honesty.js';
-import { takeTheBest as takeTheBest_heuristics } from '../dimensions/heuristics/take-the-best.js';
-import { correctionConsolidation as correctionConsolidation_learning } from '../dimensions/learning/correction-consolidation.js';
-import { faithfulRecord as faithfulRecord_objective } from '../dimensions/objective/faithful-record.js';
-import { document as document_outputFormat } from '../dimensions/output-format/document.js';
-import { react as react_reasoningStrategy } from '../dimensions/reasoning-strategy/react.js';
-import { document as document_role } from '../dimensions/role/document.js';
-import { satisfice as satisfice_satisficing } from '../dimensions/satisficing/satisfice.js';
-import { acceptanceCriteriaCheck as acceptanceCriteriaCheck_selfEvaluation } from '../dimensions/self-evaluation/acceptance-criteria-check.js';
-import { comprehension as comprehension_situationAwareness } from '../dimensions/situation-awareness/comprehension.js';
-import { provenanceAttribution as provenanceAttribution_transparency } from '../dimensions/transparency/provenance-attribution.js';
-export const archDocWriter = {
-    name: 'arch-doc-writer',
-    description: 'Use this agent to explain how an existing system works for a human reader — a guide, reference, or ADR with every claim grounded; it documents, never alters the system.',
-    archetype: 'Sage archetype of the architecture record — render a system intelligible in reader-facing prose (guides · references · ADRs), describe ¬alter, every claim cited to its ground and marked observed-vs-inferred; the Principal-Technical-Writer lineage.',
-    role: document_role,
-    formality: neutral_formality,
-    audienceAdaptation: convergence_audienceAdaptation,
-    transparency: provenanceAttribution_transparency,
-    autonomy: null,
-    provenance: { mark: { emoji: '🏗️', hue: 'pink' } },
-    objective: faithfulRecord_objective,
-    guardrails: [
-        harmAvoidance_guardrails,
-        honesty_guardrails,
-        helpfulness_guardrails,
-    ],
-    heuristics: [takeTheBest_heuristics],
-    capabilities: [technicalWriting_capabilities, systemDesign_capabilities],
-    learning: correctionConsolidation_learning,
-    situationAwareness: comprehension_situationAwareness,
-    actions: [fileOps_actions, toolCall_actions, delegation_actions],
-    modalities: null,
-    model: null,
-    memory: null,
-    trigger: null,
-    framing: systemsThinking_framing,
-    reasoningStrategy: react_reasoningStrategy,
-    satisficing: satisfice_satisficing,
-    outputFormat: document_outputFormat,
-    selfEvaluation: acceptanceCriteriaCheck_selfEvaluation,
-    engineeringPrinciples: null,
-};
-//# sourceMappingURL=arch-doc-writer.js.map

package/dist/agents/arch-doc-writer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"arch-doc-writer.js","sourceRoot":"","sources":["../../src/agents/arch-doc-writer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,IAAI,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACvF,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAC/E,OAAO,EAAE,QAAQ,IAAI,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AAClF,OAAO,EAAE,WAAW,IAAI,8BAA8B,EAAE,MAAM,kDAAkD,CAAC;AACjH,OAAO,EAAE,YAAY,IAAI,yBAAyB,EAAE,MAAM,6CAA6C,CAAC;AACxG,OAAO,EAAE,gBAAgB,IAAI,6BAA6B,EAAE,MAAM,iDAAiD,CAAC;AACpH,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AAClF,OAAO,EAAE,eAAe,IAAI,uBAAuB,EAAE,MAAM,2CAA2C,CAAC;AACvG,OAAO,EAAE,aAAa,IAAI,wBAAwB,EAAE,MAAM,4CAA4C,CAAC;AACvG,OAAO,EAAE,WAAW,IAAI,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AAChG,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACpF,OAAO,EAAE,WAAW,IAAI,sBAAsB,EAAE,MAAM,2CAA2C,CAAC;AAClG,OAAO,EAAE,uBAAuB,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AACjI,OAAO,EAAE,cAAc,IAAI,wBAAwB,EAAE,MAAM,4CAA4C,CAAC;AACxG,OAAO,EAAE,QAAQ,IAAI,qBAAqB,EAAE,MAAM,yCAAyC,CAAC;AAC5F,OAAO,EAAE,KAAK,IAAI,uBAAuB,EAAE,MAAM,2CAA2C,CAAC;AAC7F,OAAO,EAAE,QAAQ,IAAI,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC3E,OAAO,EAAE,SAAS,IAAI,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAC5F,OAAO,EAAE,uBAAuB,IAAI,sCAAsC,EAAE,MAAM,4DAA4D,CAAC;AAC/I,OAAO,EAAE,aAAa,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AACvH,OAAO,EAAE,qBAAqB,IAAI,kCAAkC,EAAE,MAAM,sDAAsD,CAAC;AAEnI,MAAM,CAAC,MAAM,aAAa,GAAU;IAClC,IAAI,EAAE,iBAAiB;IACvB,WAAW,EACT,0KAA0K;IAC5K,SAAS,EACP,yPAAyP;IAC3P,IAAI,EAAE,aAAa;IACnB,SAAS,EAAE,iBAAiB;IAC5B,kBAAkB,EAAE,8BAA8B;IAClD,YAAY,EAAE,kCAAkC;IAChD,QAAQ,EAAE,IAAI;IACd,UAAU,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE;IACnD,SAAS,EAAE,wBAAwB;IACnC,UAAU,EAAE;QACV,wBAAwB;QACxB,kBAAkB;QAClB,sBAAsB;KACvB;IACD,UAAU,EAAE,CAAC,sBAAsB,CAAC;IACpC,YAAY,EAAE,CAAC,6BAA6B,EAAE,yBAAyB,CAAC;IACxE,QAAQ,EAAE,gCAAgC;IAC1C,kBAAkB,EAAE,gCAAgC;IACpD,OAAO,EAAE,CAAC,eAAe,EAAE,gBAAgB,EAAE,kBAAkB,CAAC;IAChE,UAAU,EAAE,IAAI;IAChB,KAAK,EAAE,IAAI;IACX,MAAM,EAAE,IAAI;IACZ,OAAO,EAAE,IAAI;IACb,OAAO,EAAE,uBAAuB;IAChC,iBAAiB,EAAE,uBAAuB;IAC1C,WAAW,EAAE,qBAAqB;IAClC,YAAY,EAAE,qBAAqB;IACnC,cAAc,EAAE,sCAAsC;IACtD,qBAAqB,EAAE,IAAI;CAC5B,CAAC"}

package/dist/agents/boz.d.ts

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