@cratylus/canon 0.3.0 → 0.5.0

package/dist/roles/hold.js

@@ -0,0 +1,105 @@
+// ─────────────────────────────────────────────────────────────────────────────
+// A ROLE, AND THE FOLD THAT RESOLVES ONE.
+//
+// A role is a BUNDLE OF EXPECTED ASPECTS. In the world, naming someone an architect
+// tells you how they reason, what they are accountable for, what they may decide and
+// what they must delegate; the corpus adopts that account because it is what the word
+// already means, and a corpus whose roles mean what roles mean needs no second
+// vocabulary for it.
+//
+// Before this module, `role` was a scalar dimension over bare tokens, so the corpus
+// could NAME a role and could not STATE one. Everything the name should have carried
+// was retyped on every holder — `kino` and `architect` agreed on 19 of 22 dimensions
+// by copying — and the duplication bought nothing, because what must be FULL is the
+// TARGET (a harness reads a flat declaration, never a resolution chain) and the fold
+// below runs at `select`, before `compose`. The emitted Target is exactly as flat as
+// it was when every value was retyped by hand.
+//
+// A ROLE IS NOT A DIMENSION, AND IT IS NOT A BASE CLASS. It is made OF dimension
+// values, so it cannot be one of them; and there is no lineage here — `architect` is
+// a thin holder of the architect role exactly as `kino` is, with no parent pointer, no
+// abstract cell nobody dispatches, and no chain to resolve. Two operands, one
+// precedence rule, no ordering question.
+//
+// SINGULAR ARITY IS THE POINT, not a simplification. A role is the CONTRACT A PEER
+// DISPATCHES AGAINST: when an architect hands a cut piece to a planner it reasons about
+// the planner's role to know what comes back. A union of roles is a contract no
+// dispatcher can reason about, and it would readmit role conflict — incompatible
+// demands between two positions held at once — which singular arity deletes outright.
+// The situational switch (the same practitioner architects here and implements there)
+// is modelled by DISPATCH: the situation selects which agent runs.
+//
+// WHAT A HOLDER MAY NOT ESCAPE is exactly one thing: the role's own contract, the
+// `role` dimension value stating ⟨reads, writes⟩ and everything that follows from the
+// pair. It is inviolable BY CONSTRUCTION rather than by a marking — `Declared` omits
+// the key, so there is no field to override and no rule to enforce. Every other aspect
+// a role supplies is a DEFAULT: a scalar the holder may override, a set the holder may
+// extend. A general constitutive/default marking was considered and rejected: with the
+// contract folded into the role's own value, no second aspect needed protecting, and a
+// mechanism with no live subject is structure that carries no load.
+// ─────────────────────────────────────────────────────────────────────────────
+import { kebabToCamel } from '@cratylus/schema';
+import { DIMENSION_NAMES, MANIFEST } from '../manifest.js';
+/**
+ * `select(a) = hold(a) ⊕ declare(a)` — the two-operand fold, run at authoring time so
+ * the projected Target stays flat.
+ *
+ * `⊕` reads the manifest's own `arity`, so the precedence rule is stated once and
+ * cannot disagree with itself:
+ *
+ *   · set    → role members first, then the holder's own — EXTEND. A role-supplied
+ *              member therefore survives every holder, which is why a set needs no
+ *              inviolability marking: union already guarantees it.
+ *   · scalar → the holder's value when the KEY IS PRESENT, else the role's — OVERRIDE.
+ *              Present-with-`null` is an explicit suppression and is honoured as one;
+ *              absent means "whatever the position says", which is the common case.
+ *
+ * A dimension neither operand states is `null` — omit-to-inherit, exactly as a
+ * hand-written vector spells it.
+ *
+ * `provenance.mark` NEVER folds: it is instance-bound, minted per agent at
+ * `create-agent`, and two agents sharing a mark are indistinguishable in the one place
+ * an operator reads them. It arrives on `declared` and leaves untouched.
+ */
+export function holds(role, declared) {
+    const resolved = {
+        name: declared.name,
+        description: declared.description,
+        archetype: declared.archetype,
+        provenance: declared.provenance,
+    };
+    if (declared.preamble !== undefined) {
+        resolved.preamble = declared.preamble;
+    }
+    const skills = [
+        ...(role.skills ?? []),
+        ...(declared.skills ?? []).filter((s) => !(role.skills ?? []).includes(s)),
+    ];
+    if (skills.length > 0) {
+        resolved.skills = skills;
+    }
+    const roleVector = role.vector;
+    const declaredVector = declared;
+    for (const dimension of DIMENSION_NAMES) {
+        const field = kebabToCamel(dimension);
+        if (dimension === 'role') {
+            resolved[field] = role.sign;
+            continue;
+        }
+        const fromRole = roleVector[field];
+        const stated = field in declaredVector ? declaredVector[field] : undefined;
+        if (MANIFEST[dimension].arity === 'set') {
+            const base = Array.isArray(fromRole) ? fromRole : [];
+            const extension = Array.isArray(stated) ? stated : [];
+            const union = [...base, ...extension.filter((v) => !base.includes(v))];
+            resolved[field] = union.length > 0 ? union : null;
+            continue;
+        }
+        resolved[field] =
+            field in declaredVector ? (stated ?? null) : (fromRole ?? null);
+    }
+    // The ONE cast, and it is structural rather than hopeful: the loop is driven by
+    // `DIMENSION_NAMES`, so every dimension field of `Agent` is assigned exactly once.
+    return resolved;
+}
+//# sourceMappingURL=hold.js.map

package/dist/roles/hold.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hold.js","sourceRoot":"","sources":["../../src/roles/hold.ts"],"names":[],"mappings":"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"}

package/dist/roles/implementer.d.ts

@@ -0,0 +1,2 @@
+import type { RoleCell } from './hold.js';
+export declare const implementerRole: RoleCell;

