@cratylus/canon 0.4.0 → 0.6.0

package/README.md

@@ -64,11 +64,12 @@ directory fields are resolved against `import.meta.url` at definition time and c
 `defineAgentPlugin`. Canon reaches the projector as **data** — the corpus is passed to it as a
 plugin — and no cell imports it.
 
-One cell does import the runtime: `hooks/memory-consolidation-nudge.ts` takes `CLI_BIN` from
-`@cratylus/runtime/bin-name`, because it emits shell that invokes that binary and the alternative is
-repeating the literal inside a compiler-invisible string. This breaches the architecture's
-highest-ranked property — meaning and mechanism never referencing each other — and a test currently
-requires the breach. It is recorded in [ARCHITECTURE.md](../../ARCHITECTURE.md), not explained away.
+No cell imports the runtime either. A skill names the capability it routes to — one of `eventTap`,
+`design`, `plan` and `note`, the four built into the runtime — as `runtime: { capability: … }`,
+never its implementation, and a cell that emits shell invoking the binary carries it as a fact the
+projector substitutes at emission. That is the architecture's highest-ranked property — meaning
+and mechanism never referencing each other — and [ARCHITECTURE.md](../../ARCHITECTURE.md) records
+how it came to hold.
 
 ## Tests
 

package/dist/agents/nico.js

@@ -1,6 +1,5 @@
 import { codeExecution as codeExecution_actions } from '../dimensions/actions/code-execution.js';
 import { delegation as delegation_actions } from '../dimensions/actions/delegation.js';
-import { fileOps as fileOps_actions } from '../dimensions/actions/file-ops.js';
 import { maintenance as maintenance_audienceAdaptation } from '../dimensions/audience-adaptation/maintenance.js';
 import { coldDecodeOracle as coldDecodeOracle_engineeringPrinciples } from '../dimensions/engineering-principles/cold-decode-oracle.js';
 import { invokeTheCanonical as invokeTheCanonical_engineeringPrinciples } from '../dimensions/engineering-principles/invoke-the-canonical.js';