package/dist/roles/implementer.js

@@ -0,0 +1,62 @@
+import { fileOps as fileOps_actions } from '../dimensions/actions/file-ops.js';
+import { maintenance as maintenance_audienceAdaptation } from '../dimensions/audience-adaptation/maintenance.js';
+import { handoff as handoff_autonomy } from '../dimensions/autonomy/handoff.js';
+import { missionCommand } from '../dimensions/autonomy/mission-command.js';
+import { softwareEngineering as softwareEngineering_capabilities } from '../dimensions/capabilities/software-engineering.js';
+import { verificationTesting as verificationTesting_capabilities } from '../dimensions/capabilities/verification-testing.js';
+import { cratylism as cratylism_engineeringPrinciples } from '../dimensions/engineering-principles/cratylism.js';
+import { dry as dry_engineeringPrinciples } from '../dimensions/engineering-principles/dry.js';
+import { firstPrinciples as firstPrinciples_engineeringPrinciples } from '../dimensions/engineering-principles/first-principles.js';
+import { simplicity as simplicity_engineeringPrinciples } from '../dimensions/engineering-principles/simplicity.js';
+import { plain as plain_formality } from '../dimensions/formality/plain.js';
+import { correctnessOriented as correctnessOriented_framing } from '../dimensions/framing/correctness-oriented.js';
+import { honesty as honesty_guardrails } from '../dimensions/guardrails/honesty.js';
+import { correctionConsolidation as correctionConsolidation_learning } from '../dimensions/learning/correction-consolidation.js';
+import { correctness as correctness_objective } from '../dimensions/objective/correctness.js';
+import { react as react_reasoningStrategy } from '../dimensions/reasoning-strategy/react.js';
+import { implementer as implementer_role } from '../dimensions/role/implementer.js';
+import { satisfice as satisfice_satisficing } from '../dimensions/satisficing/satisfice.js';
+import { executableTestOracle as executableTestOracle_selfEvaluation } from '../dimensions/self-evaluation/executable-test-oracle.js';
+import { perception as perception_situationAwareness } from '../dimensions/situation-awareness/perception.js';
+import { limitationDisclosure as limitationDisclosure_transparency } from '../dimensions/transparency/limitation-disclosure.js';
+// THE BOTTOM RUNG, and the only one whose write layer is the substrate. It carries no
+// workflow skill by design: a skill guides an agent through decisions it must make, and
+// this position's decisions were made for it. It needs a unit of work, tools, and the
+// discipline to stay inside the boundary.
+export const implementerRole = {
+    sign: implementer_role,
+    vector: {
+        formality: plain_formality,
+        audienceAdaptation: maintenance_audienceAdaptation,
+        // `limitation-disclosure`: this position's entire value to the layer above is an
+        // honest account of what it could NOT establish. A clean report that hides an
+        // unproven leg is worse than a failure, because it is acted on.
+        transparency: limitationDisclosure_transparency,
+        autonomy: [missionCommand, handoff_autonomy],
+        objective: correctness_objective,
+        engineeringPrinciples: [
+            cratylism_engineeringPrinciples,
+            firstPrinciples_engineeringPrinciples,
+            simplicity_engineeringPrinciples,
+            dry_engineeringPrinciples,
+        ],
+        guardrails: [honesty_guardrails],
+        capabilities: [
+            softwareEngineering_capabilities,
+            verificationTesting_capabilities,
+        ],
+        actions: [fileOps_actions],
+        learning: correctionConsolidation_learning,
+        situationAwareness: perception_situationAwareness,
+        framing: correctnessOriented_framing,
+        reasoningStrategy: react_reasoningStrategy,
+        // `satisfice`, and it is the one aspect that must not be `optimize` here.
+        // Optimising past the spec IS the exceeding failure the contract names: this
+        // position builds to the contract and stops.
+        satisficing: satisfice_satisficing,
+        // The oracle is the spec's own criteria, executed. That is verification, and it is
+        // exactly right at this rung — it is only wrong when mistaken for validation.
+        selfEvaluation: executableTestOracle_selfEvaluation,
+    },
+};
+//# sourceMappingURL=implementer.js.map

package/dist/roles/implementer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"implementer.js","sourceRoot":"","sources":["../../src/roles/implementer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAC/E,OAAO,EAAE,WAAW,IAAI,8BAA8B,EAAE,MAAM,kDAAkD,CAAC;AACjH,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAChF,OAAO,EAAE,cAAc,EAAE,MAAM,2CAA2C,CAAC;AAC3E,OAAO,EAAE,mBAAmB,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AAC7H,OAAO,EAAE,mBAAmB,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AAC7H,OAAO,EAAE,SAAS,IAAI,+BAA+B,EAAE,MAAM,mDAAmD,CAAC;AACjH,OAAO,EAAE,GAAG,IAAI,yBAAyB,EAAE,MAAM,6CAA6C,CAAC;AAC/F,OAAO,EAAE,eAAe,IAAI,qCAAqC,EAAE,MAAM,0DAA0D,CAAC;AACpI,OAAO,EAAE,UAAU,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AACpH,OAAO,EAAE,KAAK,IAAI,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAC5E,OAAO,EAAE,mBAAmB,IAAI,2BAA2B,EAAE,MAAM,+CAA+C,CAAC;AACnH,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACpF,OAAO,EAAE,uBAAuB,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AACjI,OAAO,EAAE,WAAW,IAAI,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAC9F,OAAO,EAAE,KAAK,IAAI,uBAAuB,EAAE,MAAM,2CAA2C,CAAC;AAC7F,OAAO,EAAE,WAAW,IAAI,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AACpF,OAAO,EAAE,SAAS,IAAI,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAC5F,OAAO,EAAE,oBAAoB,IAAI,mCAAmC,EAAE,MAAM,yDAAyD,CAAC;AACtI,OAAO,EAAE,UAAU,IAAI,6BAA6B,EAAE,MAAM,iDAAiD,CAAC;AAC9G,OAAO,EAAE,oBAAoB,IAAI,iCAAiC,EAAE,MAAM,qDAAqD,CAAC;AAGhI,sFAAsF;AACtF,wFAAwF;AACxF,sFAAsF;AACtF,0CAA0C;AAE1C,MAAM,CAAC,MAAM,eAAe,GAAa;IACvC,IAAI,EAAE,gBAAgB;IACtB,MAAM,EAAE;QACN,SAAS,EAAE,eAAe;QAC1B,kBAAkB,EAAE,8BAA8B;QAClD,iFAAiF;QACjF,8EAA8E;QAC9E,gEAAgE;QAChE,YAAY,EAAE,iCAAiC;QAC/C,QAAQ,EAAE,CAAC,cAAc,EAAE,gBAAgB,CAAC;QAC5C,SAAS,EAAE,qBAAqB;QAChC,qBAAqB,EAAE;YACrB,+BAA+B;YAC/B,qCAAqC;YACrC,gCAAgC;YAChC,yBAAyB;SAC1B;QACD,UAAU,EAAE,CAAC,kBAAkB,CAAC;QAChC,YAAY,EAAE;YACZ,gCAAgC;YAChC,gCAAgC;SACjC;QACD,OAAO,EAAE,CAAC,eAAe,CAAC;QAC1B,QAAQ,EAAE,gCAAgC;QAC1C,kBAAkB,EAAE,6BAA6B;QACjD,OAAO,EAAE,2BAA2B;QACpC,iBAAiB,EAAE,uBAAuB;QAC1C,0EAA0E;QAC1E,6EAA6E;QAC7E,6CAA6C;QAC7C,WAAW,EAAE,qBAAqB;QAClC,mFAAmF;QACnF,8EAA8E;QAC9E,cAAc,EAAE,mCAAmC;KACpD;CACF,CAAC"}

package/dist/roles/planner.d.ts

@@ -0,0 +1,2 @@
+import type { RoleCell } from './hold.js';
+export declare const plannerRole: RoleCell;

package/dist/roles/planner.js

@@ -0,0 +1,73 @@
+import { fileOps as fileOps_actions } from '../dimensions/actions/file-ops.js';
+import { maintenance as maintenance_audienceAdaptation } from '../dimensions/audience-adaptation/maintenance.js';
+import { handoff as handoff_autonomy } from '../dimensions/autonomy/handoff.js';
+import { missionCommand } from '../dimensions/autonomy/mission-command.js';
+import { planningDecomposition as planningDecomposition_capabilities } from '../dimensions/capabilities/planning-decomposition.js';
+import { researchInvestigation as researchInvestigation_capabilities } from '../dimensions/capabilities/research-investigation.js';
+import { cratylism as cratylism_engineeringPrinciples } from '../dimensions/engineering-principles/cratylism.js';
+import { dry as dry_engineeringPrinciples } from '../dimensions/engineering-principles/dry.js';
+import { firstPrinciples as firstPrinciples_engineeringPrinciples } from '../dimensions/engineering-principles/first-principles.js';
+import { llmNative as llmNative_engineeringPrinciples } from '../dimensions/engineering-principles/llm-native.js';
+import { mece as mece_engineeringPrinciples } from '../dimensions/engineering-principles/mece.js';
+import { simplicity as simplicity_engineeringPrinciples } from '../dimensions/engineering-principles/simplicity.js';
+import { plain as plain_formality } from '../dimensions/formality/plain.js';
+import { decompositional as decompositional_framing } from '../dimensions/framing/decompositional.js';
+import { honesty as honesty_guardrails } from '../dimensions/guardrails/honesty.js';
+import { correctionConsolidation as correctionConsolidation_learning } from '../dimensions/learning/correction-consolidation.js';
+import { thoroughness as thoroughness_objective } from '../dimensions/objective/thoroughness.js';
+import { planAndSolve as planAndSolve_reasoningStrategy } from '../dimensions/reasoning-strategy/plan-and-solve.js';
+import { planner as planner_role } from '../dimensions/role/planner.js';
+import { optimize as optimize_satisficing } from '../dimensions/satisficing/optimize.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';
+// THE MIDDLE RUNG. Holds `mission-command` and `handoff` but NOT `principal-self`: the
+// boundary was drawn above it, and the contract's `⊄ writes C` is what makes that
+// refusal structural rather than a matter of discipline.
+//
+// `system-design` is absent alongside `software-engineering` — this position neither
+// designs nor builds. What it owns is the census and the cut-into-units.
+export const plannerRole = {
+    sign: planner_role,
+    // The role declares one skill, `plan`, and is given plan's composition with it
+    // (`design`, `note`), so it reads the boundary it plans inside. `deliver` belongs
+    // to the rung ABOVE, which draws that boundary; the rung BELOW declares none at
+    // all, because an implementer's decisions are made for it by its spec.
+    skills: ['plan'],
+    vector: {
+        formality: plain_formality,
+        audienceAdaptation: maintenance_audienceAdaptation,
+        // `provenance-attribution`: a census is only worth what its sourcing is worth, and
+        // a count quoted without its denominator is indistinguishable from not having
+        // looked. Every finding carries where it came from and whether it was observed or
+        // inferred.
+        transparency: provenanceAttribution_transparency,
+        autonomy: [missionCommand, handoff_autonomy],
+        // `thoroughness`, not `delivery`: this position ships no artifact a user sees, and
+        // its failure mode is an incomplete census rather than a slow one.
+        objective: thoroughness_objective,
+        engineeringPrinciples: [
+            cratylism_engineeringPrinciples,
+            llmNative_engineeringPrinciples,
+            firstPrinciples_engineeringPrinciples,
+            simplicity_engineeringPrinciples,
+            dry_engineeringPrinciples,
+            mece_engineeringPrinciples,
+        ],
+        guardrails: [honesty_guardrails],
+        capabilities: [
+            planningDecomposition_capabilities,
+            researchInvestigation_capabilities,
+        ],
+        learning: correctionConsolidation_learning,
+        // `comprehension`, where the architect holds `projection`: this position's job is
+        // to establish what IS, exhaustively, not to anticipate what follows.
+        situationAwareness: comprehension_situationAwareness,
+        framing: decompositional_framing,
+        reasoningStrategy: planAndSolve_reasoningStrategy,
+        satisficing: optimize_satisficing,
+        actions: [fileOps_actions],
+        selfEvaluation: acceptanceCriteriaCheck_selfEvaluation,
+    },
+};
+//# sourceMappingURL=planner.js.map