@@ -55,7 +54,7 @@ export const nico = holds(architectRole, {
         helpfulness_guardrails,
         inputUntrusted_guardrails,
     ],
-    actions: [fileOps_actions, codeExecution_actions, delegation_actions],
+    actions: [codeExecution_actions, delegation_actions],
     framing: analytical_framing,
     reasoningStrategy: react_reasoningStrategy,
     satisficing: satisfice_satisficing,

package/dist/agents/nico.js.map

@@ -1 +1 @@
-{"version":3,"file":"nico.js","sourceRoot":"","sources":["../../src/agents/nico.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,IAAI,qBAAqB,EAAE,MAAM,yCAAyC,CAAC;AACjG,OAAO,EAAE,UAAU,IAAI,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACvF,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAC/E,OAAO,EAAE,WAAW,IAAI,8BAA8B,EAAE,MAAM,kDAAkD,CAAC;AACjH,OAAO,EAAE,gBAAgB,IAAI,sCAAsC,EAAE,MAAM,4DAA4D,CAAC;AACxI,OAAO,EAAE,kBAAkB,IAAI,wCAAwC,EAAE,MAAM,8DAA8D,CAAC;AAC9I,OAAO,EAAE,SAAS,IAAI,+BAA+B,EAAE,MAAM,oDAAoD,CAAC;AAClH,OAAO,EAAE,UAAU,IAAI,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACvF,OAAO,EAAE,aAAa,IAAI,wBAAwB,EAAE,MAAM,4CAA4C,CAAC;AACvG,OAAO,EAAE,WAAW,IAAI,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AAChG,OAAO,EAAE,cAAc,IAAI,yBAAyB,EAAE,MAAM,6CAA6C,CAAC;AAC1G,OAAO,EAAE,SAAS,IAAI,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AACxF,OAAO,EAAE,IAAI,IAAI,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AAChF,OAAO,EAAE,KAAK,IAAI,uBAAuB,EAAE,MAAM,2CAA2C,CAAC;AAC7F,OAAO,EAAE,SAAS,IAAI,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAC5F,OAAO,EAAE,oBAAoB,IAAI,mCAAmC,EAAE,MAAM,yDAAyD,CAAC;AAEtI,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEzC,wFAAwF;AACxF,uFAAuF;AACvF,sFAAsF;AACtF,mFAAmF;AACnF,wFAAwF;AACxF,+CAA+C;AAC/C,EAAE;AACF,mFAAmF;AACnF,uFAAuF;AACvF,sFAAsF;AACtF,6EAA6E;AAC7E,EAAE;AACF,wFAAwF;AACxF,oFAAoF;AACpF,qFAAqF;AACrF,wCAAwC;AAExC,MAAM,CAAC,MAAM,IAAI,GAAU,KAAK,CAAC,aAAa,EAAE;IAC9C,IAAI,EAAE,MAAM;IACZ,WAAW,EACT,mUAAmU;IACrU,SAAS,EACP,2iBAA2iB;IAC7iB,UAAU,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE;IAClD,gFAAgF;IAChF,oFAAoF;IACpF,wBAAwB;IACxB,kBAAkB,EAAE,8BAA8B;IAClD,mFAAmF;IACnF,mFAAmF;IACnF,0BAA0B;IAC1B,SAAS,EAAE,mBAAmB;IAC9B,qBAAqB,EAAE;QACrB,sCAAsC;QACtC,wCAAwC;QACxC,+BAA+B;KAChC;IACD,UAAU,EAAE;QACV,wBAAwB;QACxB,sBAAsB;QACtB,yBAAyB;KAC1B;IACD,OAAO,EAAE,CAAC,eAAe,EAAE,qBAAqB,EAAE,kBAAkB,CAAC;IACrE,OAAO,EAAE,kBAAkB;IAC3B,iBAAiB,EAAE,uBAAuB;IAC1C,WAAW,EAAE,qBAAqB;IAClC,YAAY,EAAE,iBAAiB;IAC/B,qFAAqF;IACrF,kFAAkF;IAClF,8EAA8E;IAC9E,cAAc,EAAE,mCAAmC;CACpD,CAAC,CAAC"}
+{"version":3,"file":"nico.js","sourceRoot":"","sources":["../../src/agents/nico.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,IAAI,qBAAqB,EAAE,MAAM,yCAAyC,CAAC;AACjG,OAAO,EAAE,UAAU,IAAI,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACvF,OAAO,EAAE,WAAW,IAAI,8BAA8B,EAAE,MAAM,kDAAkD,CAAC;AACjH,OAAO,EAAE,gBAAgB,IAAI,sCAAsC,EAAE,MAAM,4DAA4D,CAAC;AACxI,OAAO,EAAE,kBAAkB,IAAI,wCAAwC,EAAE,MAAM,8DAA8D,CAAC;AAC9I,OAAO,EAAE,SAAS,IAAI,+BAA+B,EAAE,MAAM,oDAAoD,CAAC;AAClH,OAAO,EAAE,UAAU,IAAI,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACvF,OAAO,EAAE,aAAa,IAAI,wBAAwB,EAAE,MAAM,4CAA4C,CAAC;AACvG,OAAO,EAAE,WAAW,IAAI,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AAChG,OAAO,EAAE,cAAc,IAAI,yBAAyB,EAAE,MAAM,6CAA6C,CAAC;AAC1G,OAAO,EAAE,SAAS,IAAI,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AACxF,OAAO,EAAE,IAAI,IAAI,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AAChF,OAAO,EAAE,KAAK,IAAI,uBAAuB,EAAE,MAAM,2CAA2C,CAAC;AAC7F,OAAO,EAAE,SAAS,IAAI,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAC5F,OAAO,EAAE,oBAAoB,IAAI,mCAAmC,EAAE,MAAM,yDAAyD,CAAC;AAEtI,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEzC,wFAAwF;AACxF,uFAAuF;AACvF,sFAAsF;AACtF,mFAAmF;AACnF,wFAAwF;AACxF,+CAA+C;AAC/C,EAAE;AACF,mFAAmF;AACnF,uFAAuF;AACvF,sFAAsF;AACtF,6EAA6E;AAC7E,EAAE;AACF,wFAAwF;AACxF,oFAAoF;AACpF,qFAAqF;AACrF,wCAAwC;AAExC,MAAM,CAAC,MAAM,IAAI,GAAU,KAAK,CAAC,aAAa,EAAE;IAC9C,IAAI,EAAE,MAAM;IACZ,WAAW,EACT,mUAAmU;IACrU,SAAS,EACP,2iBAA2iB;IAC7iB,UAAU,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE;IAClD,gFAAgF;IAChF,oFAAoF;IACpF,wBAAwB;IACxB,kBAAkB,EAAE,8BAA8B;IAClD,mFAAmF;IACnF,mFAAmF;IACnF,0BAA0B;IAC1B,SAAS,EAAE,mBAAmB;IAC9B,qBAAqB,EAAE;QACrB,sCAAsC;QACtC,wCAAwC;QACxC,+BAA+B;KAChC;IACD,UAAU,EAAE;QACV,wBAAwB;QACxB,sBAAsB;QACtB,yBAAyB;KAC1B;IACD,OAAO,EAAE,CAAC,qBAAqB,EAAE,kBAAkB,CAAC;IACpD,OAAO,EAAE,kBAAkB;IAC3B,iBAAiB,EAAE,uBAAuB;IAC1C,WAAW,EAAE,qBAAqB;IAClC,YAAY,EAAE,iBAAiB;IAC/B,qFAAqF;IACrF,kFAAkF;IAClF,8EAA8E;IAC9E,cAAc,EAAE,mCAAmC;CACpD,CAAC,CAAC"}

package/dist/dimensions/actions/file-ops.js

@@ -1,2 +1,6 @@
-export const fileOps = `file-ops ⟨filesystem vcs⟩`;
+// The `vcs` factor carries what a commit IS, because nothing else an agent reads does:
+// measured 2026-09-25 (docs/commit-gated-on-acceptance-hypothesis.md), a dispatcher with
+// no commit rule in reach withheld every lane's commit until green in 18 of 18 dispatches,
+// and one reading this durability definition let every lane commit in 6 of 6.
+export const fileOps = `file-ops ⟨filesystem · vcs⟩ · commit ≜ durability ¬ acceptance ⟨acceptance ≜ unit state-move · ¬ gates commit⟩ · commit ∀ coherent-step ⟨isolated-branch ∨ worktree ⇒ red admitted ∧ NAMED ↦ message · main ⇒ green⟩ · commit ↾ own-paths ⟨pathspec · formatter(own-paths) ≺ commit⟩ · ∄ dispatch withholding commit(writer)`;
 //# sourceMappingURL=file-ops.js.map

package/dist/dimensions/actions/file-ops.js.map

@@ -1 +1 @@
-{"version":3,"file":"file-ops.js","sourceRoot":"","sources":["../../../src/dimensions/actions/file-ops.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,OAAO,GAAY,2BAA2B,CAAC"}
+{"version":3,"file":"file-ops.js","sourceRoot":"","sources":["../../../src/dimensions/actions/file-ops.ts"],"names":[],"mappings":"AAEA,uFAAuF;AACvF,yFAAyF;AACzF,2FAA2F;AAC3F,8EAA8E;AAC9E,MAAM,CAAC,MAAM,OAAO,GAAY,8TAA8T,CAAC"}

package/dist/dimensions/autonomy/human-on-the-loop.js

@@ -4,7 +4,8 @@
 // phase-STATE, not a static value: the `⟨resting · phase-state⟩` residue declares
 // this as the RESTING / initial position (a session opens in orientation, intent
 // the operator's to set) while marking that the live position shifts —
-// `carry-on` elevates it to out-of-the-loop, held until the bound plan
-// completes or an unresolvable fork re-enters on-the-loop. See skills/carry-on.
+// `carry-on` elevates it to out-of-the-loop, held until its context is
+// satisfied, the operator redirects, or an unresolvable fork re-enters
+// on-the-loop. See skills/carry-on.
 export const humanOnTheLoop = `human-on-the-loop ⟨resting · phase-state⟩`;
 //# sourceMappingURL=human-on-the-loop.js.map

package/dist/dimensions/autonomy/human-on-the-loop.js.map

@@ -1 +1 @@
-{"version":3,"file":"human-on-the-loop.js","sourceRoot":"","sources":["../../../src/dimensions/autonomy/human-on-the-loop.ts"],"names":[],"mappings":"AAEA,4EAA4E;AAC5E,kFAAkF;AAClF,+EAA+E;AAC/E,kFAAkF;AAClF,iFAAiF;AACjF,uEAAuE;AACvE,uEAAuE;AACvE,gFAAgF;AAChF,MAAM,CAAC,MAAM,cAAc,GAAa,2CAA2C,CAAC"}
+{"version":3,"file":"human-on-the-loop.js","sourceRoot":"","sources":["../../../src/dimensions/autonomy/human-on-the-loop.ts"],"names":[],"mappings":"AAEA,4EAA4E;AAC5E,kFAAkF;AAClF,+EAA+E;AAC/E,kFAAkF;AAClF,iFAAiF;AACjF,uEAAuE;AACvE,uEAAuE;AACvE,uEAAuE;AACvE,oCAAoC;AACpC,MAAM,CAAC,MAAM,cAAc,GAAa,2CAA2C,CAAC"}

package/dist/manifest.d.ts

@@ -178,7 +178,7 @@ export type ReasoningStrategy = Value<'reasoning-strategy'>;
 export type Satisficing = Value<'satisficing'>;
 export type OutputFormat = Value<'output-format'>;
 export type SelfEvaluation = Value<'self-evaluation'>;
-export declare const RUNTIME_CAPABILITIES: readonly ["memory", "eventTap", "carryOn", "heartbeat"];
+export declare const RUNTIME_CAPABILITIES: readonly ["eventTap", "design", "plan", "note"];
 /** A runtime capability this corpus ships a face for. */
 export type RuntimeCapability = (typeof RUNTIME_CAPABILITIES)[number];
 /** This corpus's `Skill`: schema's shape, narrowed to the capabilities above. */

package/dist/manifest.js

@@ -123,10 +123,10 @@ export const DIMENSION_NAMES = Object.keys(MANIFEST);
 // agent-design axis, which is a different concept. Bare `Capability` beside it
 // would be one root over two concepts.
 export const RUNTIME_CAPABILITIES = [
-    'memory',
     'eventTap',
-    'carryOn',
-    'heartbeat',
+    'design',
+    'plan',
+    'note',
 ];
 // ── The lifecycle-event vocabulary ──────────────────────────────────────────
 //

package/dist/manifest.js.map

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

package/dist/roles/architect.js

@@ -1,3 +1,4 @@
+import { fileOps as fileOps_actions } from '../dimensions/actions/file-ops.js';
 import { convergence as convergence_audienceAdaptation } from '../dimensions/audience-adaptation/convergence.js';
 import { principalSelf } from '../dimensions/autonomy/decision-authority.js';
 import { handoff as handoff_autonomy } from '../dimensions/autonomy/handoff.js';
@@ -47,8 +48,8 @@ export const architectRole = {
     sign: architect_role,
     // `design` holds the lattice, `deliver` closes the loop on what comes back. Declared
     // rather than described — omp injects them before a dispatched subagent's first
-    // prompt and the generic launcher names them as required reading for a main session,
-    // so a holder is the same agent either way it is reached.
+    // prompt and the generic launcher inlines their bodies for a main session, so a
+    // holder is the same agent either way it is reached.
     skills: ['design', 'deliver'],
     vector: {
         formality: plain_formality,
@@ -87,6 +88,9 @@ export const architectRole = {
             systemDesign_capabilities,
             researchInvestigation_capabilities,
         ],
+        // `file-ops`: this position writes C and dispatches every writer below it, so it is
+        // where a lane's commit would be withheld; the `vcs` factor forbids that.
+        actions: [fileOps_actions],
         learning: correctionConsolidation_learning,
         situationAwareness: projection_situationAwareness,
         framing: systemsThinking_framing,

package/dist/roles/architect.js.map

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

package/dist/roles/implementer.js

@@ -1,3 +1,4 @@
+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';
@@ -44,6 +45,7 @@ export const implementerRole = {
             softwareEngineering_capabilities,
             verificationTesting_capabilities,
         ],
+        actions: [fileOps_actions],
         learning: correctionConsolidation_learning,
         situationAwareness: perception_situationAwareness,
         framing: correctnessOriented_framing,

package/dist/roles/implementer.js.map

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

@@ -1,3 +1,4 @@
+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';
@@ -28,9 +29,10 @@ import { provenanceAttribution as provenanceAttribution_transparency } from '../
 // designs nor builds. What it owns is the census and the cut-into-units.
 export const plannerRole = {
     sign: planner_role,
-    // One skill, and only one. `design` and `deliver` belong to the rung ABOVE, which
-    // draws the boundary this rung plans inside; the rung BELOW declares none at all,
-    // because an implementer's decisions are made for it by its spec.
+    // 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,
@@ -64,6 +66,7 @@ export const plannerRole = {
         framing: decompositional_framing,
         reasoningStrategy: planAndSolve_reasoningStrategy,
         satisficing: optimize_satisficing,
+        actions: [fileOps_actions],
         selfEvaluation: acceptanceCriteriaCheck_selfEvaluation,
     },
 };

package/dist/roles/planner.js.map

@@ -1 +1 @@
-{"version":3,"file":"planner.js","sourceRoot":"","sources":["../../src/roles/planner.ts"],"names":[],"mappings":"AAAA,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,qBAAqB,IAAI,kCAAkC,EAAE,MAAM,sDAAsD,CAAC;AACnI,OAAO,EAAE,qBAAqB,IAAI,kCAAkC,EAAE,MAAM,sDAAsD,CAAC;AACnI,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,SAAS,IAAI,+BAA+B,EAAE,MAAM,oDAAoD,CAAC;AAClH,OAAO,EAAE,IAAI,IAAI,0BAA0B,EAAE,MAAM,8CAA8C,CAAC;AAClG,OAAO,EAAE,UAAU,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AACpH,OAAO,EAAE,KAAK,IAAI,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAC5E,OAAO,EAAE,eAAe,IAAI,uBAAuB,EAAE,MAAM,0CAA0C,CAAC;AACtG,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACpF,OAAO,EAAE,uBAAuB,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AACjI,OAAO,EAAE,YAAY,IAAI,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AACjG,OAAO,EAAE,YAAY,IAAI,8BAA8B,EAAE,MAAM,oDAAoD,CAAC;AACpH,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,+BAA+B,CAAC;AACxE,OAAO,EAAE,QAAQ,IAAI,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AACzF,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;AAGnI,uFAAuF;AACvF,kFAAkF;AAClF,yDAAyD;AACzD,EAAE;AACF,qFAAqF;AACrF,yEAAyE;AAEzE,MAAM,CAAC,MAAM,WAAW,GAAa;IACnC,IAAI,EAAE,YAAY;IAClB,kFAAkF;IAClF,kFAAkF;IAClF,kEAAkE;IAClE,MAAM,EAAE,CAAC,MAAM,CAAC;IAChB,MAAM,EAAE;QACN,SAAS,EAAE,eAAe;QAC1B,kBAAkB,EAAE,8BAA8B;QAClD,mFAAmF;QACnF,8EAA8E;QAC9E,kFAAkF;QAClF,YAAY;QACZ,YAAY,EAAE,kCAAkC;QAChD,QAAQ,EAAE,CAAC,cAAc,EAAE,gBAAgB,CAAC;QAC5C,mFAAmF;QACnF,mEAAmE;QACnE,SAAS,EAAE,sBAAsB;QACjC,qBAAqB,EAAE;YACrB,+BAA+B;YAC/B,+BAA+B;YAC/B,qCAAqC;YACrC,gCAAgC;YAChC,yBAAyB;YACzB,0BAA0B;SAC3B;QACD,UAAU,EAAE,CAAC,kBAAkB,CAAC;QAChC,YAAY,EAAE;YACZ,kCAAkC;YAClC,kCAAkC;SACnC;QACD,QAAQ,EAAE,gCAAgC;QAC1C,kFAAkF;QAClF,sEAAsE;QACtE,kBAAkB,EAAE,gCAAgC;QACpD,OAAO,EAAE,uBAAuB;QAChC,iBAAiB,EAAE,8BAA8B;QACjD,WAAW,EAAE,oBAAoB;QACjC,cAAc,EAAE,sCAAsC;KACvD;CACF,CAAC"}
+{"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
@@ -36,7 +37,7 @@ import { plan } from '../plan/skill.js';
 // 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
@@ -44,17 +45,21 @@ 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⟩
@@ -68,11 +73,9 @@ unachieved : unit → ℘(⟨c, uncovered-factor, locus⟩) ⟨what crosses UPWA
 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)
 achieved(unit) ⇔ realizes(unit) ∈ assay(artifact(unit))
@@ -97,8 +100,8 @@ validate ⊨ self ⟨¬ delegable · the executor cannot judge its own conforman
     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)
@@ -111,26 +114,25 @@ cost(validate) < cost(rebuild) ⟨else the gradient points at skipping · the ch
     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⟩
+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 → retire`;
+    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;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gFA2F8E,CAAC;AAEpG,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"}

package/dist/skills/plan/skill.js

@@ -1,5 +1,5 @@
-import { PLAN_STATES } from '../../plan-states.js';
 import { design } from '../design/skill.js';
+import { note } from '../note/skill.js';
 // SUPERSEDES `praxis`, which carried three activities with three different ends —
 // capturing understanding, specifying work, and governing execution — and no seam
 // between them. An agent asked to switch telos three times with nothing marking the
@@ -11,22 +11,50 @@ import { design } from '../design/skill.js';
 // the plan's own lifecycle. Understanding moved to `design`; dispatch, judgement and
 // triage moved to `deliver`.
 //
+// THE LIFECYCLE STATES LIVE HERE AND NOWHERE ELSE. They are meaning, so the corpus
+// holds them; the `plan` capability receives them as the configuration this cell's
+// runtime face carries, which deploy emits into the host runtime config, and acts on
+// the roles it names (which plan state at most one plan holds, which is final, which
+// unit state satisfies a dependency), never on a spelling of its own.
+//
 // The laws carried forward are the ones that were PAID FOR. The output-array law and
 // its measurement survive verbatim because the defect it names — a footprint read off
 // where a sign is DEFINED while the work is bounded by where it is USED — recurred six
 // times in one plan and voids every disjointness proof above it when it recurs.
+const LIFECYCLE = {
+    plan: {
+        states: ['proposed', 'bound', 'closed'],
+        exclusive: 'bound',
+        final: 'closed',
+    },
+    unit: { states: ['pending', 'active', 'completed'], satisfies: 'completed' },
+};
+const { plan: PLAN, unit: UNIT } = LIFECYCLE;
 const FORMAL_BLOCK = `s      ≜ a cut piece ⟨closed · handed down · ¬ redrawable here⟩ @ design
+c      @ design
 anchor @ design
 closure @ design
-pin    @ design
-digest @ design
+withdrawn @ design
+self   @ design
 P      ≜ a plan : the units cutting s into work
-unit      ≜ a unit of work ⟨unit ∈ P⟩
-States ≜ { ${PLAN_STATES.join(', ')} }
-state  : P → States
+unit   ≜ a unit of work ⟨unit ∈ P⟩
+name(x) ≜ the label x is addressed by ⟨x a P ∨ a unit · revisable⟩
+States(P) ≜ { ${PLAN.states.join(', ')} } ⟨in lifecycle order⟩
+States(unit) ≜ { ${UNIT.states.join(', ')} } ⟨in lifecycle order⟩
+state  : P → States(P) ∧ unit → States(unit)
+bound(P) ⇔ state(P) = ${PLAN.exclusive}
+closed(P) ⇔ state(P) = ${PLAN.final}
+satisfied(unit) ⇔ state(unit) ≽ ${UNIT.satisfies} ⟨reached completion ∨ moved past it⟩
+settled(x) ⇔ x has exactly one current version ⟨x a P ∨ a unit⟩
+live(x) ⇔ settled(x) ∧ that version ¬ a retraction
+diverged(x) ⇔ ¬settled(x) ⟨concurrent sessions wrote x differently ∧ merged · state, ¬ error⟩
+incoherent(P) ⇔ a law below broken across plans ∨ units by a merge ∧ kept on each branch
 R      ⊆ P × P ⟨dependency⟩
 deps(unit) ≜ { u | (unit, u) ∈ R }
-realizes : P → anchor ⟨TOTAL⟩
+realizes : P → ℘(anchor) ∧ unit → anchor ⟨TOTAL⟩
+pin    : unit → the version of denotes(realizes(unit)) the unit was authored against
+drifted(unit) ⇔ pin(unit) ≠ the one current version of denotes(realizes(unit)) ⟨amended · withdrawn · split into competing versions⟩
+suspect(unit) ⇔ ¬drifted(unit) ∧ ∃ c ∈ closure(denotes(realizes(unit))) : c has more than one current version ∨ withdrawn(c) ∨ c has a version newer than pin(unit)
 static : P → ℘(path)
 refs   : P → ℘(path) ⟨what unit's outputs compile against⟩
 outputs : P → ℘(path)
@@ -41,19 +69,49 @@ cross(S) ≜ |R ∩ ⋃ { sᵢ × sⱼ | sᵢ, sⱼ ∈ S ∧ i ≠ j }|
 wave(0) ≜ { unit | ∄ u : (unit, u) ∈ R }
 wave(n+1) ≜ { unit | unit ∉ W(n) ∧ ∀ u : (unit, u) ∈ R ⇒ u ∈ W(n) }
 W(n)   ≜ ⋃ { wave(i) | i ≤ n }
-frontier(P) ≜ { unit | state(unit) ∈ { ready, active } } ⟨where the plan IS · ¬ only
-    what is dispatchable⟩
-blocked(unit) ⇔ ∃ u : (unit, u) ∈ R ∧ state(u) ≠ completed
-ruling-owed(unit) ⇔ a decision nobody has taken stands between unit and acceptance
-mirror : (state, R, spec) → document
+owed   @ note
+blocked(unit) ⇔ ∃ u ∈ deps(unit) : ¬satisfied(u)
+ready(unit) ⇔ bound(P) ∧ ¬blocked(unit) ∧ ∄ owed note blocking unit ∨ P ⟨computed, never stored · ready
+    PROMISES an executor can FINISH · conflating a dep with a ruling stalls a fan-out⟩
+frontier(P) ≜ { unit | ready(unit) ∧ state(unit) = ${UNIT.states[0]} } ∪ { unit | bound(P) ∧ ${UNIT.states[0]} ≺ state(unit) ≺ ${UNIT.satisfies} } ⟨where
+    the plan IS · ¬ only what is dispatchable · ¬bound(P) ⇒ frontier(P) = ∅⟩
 planner   ≜ the planner ⟨bounded to s⟩
 conform @ signify
+show(P) ≜ \`scripts/plan.mjs show [<plan>]\` ↦ the bound P in wave order ∨ any P named, whole
+show(unit) ≜ \`scripts/plan.mjs show <unit> --plan <p>\` ↦ one unit in full
+add(unit) ≜ \`scripts/plan.mjs add <unit> --plan <p> --realizes <concept> --intent <i> [--static <path>]… [--deps <unit>]… [--outputs <path>]… [--accept <criterion>]… [--plan-realizes <concept>]…\` ⟨pin(unit) taken · the first add naming an absent P proposes it, realizing each --plan-realizes⟩
+advance(unit) ≜ \`scripts/plan.mjs advance <unit> --plan <p> --to <state>\`
+retract(unit) ≜ \`scripts/plan.mjs retract <unit> --plan <p>\`
+revise(unit) ≜ \`scripts/plan.mjs revise <unit> --plan <p> [--intent <i>] [--static <path>]… [--deps <unit>]… [--outputs <path>]… [--accept <criterion>]…\` ⟨spec(unit) · pin(unit) kept⟩
+revise(P) ≜ \`scripts/plan.mjs revise <plan> [--name <n>] [--realizes <concept>]…\` ⟨name(P) ∨ realizes(P)⟩
+bind(P) ≜ \`scripts/plan.mjs bind <plan>\` ⟨bound(P) ∧ the P bound before returns to ${PLAN.states[0]}⟩
+close(P) ≜ \`scripts/plan.mjs close <plan>\` ⟨closed(P)⟩
+reconcile(x) ≜ \`scripts/plan.mjs reconcile <unit> --plan <p> [--name <n>] [--realizes <concept>] [--intent <i>] [--static <path>]… [--deps <unit>]… [--outputs <path>]… [--accept <criterion>]… [--state <state>] [--repin]\` ∨ \`scripts/plan.mjs reconcile <plan> [--name <n>] [--realizes <concept>]… [--state <state>]\` ↦ one version superseding every current version of x ⟨each field the versions disagree on is given · a unit whose versions pin differently takes --repin⟩
 
+∀ add ∨ advance ∨ retract ∨ revise ∨ bind ∨ close ∨ reconcile : \`--author <who> --reason <why> --cause <what caused it>\` ⟨a set-valued flag repeats, one member each⟩
 ∀ unit : realizes(unit) ∈ { anchor(c) | c ∈ s } ⟨TOTALITY is the gate · a unit citing no
     concept is work whose purpose cannot be stated ∴ REFUSED at authoring, ¬ warned⟩
 ∀ unit : closure(denotes(realizes(unit))) ⊆ s ⟨a unit reaching outside its piece is a
     BOUNDARY finding · SURFACE it ; the planner may ¬ redraw the cut⟩
-pin(s) ≠ digest(s) ⇒ REFUSE ⟨the design moved under the plan · drift, ¬ staleness⟩
+∀ unit : realizes(unit) = the concept pin(unit) names ∧ realizes(unit) ∈ realizes(P) ⟨a merge
+    breaking it is incoherent(P), reported like the others⟩
+|{ P | bound(P) }| ≤ 1 ⟨held by bind(P), which returns the P bound before⟩
+∀ n : |{ P | live(P) ∧ name(P) = n }| ≤ 1 ∧ ∀ P : |{ unit ∈ P | live(unit) ∧ name(unit) = n }| ≤ 1
+closed(P) ⇒ name(P) kept ∧ ∄ write to P ∨ any unit ∈ P ⟨closed is final · readable forever⟩
+¬closed(P) ⇒ revise(P) admitted ⟨its name ∧ its concepts, never its state⟩
+state(P) moves by bind(P) ∨ close(P) alone
+revise routes to revise(unit) ∨ revise(P) by the name it is given ⟨--plan puts a unit's P in view⟩
+∃ u : live(u) ∧ unit ∈ deps(u) ⇒ ¬ retract(unit)
+advance(unit) ⊨ bound(P) ∧ one step forward in States(unit) ⟨a skip ∨ a step back refuses · a unit of an unbound P is authored ∧ revised, ¬ worked⟩
+∀ unit : R acyclic ∧ ∀ u ∈ deps(unit) : live(u) ∧ u ∈ P
+an owed note blocking P ⇒ ¬ bind(P) ∧ ∀ unit ∈ P : ¬ready(unit)
+add(unit) ⊨ ∀ c ∈ closure(denotes(realizes(unit))) : c has exactly one current version ∧ ¬withdrawn(c) ⟨a pin is taken on settled ground alone⟩
+pin(unit) retaken ⇔ \`scripts/plan.mjs revise <unit> --plan <p> --repin --reason <why>\` ⟨the ONLY way · never a side effect of editing spec(unit)⟩
+withdrawn(denotes(realizes(unit))) ⇒ drifted(unit) ∧ ¬ incoherent(P) ⟨a retraction in the design never breaks a plan law⟩
+drifted(unit) ∨ suspect(unit) ⇒ SURFACE ⟨the design moved under the plan · drift, ¬ staleness⟩
+diverged(x) ⇒ reconcile(x) ⟨an ordinary write on x refuses⟩
+incoherent(P) ⇒ repaired by ordinary writes, one at a time
+reconcile ⊨ self ⟨reconciliation of plans ∧ units is the architect's alone⟩
 slices(P) cut on s ⟨¬ file-adjacency · files are a LAGGING proxy for modularity ∴
     file-cut ⇒ ∀ unit ⊇ fragments of several c ⇒ executor finishes ∧ system incoherent⟩
 ⋃ slices(P) = P ∧ ∀ s₁, s₂ ∈ slices(P) : s₁ ≠ s₂ ⇒ s₁ ∩ s₂ = ∅
@@ -75,15 +133,13 @@ slices(P) cut on s ⟨¬ file-adjacency · files are a LAGGING proxy for modular
 ∀ unit : measurement ∈ spec(unit) ⇒ measurement = claim⟨timestamp⟩ ∴ re-derive ≺ cite
     ⟨a count in a unit is CENSUS OUTPUT, ¬ a datum · the tree moves ∧ nothing reds⟩
 ∀ unit : reach-leg(unit) ⊨ print(denominator) ⟨∄ denominator ⇒ found-nothing ≡ could-not-look⟩
-state(unit) = ready ⇒ ¬blocked(unit) ∧ ¬ruling-owed(unit) ⟨ready PROMISES an executor can
-    FINISH · conflating a dep with a ruling stalls a fan-out on one unanswered question⟩
 ∀ unit : conform(spec(unit))
-advance ⊨ mirror ⟨state moves ∴ the document moves · drift is ¬ a later chore⟩
-plan ≜ take(s) → census ⟨delegable⟩ → slice(s) → author spec(∀ unit) → mirror → ratify @ planner`;
+plan ≜ take(s) → census ⟨delegable⟩ → slice(s) → add(∀ unit) ⟨spec ∧ pin⟩ → ratify @ planner → advance`;
 export const plan = {
     name: 'plan',
-    description: `use this skill to decompose ONE cut piece of a design into MECE units of work — each citing the single concept it realizes, with its inputs, dependencies, declared outputs and mechanical acceptance criteria — sliced on the design's seams rather than on file adjacency, and ordered into waves whose outputs are disjoint so they dispatch concurrently without contending. Reach for it after a design exists and before any work is dispatched. A unit that cites no concept is refused; a piece that cannot be planned as handed down is surfaced, never silently redrawn.`,
+    description: `use this skill to decompose ONE cut piece of a design into MECE units of work — each citing the single concept it realizes, with its inputs, dependencies, declared outputs and mechanical acceptance criteria — sliced on the design's seams rather than on file adjacency, and ordered into waves whose outputs are disjoint so they dispatch concurrently without contending. Reach for it after a design exists and before any work is dispatched. A unit that cites no concept is refused; a piece that cannot be planned as handed down is surfaced, never silently redrawn. Its verbs show a plan or a unit, add, advance, retract and revise units, revise, bind and close a plan, and reconcile either.`,
     formalBlock: FORMAL_BLOCK,
-    composition: () => [design],
+    runtime: { capability: 'plan', configuration: LIFECYCLE },
+    composition: () => [design, note],
 };
 //# sourceMappingURL=skill.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/plan/skill.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAE5C,kFAAkF;AAClF,kFAAkF;AAClF,oFAAoF;AACpF,kFAAkF;AAClF,oFAAoF;AACpF,oCAAoC;AACpC,EAAE;AACF,mFAAmF;AACnF,qFAAqF;AACrF,6BAA6B;AAC7B,EAAE;AACF,qFAAqF;AACrF,sFAAsF;AACtF,uFAAuF;AACvF,gFAAgF;AAEhF,MAAM,YAAY,GAChB;;;;;;;aAOW,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iGAyDiF,CAAC;AAErH,MAAM,CAAC,MAAM,IAAI,GAAU;IACzB,IAAI,EAAE,MAAM;IACZ,WAAW,EAAE,ojBAAojB;IACjkB,WAAW,EAAE,YAAY;IACzB,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,MAAM,CAAC;CAC5B,CAAC"}
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/plan/skill.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAExC,kFAAkF;AAClF,kFAAkF;AAClF,oFAAoF;AACpF,kFAAkF;AAClF,oFAAoF;AACpF,oCAAoC;AACpC,EAAE;AACF,mFAAmF;AACnF,qFAAqF;AACrF,6BAA6B;AAC7B,EAAE;AACF,mFAAmF;AACnF,mFAAmF;AACnF,qFAAqF;AACrF,qFAAqF;AACrF,sEAAsE;AACtE,EAAE;AACF,qFAAqF;AACrF,sFAAsF;AACtF,uFAAuF;AACvF,gFAAgF;AAEhF,MAAM,SAAS,GAAG;IAChB,IAAI,EAAE;QACJ,MAAM,EAAE,CAAC,UAAU,EAAE,OAAO,EAAE,QAAQ,CAAC;QACvC,SAAS,EAAE,OAAO;QAClB,KAAK,EAAE,QAAQ;KAChB;IACD,IAAI,EAAE,EAAE,MAAM,EAAE,CAAC,SAAS,EAAE,QAAQ,EAAE,WAAW,CAAC,EAAE,SAAS,EAAE,WAAW,EAAE;CACpE,CAAC;AACX,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,SAAS,CAAC;AAE7C,MAAM,YAAY,GAChB;;;;;;;;;gBASc,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;mBACnB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;;wBAEjB,IAAI,CAAC,SAAS;yBACb,IAAI,CAAC,KAAK;kCACD,IAAI,CAAC,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDA6BK,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,4BAA4B,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,oBAAoB,IAAI,CAAC,SAAS;;;;;;;;;;;uFAWxD,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uGAkDqB,CAAC;AAE3H,MAAM,CAAC,MAAM,IAAI,GAAU;IACzB,IAAI,EAAE,MAAM;IACZ,WAAW,EAAE,krBAAkrB;IAC/rB,WAAW,EAAE,YAAY;IACzB,OAAO,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,aAAa,EAAE,SAAS,EAAE;IACzD,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,IAAI,CAAC;CAClC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cratylus/canon",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "The canonical corpus of discovered optimal-signifiers — agents, skills, dimensions and rules as typed TS source. Markdown is a projection of these modules.",
   "license": "MIT",
   "engines": {
@@ -18,11 +18,11 @@
   ],
   "//test": "`test` builds FIRST because `test/runtime-shim.test.ts` drives the shipped `cratylus project` over the repository's own `cratylus.config.ts`, and that config extends `@cratylus/canon` — the PACKAGE, i.e. this package's `dist`. turbo's `test.dependsOn: [^build]` builds this package's DEPENDENCIES, never this package, so a cold clone would run the consumer path against a dist that does not exist.",
   "dependencies": {
-    "@cratylus/schema": "0.2.0"
+    "@cratylus/schema": "0.4.0"
   },
   "devDependencies": {
-    "@cratylus/forge": "0.6.0",
-    "@cratylus/runtime": "0.2.0",
+    "@cratylus/forge": "0.9.0",
+    "@cratylus/runtime": "0.4.0",
     "@cratylus/tooling": "0.0.0",
     "@types/node": "^22.0.0",
     "tsx": "^4.19.0",
@@ -57,8 +57,6 @@
     "clean": "rm -rf dist",
     "dev": "tsc -p tsconfig.build.json --watch --preserveWatchOutput",
     "pack:smoke": "tsx tooling/pack-smoke/pack-smoke-cli.ts",
-    "plan-set": "tsx tooling/plan-set-cli.ts",
-    "plan": "sh tooling/plan-set/plan-set.sh",
     "project:targets": "tsx tooling/project-targets-cli.ts",
     "scaffold": "tsx tooling/scaffold-cli.ts",
     "stance-guard:test": "sh test/support/guardrail/test-stance-guardrail.sh",

package/dist/plan-states.d.ts

@@ -1,31 +0,0 @@
-/** The plan-layout state folders, in task-file lifecycle order. */
-export declare const PLAN_STATES: readonly ["pending", "ready", "active", "completed"];
-/** `frontier(P)` — the states a shard sits in when the plan is workable AT it
- *  (`{ t | state(t) ∈ { ready, active } }`, where the plan IS, not merely
- *  what is dispatchable). A subset of {@link PLAN_STATES} and not derivable from
- *  their ORDER: `pending` is open too, and is not frontier. */
-export declare const PLAN_FRONTIER: readonly ["ready", "active"];
-/**
- * The plan-tier dotfile MARKERS whose only home is here.
- *
- * A relation with no on-disk carrier is not readable — the reading `plan-set.sh`
- * states in its own words when it explains why `.landed` exists ("exactly parallel
- * to `.superseded-by`"). These are the two markers a reader of the plan set needs
- * that have no other TypeScript home: `.superseded-by` already has one
- * (`plan-set.ts`'s `SUPERSEDED_MARKER`) and is deliberately not restated.
- *
- * `.ruling-owed` is the third carrier this corpus has minted on that reading, and
- * it carries the concept the corpus ALREADY signifies as a ruling owed — "a
- * decision nobody has taken", which the retired praxis cell distinguished from a
- * dependency ("a dep waits itself out, a ruling needs a human"). At the SHARD tier
- * that concept is `ruling-owed(t)`, and it gates `ready`; at the
- * PLAN tier it had no carrier at all, so a fork the principal cannot resolve —
- * irreversible, or above its competence — was unreadable from disk however loudly
- * it had been surfaced. Its content is the fork as it was put to the operator.
- */
-export declare const PLAN_MARKERS: {
-    /** `bound(P)` — the plan-level commitment; exactly one plan carries it (WIP=1). */
-    readonly bound: ".bound";
-    /** `fork⊥(P)` — a fork surfaced to the operator, whose ruling nobody has taken. */
-    readonly rulingOwed: ".ruling-owed";
-};

package/dist/plan-states.js

@@ -1,46 +0,0 @@
-// plan-states.ts — the CANON home of the sharded-plan-layout state folders, in
-// lifecycle order. ONE home, two consumers (DRY): the `plan` skill's formal block
-// (`../skills/plan/skill.ts`, whose `States ≜ {…}` set derives from here) and the
-// canon project template (`./project-template.ts`, whose `planStates` is this). It
-// lives here — not as a second export on the plan skill module — because a skill
-// module carries exactly one export (its `Skill`); this is the plan cell's canon,
-// factored out to a sibling both can source.
-//
-// The consumer was `praxis` until that cell was superseded by the design/plan/deliver
-// trio: praxis carried understanding, specification and governance in one place, and
-// the state set belongs to the middle term alone.
-/** The plan-layout state folders, in task-file lifecycle order. */
-export const PLAN_STATES = ['pending', 'ready', 'active', 'completed'];
-/** `frontier(P)` — the states a shard sits in when the plan is workable AT it
- *  (`{ t | state(t) ∈ { ready, active } }`, where the plan IS, not merely
- *  what is dispatchable). A subset of {@link PLAN_STATES} and not derivable from
- *  their ORDER: `pending` is open too, and is not frontier. */
-export const PLAN_FRONTIER = [
-    'ready',
-    'active',
-];
-/**
- * The plan-tier dotfile MARKERS whose only home is here.
- *
- * A relation with no on-disk carrier is not readable — the reading `plan-set.sh`
- * states in its own words when it explains why `.landed` exists ("exactly parallel
- * to `.superseded-by`"). These are the two markers a reader of the plan set needs
- * that have no other TypeScript home: `.superseded-by` already has one
- * (`plan-set.ts`'s `SUPERSEDED_MARKER`) and is deliberately not restated.
- *
- * `.ruling-owed` is the third carrier this corpus has minted on that reading, and
- * it carries the concept the corpus ALREADY signifies as a ruling owed — "a
- * decision nobody has taken", which the retired praxis cell distinguished from a
- * dependency ("a dep waits itself out, a ruling needs a human"). At the SHARD tier
- * that concept is `ruling-owed(t)`, and it gates `ready`; at the
- * PLAN tier it had no carrier at all, so a fork the principal cannot resolve —
- * irreversible, or above its competence — was unreadable from disk however loudly
- * it had been surfaced. Its content is the fork as it was put to the operator.
- */
-export const PLAN_MARKERS = {
-    /** `bound(P)` — the plan-level commitment; exactly one plan carries it (WIP=1). */
-    bound: '.bound',
-    /** `fork⊥(P)` — a fork surfaced to the operator, whose ruling nobody has taken. */
-    rulingOwed: '.ruling-owed',
-};
-//# sourceMappingURL=plan-states.js.map

package/dist/plan-states.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"plan-states.js","sourceRoot":"","sources":["../src/plan-states.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,kFAAkF;AAClF,kFAAkF;AAClF,mFAAmF;AACnF,iFAAiF;AACjF,kFAAkF;AAClF,6CAA6C;AAC7C,EAAE;AACF,sFAAsF;AACtF,qFAAqF;AACrF,kDAAkD;AAElD,mEAAmE;AACnE,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,WAAW,CAAU,CAAC;AAEhF;;;+DAG+D;AAC/D,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,OAAO;IACP,QAAQ;CACkD,CAAC;AAE7D;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,mFAAmF;IACnF,KAAK,EAAE,QAAQ;IACf,mFAAmF;IACnF,UAAU,EAAE,cAAc;CAClB,CAAC"}