package/dist/roles/planner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner.js","sourceRoot":"","sources":["../../src/roles/planner.ts"],"names":[],"mappings":"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"}

package/dist/skills/deliver/skill.js

@@ -1,4 +1,5 @@
 import { design } from '../design/skill.js';
+import { note } from '../note/skill.js';
 import { plan } from '../plan/skill.js';
 // WHERE THE TRUST DEFECT IS CLOSED. Acceptance keyed to a unit's own criteria is a
 // closed loop: the author writes the unit, writes its criteria, and checks the return
@@ -16,8 +17,27 @@ import { plan } from '../plan/skill.js';
 // rather than convenient: a check costing more than redoing the work is skipped, and
 // no instruction survives that gradient. Naming discipline is what buys the cheapness —
 // if the artifact spells its concept, two of the three are reading a name.
+//
+// WHERE THE READ GOES, AND WHY THE VERDICT DOES NOT FOLLOW IT. `validate ⊨ artifact` is
+// right and it has a cost: reading artifacts is reading files — paths, identifiers, call
+// sites — which is exactly the mechanical work the architect's contract calls a descent.
+// Left there, the skill obliges the design-holder to descend on every wave, and by the
+// third wave the design-holder is a code reviewer holding a lattice it can no longer
+// carry. So `validate` is two operations under one name and they separate cleanly: the
+// ASSAY (read the landed artifact, re-derive which concepts it realizes) is mechanical,
+// substrate-bound and DELEGABLE; the JUDGMENT (what an unachieved concept means —
+// rejection, an `amend(C)` because execution established a yield, or a design that was
+// wrong) is keyed to C and is NOT.
+//
+// A THIRD PARTY DOES NOT REOPEN THE DEFECT THIS CELL CLOSES. The law forbids accepting
+// on a claim from the party that BUILT the thing: one description, a closed loop. There
+// are still two descriptions here and they are still held by different parties — the
+// executor holds the spec and not the design, the assayer holds the design and not the
+// spec. The artifact read the law demands still happens; it happens at the one site in
+// the loop where reading substrate is the work rather than a descent, and what reaches
+// the principal is in the only vocabulary the principal can check without descending.
 const FORMAL_BLOCK = `C      @ design
-c      ≜ a concept ⟨c ∈ C⟩
+c      @ design
 anchor @ design
 gloss  @ design
 factors @ design
@@ -25,74 +45,94 @@ denotes @ design
 amend  @ design
 yield  ≜ what execution established ∧ ¬ derivable from C
 P      @ plan
-unit      ≜ a unit of work
+unit   @ plan
 wave   @ plan
 frontier @ plan
 realizes @ plan
+advance, bind, close, bound, ready @ plan
+show ⟨C⟩ @ design
+show ⟨P ∧ unit⟩ @ plan
 accept @ plan ⟨the MECHANICAL half⟩
 outputs @ plan
 artifact : P → ℘(path) ⟨what landed · the EVIDENCE⟩
 r      ≜ an executor's return
 conform @ signify
 executor : P ⇀ agent
-self   ≜ the principal ⟨the design-holder⟩
+self   @ design
+capture @ note
 spells : path × anchor → 𝔹 ⟨identifiers · path · public surface bear the sign⟩
 covers : path × ℘(C) → 𝔹 ⟨observable behaviour ≅ the factorization · nothing missing
          ∧ nothing extra⟩
 sole   : path × anchor → 𝔹 ⟨∄ other artifact realizing the same concept⟩
 verify : P × return → 𝔹 ⟨the EXECUTOR's · built-it-right, against spec⟩
 validate : P → 𝔹 ⟨the PRINCIPAL's · built-the-right-thing, against C⟩
+assay  : artifact → ℘(C) ⟨which concepts the artifact ACTUALLY realizes · the REVERSE of plan⟩
+assayer : unit ⇀ agent ⟨role = assayer · holds C ∧ ¬ holds spec(unit)⟩
+achieved : unit → 𝔹 ⟨the three questions, answered against the assay⟩
+unachieved : unit → ℘(⟨c, uncovered-factor, locus⟩) ⟨what crosses UPWARD⟩
 defect ≜ ⟨symptom, locus, provenance⟩
 impedes : defect × P → 𝔹
 cost   : act → effort
-bound  : P → 𝔹 ⟨plan-level commitment · persists across sessions⟩
+file(d) ≜ capture(d) ⟨its topic names the unit as \`u of plan p\` · beside the path ∴ it blocks nothing⟩
 electable ≜ { P | ¬terminal(P) ∧ ¬occupied(P) }
 terminal : P → 𝔹
-commit @ design
-accepts @ design
 
 ∀ unit, r : ¬conform(r) ⇒ ¬accept(unit)(r)
-validate(unit) ⇔ spells(artifact(unit), realizes(unit))
+achieved(unit) ⇔ realizes(unit) ∈ assay(artifact(unit))
+    ∧ spells(artifact(unit), realizes(unit))
     ∧ covers(artifact(unit), factors(denotes(realizes(unit))))
     ∧ sole(artifact(unit), realizes(unit))
+unachieved(unit) = ∅ ⇔ achieved(unit)
+unachieved ⊨ C-typed ⟨it crosses in C's OWN vocabulary · mechanism-prose ⟨naming · structure ·
+    test-quality⟩ ⇒ REFUSE ∵ it descends the principal it was dispatched to spare⟩
+locus ⊨ ROUTED ∧ ¬ read ⟨an ADDRESS so the redispatch has one · a citation is substrate, and
+    handing the principal substrate is the same defect in smaller pieces⟩
+assay ⊨ artifact ⟨the ASSAYER reads the files · the ONE site in the loop where
+    substrate-reading is ¬ a descent⟩
+assayer ⊥ executor ⟨TWO descriptions, two witnesses : executor holds spec ∧ ¬ holds C ·
+    assayer holds C ∧ ¬ holds spec⟩
+validate(unit) ≜ unachieved(unit) = ∅ ⟨the principal JUDGES the assay ∧ ¬ re-reads the
+    artifact · the READ is delegable · the VERDICT is ¬ delegable ∵ keyed to C, which the
+    principal alone amends⟩
 validate ⊨ artifact ⟨NEVER r · a summary is a CLAIM ∧ the file is EVIDENCE ·
     an acceptance that read only the return has accepted nothing⟩
 validate ⊨ self ⟨¬ delegable · the executor cannot judge its own conformance ∵ it
     holds the spec ∧ ¬ the design⟩
 verify ⊥ validate ⟨two checks, two witnesses · neither substitutes ; an executor's
     green suite proves the EXECUTOR's own assertion ∧ nothing about the design⟩
-judge(unit) ≜ verify(unit, r) ∧ validate(unit) ⇒ advance(unit) ; ¬ ⇒ r rejected back to
-    executor(unit) ∧ state(unit) stays active
+judge(unit) ≜ verify(unit, r) ∧ validate(unit) ⇒ advance(unit) ⟨the acceptance⟩ ; ¬ ⇒ r rejected
+    back to executor(unit) ∧ ¬advance(unit)
     ⟨r lands VERBATIM ≺ any verdict on it · the loss mode is read-reason-discard,
      and it takes everything when a run dies mid-judgement⟩
     ⟨fan-in is as order-sensitive as fan-out : ∀ unit dispatched, confirm executor(unit)
      RETURNED · outputs(unit) exist ≠ executor(unit) returned⟩
+¬validate(unit) ⇒ redispatch(executor(unit), unachieved(unit)) ⟨the flaw handed down is
+    CONCEPTUAL ∧ ¬ a review⟩
 cost(validate) < cost(rebuild) ⟨else the gradient points at skipping · the cheapness
     is BOUGHT by conform(anchor) ∴ naming discipline is the verification budget⟩
 ¬spells ⇒ REFUSE ≺ any behavioural read ⟨the traceability arrow breaks at the cheapest
     place it will ever be visible⟩
 ¬covers ∧ extra ⇒ a second concept smuggled in unnamed ⇒ amend(C) ∨ REFUSE
 ¬sole ⇒ duplication ⟨the observable signature of a vision that fragmented⟩
-dispatch(P) ≜ ∀ unit ∈ frontier(P) ⟨state(unit) = ready⟩ concurrently ⟨state(unit) := active ∧
+dispatch(P) ≜ ∀ unit ∈ frontier(P) ⟨ready(unit)⟩ concurrently ⟨advance(unit) ∧
     executor(unit) runs spec(unit)⟩ ; pre bound(P) ∧ ⊨ disjoint-outputs
-yield ≠ ∅ ⇒ amend(C) @ design ⟨LIVE, ¬ at retirement⟩
-∀ k : amends(k, c) ⇒ ¬accepts(k) ⟨the amendment and the acceptance motivating it are
-    two commits · fused, the agent adjusts the concept its artifact failed ∧ declares
-    success ⟨evidence MANUFACTURED⟩⟩
+∀ c : ∄ unit ⟨realizes(unit) = anchor(c)⟩ ⇒ SURFACE ⟨a concept nothing builds is design agreed ∧
+    unbuilt · the reverse orphan is plan's⟩
 impedes(d, unit) ⇔ d standing ⇒ ∄ r : accept(unit)(r)
 impedes(d, unit) ⇒ fix(d) ⟨a regression in the path is repaired, ¬ surfaced⟩
 ¬impedes(d, unit) ⇒ file(d) ∧ ¬fix(d) ⟨a defect BESIDE the path is filed, ¬ chased⟩
 cost(file) < cost(fix) ⟨else the gradient points at chasing · the load-bearing law⟩
-∃ P : ¬terminal(P) ⇒ ∃! P : bound(P) ⟨WIP = 1 · finish before starting⟩
+∃ P : ¬terminal(P) ⇒ ∃ P : bound(P) ⟨WIP = 1, held by bind : it returns the plan bound before ·
+    finish before starting⟩
 elect ≜ in-flight ≻ gating ≻ operator-intent ⟨lexicographic⟩
-terminal(P) ⇒ retire(P) ⟨obligation ¬ permission · an unretired terminal plan is WIP
-    that is not work⟩ ; C persists ⟨plans come ∧ go ABOVE the design⟩
-deliver ≜ bind → dispatch(wave) → verify ⟨executor⟩ → validate ⟨self, on artifact⟩ →
-    judge → amend(C) ⇔ yield → advance → retire`;
+terminal(P) ⇒ close(P) ⟨obligation ¬ permission · an unclosed terminal plan is WIP
+    that is not work · a closed plan stays readable⟩ ; C persists ⟨plans come ∧ go ABOVE the design⟩
+deliver ≜ bind → dispatch(wave) → verify ⟨executor⟩ → assay ⟨assayer, on artifact⟩ →
+    validate ⟨self, on the assay⟩ → judge → amend(C) ⇔ yield → advance → close`;
 export const deliver = {
     name: 'deliver',
     description: `use this skill to execute a plan and ACCEPT its results — dispatch a wave of units to executors, then validate each landed artifact against the design rather than against the executor's report, and integrate. Reach for it whenever delegated work comes back. Validation is three cheap questions — does the artifact spell its concept's name, does its behaviour cover that concept's factorization exactly, and does anything else already realize it — read off the files themselves, never off a summary. It also carries the conduct of the work: one plan bound at a time, finish before starting, repair what blocks the path and merely file what sits beside it.`,
     formalBlock: FORMAL_BLOCK,
-    composition: () => [design, plan],
+    composition: () => [design, plan, note],
 };
 //# sourceMappingURL=skill.js.map

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

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

package/dist/skills/design/skill.js

@@ -1,5 +1,5 @@
-// THE DURATIVE HALF. `plan` and `deliver` are per-effort and disposable; this cell
-// is the one that persists, and that asymmetry is the whole point of the trio.
+// THE DURATIVE HALF. `plan` and `deliver` are per-effort; this cell is the one that
+// persists across every effort, and that asymmetry is the whole point of the trio.
 //
 // It exists because the corpus could DO long-horizon work and could only THINK in
 // single sittings: every conceptual cell (conceptualize · signify · materialize ·
@@ -16,7 +16,7 @@
 // operation rather than a re-reading of the claim. That statement is this lattice.
 const FORMAL_BLOCK = `anchor ≜ a concept's canonical sign @ signify
 gloss  ≜ what a concept IS ⟨one line · reconstruction-grade⟩
-C      ≜ the concept lattice ⟨the project's durative record⟩
+C      ≜ the concept lattice ⟨the project's durative model⟩
 c      ≜ a concept ⟨c ∈ C⟩
 concept ≜ ⟨ anchor(c) , gloss(c) , factors(c) ⟩
 factors : C → ℘(C) ⟨what c decomposes into⟩
@@ -28,52 +28,59 @@ denotes : anchor ⇀ C
 conform @ signify
 Piece  ≜ a cut piece ⟨what a planner is handed⟩
 cut    : C → ℘(℘(C))
-digest : ℘(C) → hash ⟨content address of a piece⟩
-pin    : Piece ⇀ hash ⟨the digest a piece was DERIVED from · carried with it⟩
-Phase  ≜ { live, superseded }
-phase  : C → Phase
-supersededBy : C ⇀ C
-commit ≜ a VCS commit ⟨the append-only carrier · attribution ∧ order⟩
-amends : commit × C → 𝔹
-accepts : commit → 𝔹 ⟨the commit carries an acceptance @ deliver⟩
-realizes : unit ⇀ anchor @ plan
+history(c) ≜ every version ∧ retraction of c, in order ⟨resident · ¬ deleted⟩
+settled(c) ⇔ c has exactly one current version
+live(c) ⇔ settled(c) ∧ that version ¬ a retraction
+withdrawn(c) ⇔ settled(c) ∧ c retracted
+diverged(c) ⇔ ¬settled(c) ⟨concurrent sessions wrote c differently ∧ merged · state, ¬ error⟩
+incoherent(C) ⇔ a law below broken across concepts by a merge ∧ kept on each branch
 yield  ≜ what execution established ∧ ¬ derivable from C @ deliver
-self   ≜ the principal ⟨the design-holder · ¬ delegable⟩
+self   ≜ the principal ⟨the architect · the design-holder · ¬ delegable⟩
 author : C ⇀ self
+show(C) ≜ \`scripts/design.mjs show [<concept>]\` ↦ C root to primitive ∨ one c in full
+define(c) ≜ \`scripts/design.mjs define <anchor> --gloss <g> [--factors <anchor>]…\`
+supersede(c) ≜ \`scripts/design.mjs amend <concept> [--anchor <a>] [--gloss <g>] [--factors <anchor>]…\` ⟨a new version of the SAME c · amending a withdrawn c reinstates it⟩
+retract(c) ≜ \`scripts/design.mjs retract <concept>\` ⟨c withdrawn · no successor version⟩
+reconcile(c) ≜ \`scripts/design.mjs reconcile <concept> [--anchor <a>] [--gloss <g>] [--factors <anchor>]…\` ⟨one version superseding every current version of c⟩
+trace(c) ≜ \`scripts/design.mjs trace <concept>\` ↦ ⟨history(c), closure(c), blast(c)⟩ ⟨how c came to be · what it stands on · what stands on it⟩
 
-∀ c : ∃! anchor(c) ∧ ∀ a ∈ dom(denotes) : ∃! denotes(a) ⟨one name ⇔ one concept⟩
+∀ define ∨ supersede ∨ retract ∨ reconcile : \`--author <who> --reason <why> --cause <what caused it>\` ⟨a set-valued flag repeats, one member each⟩
+∀ c : ∃! anchor(c) ∧ ∀ a ∈ dom(denotes) : ∃! denotes(a) ⟨one live concept per anchor⟩
+withdrawn(c) ⇒ anchor(c) held until supersede(c) reinstates it
 ∀ c : conform(anchor(c)) ∧ gloss(c) ≠ ∅
-∀ c : closure(c) finite ⟨factors acyclic ∴ a lattice, ¬ a graph⟩
+∀ c : closure(c) finite ⟨factors acyclic ∴ a lattice, ¬ a graph⟩ ∧ ∀ f ∈ factors(c) : live(f)
+∃ d : live(d) ∧ c ∈ factors(d) ⇒ ¬ retract(c) ⟨what live concepts factor on cannot be withdrawn⟩
 amend(C) ≜ supersede ⟨∄ overwrite ; a live c is NEVER edited in place⟩
     ⟨the protection is ¬ a rule about honesty : an editable lattice lets the agent
      adjust the concept its artifact failed, ∴ acceptance-against-C goes CIRCULAR
      with one extra step ∧ the loop manufactures its own evidence⟩
-supersede(c, c') ⇒ phase(c) := superseded ∧ supersededBy(c) = c' ∧ c ∈ C
-    ⟨residence, ¬ deletion : a reader of the CURRENT state sees the history without
-     a VCS query ∴ the lattice is self-describing⟩
-∀ k : amends(k, c) ⇒ ¬ accepts(k) ⟨THE separation · an amendment and an acceptance
-    it bears on are two acts ; fused, the second witness collapses into the first⟩
-∀ k : amends(k, c) ⇒ reason(k) ≠ ∅ ⟨attribution ∧ order are what make retroactive
-    justification DETECTABLE : the amendment postdates the artifact it excuses⟩
+supersede(c) ⇒ the prior version stays in history(c) ⟨residence, ¬ deletion : trace(c) reads
+    the history without a VCS query ∴ the lattice is self-describing⟩
+c becomes another concept ⇒ retract(c) ∧ define(c') ⟨¬ supersede : a new version is the SAME concept⟩
+∀ define ∨ supersede ∨ retract ∨ reconcile : reason ≠ ∅ ⟨attribution ∧ order are what make
+    retroactive justification DETECTABLE : the amendment postdates the artifact it excuses⟩
+reconcile ⊨ amend(C) ∧ ¬ an acceptance ⟨THE separation · a reconciliation never shares a write
+    with an acceptance it bears on ; fused, the second witness collapses into the first⟩
+diverged(c) ⇒ reconcile(c) ⟨an ordinary write on c refuses⟩
+incoherent(C) ⇒ repaired by ordinary writes, one at a time
+reconcile ⊨ self ⟨reconciliation of the design is the architect's alone⟩
+planner ∨ implementer ∨ assayer ⊨ diverged ∨ incoherent ⇒ report ∧ ¬ resolve
 blast(c) ≜ { d ∈ C | c ∈ closure(d) } ⟨DERIVED, ¬ guessed · what the normal form buys⟩
 churn(primitive) high ⇒ conceptualization wrong ⟨primitives near-stable · composites move⟩
 ⋃ cut(C) = C ∧ ∀ s₁, s₂ ∈ cut(C) : s₁ ≠ s₂ ⇒ s₁ ∩ s₂ = ∅
 ∀ s ∈ cut(C) : ∀ c ∈ s : closure(c) ⊆ s ⟨a piece is CLOSED ∴ plannable alone⟩
 cut ⊨ self ⟨the ASSIGNMENT of concepts to pieces is the design-holder's ; a planner
     receiving a piece may ¬ redraw it · a boundary it cannot plan is SURFACED⟩
-∀ s ∈ cut(C) : pin(s) = digest(s) ⟨a piece carries the digest it was derived from ∴
-    an amendment mid-flight surfaces as DRIFT, ¬ executes silently⟩
 yield ≠ ∅ ⇒ amend(C) ⟨intake at INCEPTION ∧ live, never at retirement : an obligation
     standing between an agent and closing its work always loses · measured 0 of 25⟩
-∀ c : ∄ unit ⟨realizes(unit) = anchor(c)⟩ ⇒ SURFACE ⟨a concept nothing builds is design agreed ∧
-    unbuilt · the reverse orphan is plan's⟩
 design ⊨ ¬ delegable ⟨a subagent starts blank ∧ a design authored by several
     fragments BY CONSTRUCTION⟩
-design ≜ conceptualize(intent) → signify(·) → materialize(·) → C ⟨bind⟩ → cut(C)`;
+design ≜ conceptualize(intent) → signify(·) → materialize(·) → define(c) ∨ supersede(c) → C → cut(C)`;
 export const design = {
     name: 'design',
-    description: `use this skill to build and hold a project's DURATIVE conceptual model — the one artifact that outlives every plan: each concept's anchor, gloss and factorization, amended only by append-only supersession, and cut into closed pieces a planner can take. Reach for it FIRST on any long-horizon effort, before any work is decomposed, and again whenever execution establishes something the model does not yet hold. It is what acceptance is judged against, so without it verification has no referent and degrades into re-reading the executor's own claim.`,
+    description: `use this skill to build and hold a project's DURATIVE conceptual model — the one artifact that outlives every plan: each concept's anchor, gloss and factorization, amended only by append-only supersession, and cut into closed pieces a planner can take. Its verbs show the design or one concept, define, amend, retract and reconcile a concept, and trace how one came to be, what it stands on and what stands on it. Reach for it FIRST on any long-horizon effort, before any work is decomposed, and again whenever execution establishes something the model does not yet hold. It is what acceptance is judged against, so without it verification has no referent and degrades into re-reading the executor's own claim.`,
     formalBlock: FORMAL_BLOCK,
+    runtime: { capability: 'design' },
     composition: () => [],
 };
 //# sourceMappingURL=skill.js.map

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

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

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

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

package/dist/skills/note/skill.js

@@ -0,0 +1,56 @@
+// THE NOTEBOOK'S OWN RULES, and no one else's. This cell routes the reader's notebook
+// intents to the `note` capability and is the one home of the three kinds: the
+// runtime carries a kind as a label it never interprets, so nothing else spells them.
+//
+// It rectifies an earlier ledger skill kept outside this corpus. That one addressed a
+// note by a sequential number, grew a note in place by appending "derived" material
+// beside a frozen definition, treated a withdrawal as one more kind, and taught its
+// reader the mechanics of how the ledger was stored. Here a note is addressed by its
+// title, every change is a whole new version, withdrawal is a verb, and the reader meets
+// only notes. No kind is privileged to block: any live note that names a plan or unit
+// owes a ruling, whatever its kind.
+//
+// COMPOSES NOTHING. The `runtime` capability below is the real coupling; its verbs take
+// the notebook's words and nothing borrowed.
+const NOTE_BLOCK = `note         ≜ show → capture → revise → retract → reconcile
+route        ≜ \`scripts/note.mjs <verb>\` ⟨runtime-bound : every verb reaches the note capability⟩
+verb         ∈ { show · capture · revise · retract · reconcile }
+notebook     ≜ the set of notes ⟨ideas, questions ∧ decisions ¬ yet canonical⟩
+n            ≜ a note ⟨n ∈ notebook⟩
+title(n)     ≜ the note's name
+kind(n)      ∈ { idea · question · decision } ⟨a label the runtime never interprets⟩
+topic(n)     ≜ what the note is about ⟨the notebook groups by kind, then topic⟩
+body(n)      ≜ the note's whole statement
+blocks(n)    ≜ the plans ∧ units n names ⟨a plan by its name · a unit as \`u of plan p\`, bare u only where the unit's name is its own⟩
+live(n)      ≜ n captured ∧ ¬ retracted
+versions(n)  ≜ the competing versions of n a merge left standing
+diverged(n)  ⇔ versions(n) disagree
+owed(n)      ⇔ live(n) ∧ blocks(n) ≠ ∅ ⟨an owed ruling⟩
+holders(t)   ≜ { n | live(n) ∧ title(n) = t } ∪ { n | diverged(n) ∧ ∃ v ∈ versions(n) : title(v) = t }
+incoherent(t) ⇔ |holders(t)| > 1 ⟨a merge left title t held by more than one note ; show prints each holder with its identity beside t⟩
+by           ≜ \`--author <who> --reason <why> --cause <what caused it>\` ⟨every write carries it⟩
+
+show(n?)     ≜ \`scripts/note.mjs show [<title>]\` ↦ owed rulings, diverged notes ∧ incoherent titles first, then the notebook by kind, then topic ∨ n in full ⟨every version of a diverged n · every holder of an incoherent title⟩
+capture(n)   ≜ \`scripts/note.mjs capture <title> --kind <k> --topic <t> --body <b> [--blocks <plan or unit>]… <by>\`
+revise(n)    ≜ \`scripts/note.mjs revise <title> [--title <new title>] [--kind <k>] [--topic <t>] [--body <b>] [--blocks <plan or unit>]… <by>\` ⟨a field left out carries over ; \`--blocks ''\` ↦ blocks(n) = ∅⟩
+retract(n)   ≜ \`scripts/note.mjs retract <title> <by>\`
+reconcile(n) ≜ \`scripts/note.mjs reconcile <title> [--title …] [--kind …] [--topic …] [--body …] [--blocks …]… <by>\` ↦ one version over every version ⟨each field the versions disagree on is given⟩
+
+a note's title is its name ⟨one live note per title⟩ ∴ n is addressed by title(n) as show prints it ⟨∄ matching on a fragment of its body⟩
+anyone ⊨ capture ∧ revise ∧ retract ∧ reconcile
+capture ⊨ ∄ admission bar ⟨the note's shape ∧ one live note per title suffice⟩
+changed(n) ⇒ revise(n) ⟨¬ edited in place ; \`--title\` retitles n⟩
+owed(n) ⇒ n blocks every x ∈ blocks(n) ⟨whatever its kind⟩ until retract(n) ∨ revise(n) ↦ blocks(n) = ∅
+diverged(n) ⇒ n blocks ⋃ { blocks(v) | v ∈ versions(n) } until reconcile(n)
+diverged(n) ⇒ reconcile(n) ≺ every other write to n
+incoherent(t) ⇒ for ONE h ∈ holders(t) ⟨h named exactly as show prints it, identity included⟩ : live(h) ⇒ revise(h) with \`--title\` ∨ retract(h) · diverged(h) ⇒ reconcile(h) ; until ¬ incoherent(t)
+reconcile ↾ diverged(n) ⟨one note's competing versions ; never a title merely held by more than one note⟩
+verb ∉ { show · capture · revise · retract · reconcile } ⇒ ⊥ ⟨loud⟩`;
+export const note = {
+    name: 'note',
+    description: `use this skill to keep the project's notebook of notes not yet canonical, whenever one surfaces in the work or to see what is still owed: show the whole notebook or one note, capture a note under its title with a kind, topic and body, revise it (retitle it too), retract it, or reconcile one a merge left in competing versions; where a merge left one title held by two notes, repair one holder, named as show prints it: retitle or retract a live one, reconcile a diverged one. Anyone may capture, with no admission bar, and any live note that names a plan or unit blocks it until it is retracted or revised to block nothing.`,
+    formalBlock: NOTE_BLOCK,
+    runtime: { capability: 'note' },
+    composition: () => [],
+};
+//# sourceMappingURL=skill.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/note/skill.ts"],"names":[],"mappings":"AAEA,sFAAsF;AACtF,+EAA+E;AAC/E,sFAAsF;AACtF,EAAE;AACF,sFAAsF;AACtF,oFAAoF;AACpF,oFAAoF;AACpF,qFAAqF;AACrF,yFAAyF;AACzF,sFAAsF;AACtF,oCAAoC;AACpC,EAAE;AACF,wFAAwF;AACxF,6CAA6C;AAE7C,MAAM,UAAU,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oEAiCoE,CAAC;AAExF,MAAM,CAAC,MAAM,IAAI,GAAU;IACzB,IAAI,EAAE,MAAM;IACZ,WAAW,EAAE,knBAAknB;IAC/nB,WAAW,EAAE,UAAU;IACvB,OAAO,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE;IAC/B,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;CACtB,CAAC"}