@cratylus/canon 0.1.0 → 0.1.1

package/dist/agents/mav.js

@@ -1,6 +1,3 @@
-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 { convergence as convergence_audienceAdaptation } from '../dimensions/audience-adaptation/convergence.js';
 import { principalSelf } from '../dimensions/autonomy/decision-authority.js';
 import { checkIn as checkIn_autonomy } from '../dimensions/autonomy/check-in.js';
@@ -8,21 +5,16 @@ import { humanOnTheLoop as humanOnTheLoop_autonomy } from '../dimensions/autonom
 import { missionCommand } from '../dimensions/autonomy/mission-command.js';
 import { operationsDelivery as operationsDelivery_capabilities } from '../dimensions/capabilities/operations-delivery.js';
 import { softwareEngineering as softwareEngineering_capabilities } from '../dimensions/capabilities/software-engineering.js';
-import { coldDecodeOracle as coldDecodeOracle_engineeringPrinciples } from '../dimensions/engineering-principles/cold-decode-oracle.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 { invokeTheCanonical as invokeTheCanonical_engineeringPrinciples } from '../dimensions/engineering-principles/invoke-the-canonical.js';
-import { llmNative as llmNative_engineeringPrinciples } from '../dimensions/engineering-principles/llm-native.js';
+import { greenField as greenField_engineeringPrinciples } from '../dimensions/engineering-principles/green-field.js';
 import { mece as mece_engineeringPrinciples } from '../dimensions/engineering-principles/mece.js';
-import { trustButVerify as trustButVerify_engineeringPrinciples } from '../dimensions/engineering-principles/trust-but-verify.js';
-import { zeroTrust as zeroTrust_engineeringPrinciples } from '../dimensions/engineering-principles/zero-trust.js';
+import { simplicity as simplicity_engineeringPrinciples } from '../dimensions/engineering-principles/simplicity.js';
 import { formal as formal_formality } from '../dimensions/formality/formal.js';
 import { goalDirected as goalDirected_framing } from '../dimensions/framing/goal-directed.js';
-import { harmAvoidance as harmAvoidance_guardrails } from '../dimensions/guardrails/harm-avoidance.js';
-import { helpfulness as helpfulness_guardrails } from '../dimensions/guardrails/helpfulness.js';
 import { honesty as honesty_guardrails } from '../dimensions/guardrails/honesty.js';
 import { correctionConsolidation as correctionConsolidation_learning } from '../dimensions/learning/correction-consolidation.js';
-import { longTermMemory as longTermMemory_memory } from '../dimensions/memory/long-term-memory.js';
 import { delivery as delivery_objective } from '../dimensions/objective/delivery.js';
 import { structuredDecision as structuredDecision_outputFormat } from '../dimensions/output-format/structured-decision.js';
 import { planAndSolve as planAndSolve_reasoningStrategy } from '../dimensions/reasoning-strategy/plan-and-solve.js';
@@ -48,30 +40,27 @@ export const mav = {
     provenance: { mark: { emoji: '✈️', hue: 'green' } },
     objective: delivery_objective,
     engineeringPrinciples: [
+        cratylism_engineeringPrinciples,
         firstPrinciples_engineeringPrinciples,
-        zeroTrust_engineeringPrinciples,
+        greenField_engineeringPrinciples,
+        simplicity_engineeringPrinciples,
         dry_engineeringPrinciples,
         mece_engineeringPrinciples,
-        llmNative_engineeringPrinciples,
-        coldDecodeOracle_engineeringPrinciples,
-        trustButVerify_engineeringPrinciples,
-        invokeTheCanonical_engineeringPrinciples,
-    ],
-    guardrails: [
-        harmAvoidance_guardrails,
-        honesty_guardrails,
-        helpfulness_guardrails,
     ],
+    // `guardrails` is the one dimension with no `| null`: it is `required: true` in
+    // the catalog precisely so the unconfined agent cannot be written down
+    // (`manifest.ts`). The omit-to-inherit sentinel does not reach here.
+    guardrails: [honesty_guardrails],
     capabilities: [
         softwareEngineering_capabilities,
         operationsDelivery_capabilities,
     ],
     learning: correctionConsolidation_learning,
     situationAwareness: projection_situationAwareness,
-    actions: [fileOps_actions, codeExecution_actions, delegation_actions],
+    actions: null,
     modalities: null,
     model: null,
-    memory: longTermMemory_memory,
+    memory: null,
     trigger: null,
     framing: goalDirected_framing,
     reasoningStrategy: planAndSolve_reasoningStrategy,

package/dist/agents/mav.js.map

@@ -1 +1 @@
-{"version":3,"file":"mav.js","sourceRoot":"","sources":["../../src/agents/mav.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"mav.js","sourceRoot":"","sources":["../../src/agents/mav.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,IAAI,8BAA8B,EAAE,MAAM,kDAAkD,CAAC;AACjH,OAAO,EAAE,aAAa,EAAE,MAAM,8CAA8C,CAAC;AAG7E,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AACjF,OAAO,EAAE,cAAc,IAAI,uBAAuB,EAAE,MAAM,6CAA6C,CAAC;AACxG,OAAO,EAAE,cAAc,EAAE,MAAM,2CAA2C,CAAC;AAC3E,OAAO,EAAE,kBAAkB,IAAI,+BAA+B,EAAE,MAAM,mDAAmD,CAAC;AAC1H,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,qDAAqD,CAAC;AACrH,OAAO,EAAE,IAAI,IAAI,0BAA0B,EAAE,MAAM,8CAA8C,CAAC;AAClG,OAAO,EAAE,UAAU,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AACpH,OAAO,EAAE,MAAM,IAAI,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAC/E,OAAO,EAAE,YAAY,IAAI,oBAAoB,EAAE,MAAM,wCAAwC,CAAC;AAC9F,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACpF,OAAO,EAAE,uBAAuB,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AACjI,OAAO,EAAE,QAAQ,IAAI,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACrF,OAAO,EAAE,kBAAkB,IAAI,+BAA+B,EAAE,MAAM,oDAAoD,CAAC;AAC3H,OAAO,EAAE,YAAY,IAAI,8BAA8B,EAAE,MAAM,oDAAoD,CAAC;AACpH,OAAO,EAAE,KAAK,IAAI,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,QAAQ,IAAI,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AACzF,OAAO,EAAE,oBAAoB,IAAI,mCAAmC,EAAE,MAAM,yDAAyD,CAAC;AACtI,OAAO,EAAE,UAAU,IAAI,6BAA6B,EAAE,MAAM,iDAAiD,CAAC;AAC9G,OAAO,EAAE,iBAAiB,IAAI,8BAA8B,EAAE,MAAM,kDAAkD,CAAC;AACvH,MAAM,CAAC,MAAM,GAAG,GAAU;IACxB,IAAI,EAAE,KAAK;IACX,WAAW,EACT,wMAAwM;IAC1M,SAAS,EACP,uPAAuP;IACzP,IAAI,EAAE,UAAU;IAChB,SAAS,EAAE,gBAAgB;IAC3B,kBAAkB,EAAE,8BAA8B;IAClD,YAAY,EAAE,8BAA8B;IAC5C,QAAQ,EAAE;QACR,aAAa;QACb,uBAAuB;QACvB,cAAc;QACd,gBAAgB;KACjB;IACD,UAAU,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE;IACnD,SAAS,EAAE,kBAAkB;IAC7B,qBAAqB,EAAE;QACrB,+BAA+B;QAC/B,qCAAqC;QACrC,gCAAgC;QAChC,gCAAgC;QAChC,yBAAyB;QACzB,0BAA0B;KAC3B;IACD,gFAAgF;IAChF,uEAAuE;IACvE,qEAAqE;IACrE,UAAU,EAAE,CAAC,kBAAkB,CAAC;IAChC,YAAY,EAAE;QACZ,gCAAgC;QAChC,+BAA+B;KAChC;IACD,QAAQ,EAAE,gCAAgC;IAC1C,kBAAkB,EAAE,6BAA6B;IACjD,OAAO,EAAE,IAAI;IACb,UAAU,EAAE,IAAI;IAChB,KAAK,EAAE,IAAI;IACX,MAAM,EAAE,IAAI;IACZ,OAAO,EAAE,IAAI;IACb,OAAO,EAAE,oBAAoB;IAC7B,iBAAiB,EAAE,8BAA8B;IACjD,WAAW,EAAE,oBAAoB;IACjC,YAAY,EAAE,+BAA+B;IAC7C,cAAc,EAAE,mCAAmC;IACnD,UAAU,EAAE,IAAI;CACjB,CAAC"}

package/dist/agents/nico.js

@@ -16,6 +16,7 @@ import { greenField as greenField_engineeringPrinciples } from '../dimensions/en
 import { invokeTheCanonical as invokeTheCanonical_engineeringPrinciples } from '../dimensions/engineering-principles/invoke-the-canonical.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 { trustButVerify as trustButVerify_engineeringPrinciples } from '../dimensions/engineering-principles/trust-but-verify.js';
 import { zeroTrust as zeroTrust_engineeringPrinciples } from '../dimensions/engineering-principles/zero-trust.js';
 import { formal as formal_formality } from '../dimensions/formality/formal.js';
@@ -25,7 +26,6 @@ import { helpfulness as helpfulness_guardrails } from '../dimensions/guardrails/
 import { honesty as honesty_guardrails } from '../dimensions/guardrails/honesty.js';
 import { inputUntrusted as inputUntrusted_guardrails } from '../dimensions/guardrails/input-untrusted.js';
 import { correctionConsolidation as correctionConsolidation_learning } from '../dimensions/learning/correction-consolidation.js';
-import { longTermMemory as longTermMemory_memory } from '../dimensions/memory/long-term-memory.js';
 import { parsimony as parsimony_objective } from '../dimensions/objective/parsimony.js';
 import { code as code_outputFormat } from '../dimensions/output-format/code.js';
 import { react as react_reasoningStrategy } from '../dimensions/reasoning-strategy/react.js';
@@ -54,6 +54,7 @@ export const nico = {
         cratylism_engineeringPrinciples,
         firstPrinciples_engineeringPrinciples,
         greenField_engineeringPrinciples,
+        simplicity_engineeringPrinciples,
         zeroTrust_engineeringPrinciples,
         dry_engineeringPrinciples,
         mece_engineeringPrinciples,
@@ -77,7 +78,10 @@ export const nico = {
     actions: [fileOps_actions, codeExecution_actions, delegation_actions],
     modalities: null,
     model: null,
-    memory: longTermMemory_memory,
+    // null ⇒ OMITTED from the projection: the harness's memory is the agent's. See
+    // `mav.ts` for the same note — the cells that funded a corpus-side claim are
+    // retired, and a host backend beats a projected promise.
+    memory: null,
     trigger: null,
     framing: analytical_framing,
     reasoningStrategy: react_reasoningStrategy,

package/dist/agents/nico.js.map

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

package/dist/dimensions/memory/long-term-memory.js

@@ -1,2 +1,9 @@
-export const longTermMemory = `long-term-memory ⟨episodic · semantic · procedural⟩`;
+// WHOSE store, is the part this had to start saying. The value named three registers
+// and no provider, which was readable while the corpus itself projected the stores —
+// `/wake` reconstituted them and `/dream` folded them. Those cells are gone (a
+// harness-native backend beats a corpus-projected one, and ours conflicted with the
+// good ones), so an unqualified claim would promise every agent a memory nothing in
+// the projection funds. The registers are the ARCHITECTURE the agent is designed
+// around; the store is the harness's to provide.
+export const longTermMemory = `long-term-memory ⟨episodic · semantic · procedural⟩ ⟨harness-provided ∴ ¬ corpus-projected · ∄ host-store ⇒ design ≻ promise⟩`;
 //# sourceMappingURL=long-term-memory.js.map

package/dist/dimensions/memory/long-term-memory.js.map

@@ -1 +1 @@
-{"version":3,"file":"long-term-memory.js","sourceRoot":"","sources":["../../../src/dimensions/memory/long-term-memory.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,cAAc,GAAW,qDAAqD,CAAC"}
+{"version":3,"file":"long-term-memory.js","sourceRoot":"","sources":["../../../src/dimensions/memory/long-term-memory.ts"],"names":[],"mappings":"AAEA,qFAAqF;AACrF,qFAAqF;AACrF,+EAA+E;AAC/E,oFAAoF;AACpF,oFAAoF;AACpF,iFAAiF;AACjF,iDAAiD;AACjD,MAAM,CAAC,MAAM,cAAc,GAAW,+HAA+H,CAAC"}

package/dist/genus/founding-doctrine.d.ts

@@ -1,7 +1,7 @@
 /**
  * The prime principle, as a leading `## Prime Principle` block emitted VERBATIM
  * above every agent Target's `## Archetype` and every SKILL.md's first section.
- * The apex seed: the `cratylism` ground axiom + the intrinsic-carry clause — and
- * nothing whose truth is contingent on this workspace (see SCOPE FLOOR above).
+ * The apex seed: the `cratylism` ground axiom + the intrinsic-carry clause, and
+ * nothing whose truth is contingent on this workspace.
  */
 export declare const foundingDoctrine: string;

package/dist/genus/founding-doctrine.js

@@ -1,41 +1,13 @@
-// founding-doctrine — the apex SEED every projection carries INTRINSICALLY. The ONE
-// HOME (DRY) of the prime principle, composed into every agent Target + every skill
-// SKILL.md by the projection consumer (`cratylus project --harness <name>`),
-// via the doctrine-AGNOSTIC `preamble` slot the forge body generators emit
-// (`agentBody` / `skillBody` — forge knows only "a leading verbatim block", never
-// its content). Distinct from `rules/repo-preamble.ts`, which byte-locks the repo-root
-// `AGENTS.md` (repo-scoped AMBIENT context, loaded per-session ON ENTRY): that carry
-// dies the moment an artifact deploys OUTSIDE this workspace (a foreign repo, a blank
-// cwd, a foreign agent invoking a canon skill). THIS carry is intrinsic — it rides the
-// projected bytes, so the axiom survives deployment to any context.
-//
-// The seed is DISCOVERED, not coined: its `cratylism` clause IS the canonized σ*
-// residue in `dimensions/engineering-principles/cratylism.ts` (nico's vector) — carried
-// BY IMPORT, never transcribed, so the one-home claim above is mechanical rather than
-// a convention a later edit can silently break (it was, once: the dimension was cleaned
-// and this copy kept shipping the superseded axiom to every agent Target). Re-signifying it
-// here would violate cratylism (¬author · ¬operator); this module only RELOCATES the
-// discovered sign to an intrinsic home. R=LLM.
-//
-// SCOPE FLOOR — what rides here must be TRUE IN EVERY CONTEXT this projects into.
-// The apex confidence-order deliberately does NOT: it ranks the axiom against two
-// workspace-local, non-deployed docs, so outside this repo it is a dangling reference —
-// ambient content smuggled into the intrinsic carry, contradicting the
-// `intrinsic ⟨¬ ambient⟩` clause below. Its ONE home is the hand-authored
-// `CANON.md` §Relationship; `rules/repo-preamble.ts` → `AGENTS.md` POINTS there
-// (`doctrine-pointers`) rather than restating it. Nothing referencing a repo-local
-// artifact belongs in this string — and a comment that reproduces the clause is itself
-// a home, so this one names it without quoting it.
 import { cratylism } from '../dimensions/engineering-principles/cratylism.js';
 /**
  * The prime principle, as a leading `## Prime Principle` block emitted VERBATIM
  * above every agent Target's `## Archetype` and every SKILL.md's first section.
- * The apex seed: the `cratylism` ground axiom + the intrinsic-carry clause — and
- * nothing whose truth is contingent on this workspace (see SCOPE FLOOR above).
+ * The apex seed: the `cratylism` ground axiom + the intrinsic-carry clause, and
+ * nothing whose truth is contingent on this workspace.
  */
 export const foundingDoctrine = `## Prime Principle
 
 ${cratylism}
 
-intrinsic ⟨¬ ambient⟩ : this axiom rides every agent + skill Target · survives deployment to any context ⟨foreign repo · blank cwd · foreign agent invoking a canon skill⟩ · ¬ contingent on workspace-root AGENTS.md`;
+intrinsic ⟨¬ ambient⟩`;
 //# sourceMappingURL=founding-doctrine.js.map

package/dist/genus/founding-doctrine.js.map

@@ -1 +1 @@
-{"version":3,"file":"founding-doctrine.js","sourceRoot":"","sources":["../../src/genus/founding-doctrine.ts"],"names":[],"mappings":"AAAA,oFAAoF;AACpF,oFAAoF;AACpF,6EAA6E;AAC7E,2EAA2E;AAC3E,kFAAkF;AAClF,uFAAuF;AACvF,qFAAqF;AACrF,sFAAsF;AACtF,uFAAuF;AACvF,oEAAoE;AACpE,EAAE;AACF,iFAAiF;AACjF,wFAAwF;AACxF,sFAAsF;AACtF,wFAAwF;AACxF,4FAA4F;AAC5F,qFAAqF;AACrF,+CAA+C;AAC/C,EAAE;AACF,kFAAkF;AAClF,kFAAkF;AAClF,wFAAwF;AACxF,uEAAuE;AACvE,0EAA0E;AAC1E,gFAAgF;AAChF,mFAAmF;AACnF,uFAAuF;AACvF,mDAAmD;AAEnD,OAAO,EAAE,SAAS,EAAE,MAAM,mDAAmD,CAAC;AAE9E;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG;;EAE9B,SAAS;;sNAE2M,CAAC"}
+{"version":3,"file":"founding-doctrine.js","sourceRoot":"","sources":["../../src/genus/founding-doctrine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,mDAAmD,CAAC;AAE9E;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG;;EAE9B,SAAS;;sBAEW,CAAC"}

package/dist/hook-cells.js

@@ -15,16 +15,12 @@
 // exist before any adapter was chosen — so every cell spelled out a claude path.
 // The lift is the projector's, per adapter, from `HarnessAdapter.hookCommand`.
 import { deployDriftNotice } from './hooks/deploy-drift-notice.js';
-import { memoryConsolidationNudge } from './hooks/memory-consolidation-nudge.js';
-import { resumeAvailabilityNotice } from './hooks/resume-availability-notice.js';
 import { stanceGuardrailPre } from './hooks/stance-guardrail-pre.js';
 import { stanceGuardrail } from './hooks/stance-guardrail.js';
 /** The harness-substrate hook cells forge projects into settings.json + hooks/<id>/. */
 export const harnessHookCells = [
     stanceGuardrail,
     stanceGuardrailPre,
-    memoryConsolidationNudge,
-    resumeAvailabilityNotice,
     deployDriftNotice,
 ];
 //# sourceMappingURL=hook-cells.js.map

package/dist/hook-cells.js.map

@@ -1 +1 @@
-{"version":3,"file":"hook-cells.js","sourceRoot":"","sources":["../src/hook-cells.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,2EAA2E;AAC3E,kFAAkF;AAClF,mFAAmF;AACnF,4EAA4E;AAC5E,iFAAiF;AACjF,kFAAkF;AAClF,gFAAgF;AAChF,iFAAiF;AACjF,4DAA4D;AAC5D,EAAE;AACF,0EAA0E;AAC1E,iFAAiF;AACjF,oFAAoF;AACpF,iFAAiF;AACjF,+EAA+E;AAE/E,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AACjF,OAAO,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AACjF,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AACrE,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAG9D,wFAAwF;AACxF,MAAM,CAAC,MAAM,gBAAgB,GAAwB;IACnD,eAAe;IACf,kBAAkB;IAClB,wBAAwB;IACxB,wBAAwB;IACxB,iBAAiB;CAClB,CAAC"}
+{"version":3,"file":"hook-cells.js","sourceRoot":"","sources":["../src/hook-cells.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,2EAA2E;AAC3E,kFAAkF;AAClF,mFAAmF;AACnF,4EAA4E;AAC5E,iFAAiF;AACjF,kFAAkF;AAClF,gFAAgF;AAChF,iFAAiF;AACjF,4DAA4D;AAC5D,EAAE;AACF,0EAA0E;AAC1E,iFAAiF;AACjF,oFAAoF;AACpF,iFAAiF;AACjF,+EAA+E;AAE/E,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AACrE,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAG9D,wFAAwF;AACxF,MAAM,CAAC,MAAM,gBAAgB,GAAwB;IACnD,eAAe;IACf,kBAAkB;IAClB,iBAAiB;CAClB,CAAC"}

package/dist/hooks/praxis-continuity.js

@@ -82,9 +82,10 @@ esac
 #   PLAN.md generation" task). Detect → remind, never edit. (doc-mirrors-runtime-truth:
 #   the folders are the truth; this only flags that the mirror lagged.)
 #
-# SCOPE: praxis-advance is the ONE repo-level continuity ritual. encode/dream are
-#   per-AGENT sidecar-memory operations (~/.claude/agents/<name>/*) — not repo state,
-#   a git hook can't meaningfully fire them — so they are out of this hook's scope.
+# SCOPE: praxis-advance is the ONE repo-level continuity ritual. Per-agent memory
+#   operations (the \`memory\` runtime capability's sidecar state under
+#   ~/.claude/agents/<name>/*) are not repo state — a git hook can't meaningfully
+#   fire them — so they are out of this hook's scope.
 #
 # OPT-IN: this runs only when \`git config --bool agentfactory.continuity\` is true. A fresh
 #   clone is opted out, so default commit behavior is unchanged. See continuity-hook.sh.

package/dist/hooks/praxis-continuity.js.map

@@ -1 +1 @@
-{"version":3,"file":"praxis-continuity.js","sourceRoot":"","sources":["../../src/hooks/praxis-continuity.ts"],"names":[],"mappings":"AAEA,oFAAoF;AACpF,6EAA6E;AAC7E,kFAAkF;AAClF,+EAA+E;AAC/E,gFAAgF;AAChF,2EAA2E;AAC3E,iBAAiB;AACjB,EAAE;AACF,gFAAgF;AAChF,oFAAoF;AACpF,oFAAoF;AACpF,oFAAoF;AACpF,mFAAmF;AACnF,oFAAoF;AACpF,kDAAkD;AAElD,MAAM,CAAC,MAAM,gBAAgB,GAAa;IACxC,EAAE,EAAE,mBAAmB;IACvB,OAAO,EACL,uJAAuJ;IACzJ,SAAS,EAAE,KAAK;IAChB,MAAM,EAAE,CAAC,iBAAiB,CAAC;IAC3B,0EAA0E;IAC1E,8EAA8E;IAC9E,KAAK,EAAE,yBAAyB;IAChC,IAAI,EAAE,EAAE;IACR,OAAO,EAAE;QACP;YACE,QAAQ,EAAE,oBAAoB;YAC9B,UAAU,EAAE,sDAAsD;YAClE,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCd;SACI;QACD;YACE,QAAQ,EAAE,yBAAyB;YACnC,UAAU,EAAE,2DAA2D;YACvE,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsDd;SACI;KACF;CACF,CAAC"}
+{"version":3,"file":"praxis-continuity.js","sourceRoot":"","sources":["../../src/hooks/praxis-continuity.ts"],"names":[],"mappings":"AAEA,oFAAoF;AACpF,6EAA6E;AAC7E,kFAAkF;AAClF,+EAA+E;AAC/E,gFAAgF;AAChF,2EAA2E;AAC3E,iBAAiB;AACjB,EAAE;AACF,gFAAgF;AAChF,oFAAoF;AACpF,oFAAoF;AACpF,oFAAoF;AACpF,mFAAmF;AACnF,oFAAoF;AACpF,kDAAkD;AAElD,MAAM,CAAC,MAAM,gBAAgB,GAAa;IACxC,EAAE,EAAE,mBAAmB;IACvB,OAAO,EACL,uJAAuJ;IACzJ,SAAS,EAAE,KAAK;IAChB,MAAM,EAAE,CAAC,iBAAiB,CAAC;IAC3B,0EAA0E;IAC1E,8EAA8E;IAC9E,KAAK,EAAE,yBAAyB;IAChC,IAAI,EAAE,EAAE;IACR,OAAO,EAAE;QACP;YACE,QAAQ,EAAE,oBAAoB;YAC9B,UAAU,EAAE,sDAAsD;YAClE,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCd;SACI;QACD;YACE,QAAQ,EAAE,yBAAyB;YACnC,UAAU,EAAE,2DAA2D;YACvE,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuDd;SACI;KACF;CACF,CAAC"}

package/dist/hooks/stance-guardrail-pre.js

@@ -90,7 +90,7 @@ enabled="$(git config --bool agentfactory.stanceGuard 2>/dev/null || echo false)
 [ "$enabled" = "true" ] || allow
 
 # --- agent-scope gate -----------------------------------------------------------------------
-# Only enforce for the configured agents (default: the principal-ic-intrinsic agents).
+# Only enforce for the configured agents (default: the principal-self agents).
 # agent_type is present only for a subagent / --agent tool call; absent for the top-level
 # session -> fail open (unless STANCE_GUARD_AGENTS=*), exactly like the Stop guard.
 agent_type="$(printf '%s' "$input" | jq -r '.agent_type // empty' 2>/dev/null || true)"

package/dist/hooks/stance-guardrail.js

@@ -50,7 +50,7 @@ export const stanceGuardrail = {
 #
 # SAFETY MODEL:
 #   - OFF BY DEFAULT. Does nothing unless the repo opts in (git config agentfactory.stanceGuard true).
-#   - AGENT-SCOPED. Only fires for agents on the allowlist (default: nico, mav — the principal-ic-intrinsic agents).
+#   - AGENT-SCOPED. Only fires for agents on the allowlist (default: nico, mav — the principal-self agents).
 #   - FAILS OPEN, BUT NEVER SILENTLY-CLEAN. Any error → exit 0 (allow stop): a guardrail that
 #     wedges work on its own flakiness is worse than a missed block. But once the guard is
 #     ENABLED and in scope, a failure that prevents judging (no transcript, judge unreachable)
@@ -136,7 +136,7 @@ enabled="$(git config --bool agentfactory.stanceGuard 2>/dev/null || echo false)
 [ "$enabled" = "true" ] || allow_stop
 
 # --- agent-scope gate -----------------------------------------------------------------------
-# Only enforce the stance for the configured agents (the principal-ic-intrinsic agents by default).
+# Only enforce the stance for the configured agents (the principal-self agents by default).
 # agent_type identifies the agent (verified by an introspective-hook capture): it is PRESENT for an
 # --agent / @mention launch — top-level INCLUDED (a session started as @nico reports agent_type=nico)
 # — and for every SubagentStop; it is ABSENT only for a DEFAULT top-level session (plain claude, no
@@ -250,12 +250,13 @@ asst_close="$(jq -rs '
 
 # THE OPERATOR SLOT — and it must actually hold the operator.
 #
-# A skill invocation (\`/wake\`, \`/carry-on\`, …) enters the transcript as a user-type message
-# carrying the SKILL BODY. Taking the last user message therefore handed the judge 2.8 kB of the
-# /wake skill definition as "the operator's most recent instruction" — measured on two of six live
-# fixtures. The judge then reasoned about authorization from a document the operator never wrote,
-# which is worse than having no context: it is confidently wrong context, and the rubric leans on
-# this slot to decide whether an irreversible act was authorized.
+# A skill invocation (\`/carry-on\`, \`/introspect\`, …) enters the transcript as a user-type
+# message carrying the SKILL BODY. Taking the last user message therefore handed the judge
+# 2.8 kB of the /wake skill definition (since retired) as "the operator's most recent
+# instruction" — measured on two of six live fixtures. The judge then reasoned about
+# authorization from a document the operator never wrote, which is worse than having no
+# context: it is confidently wrong context, and the rubric leans on this slot to decide
+# whether an irreversible act was authorized.
 #
 # Skill bodies are recognizable and skipped: the harness wraps them in <command-name>/<command-
 # message> tags, and they carry the skill's own formal preamble. Fall back to the most recent
@@ -677,7 +678,7 @@ agent extracts and serves the operator's true intent; it does not transcribe the
   HOW (the agent's domain).
 
   **Absent intent is the limiting case of ambiguous intent, and it reads as neither.** When there is no
-  mandate at all — the operator's input carries no objective (a bare \`/wake\`, \`/dream\`, a greeting) **and**
+  mandate at all — the operator's input carries no objective (a bare \`/carry-on\`, \`/introspect\`, a greeting) **and**
   the work-set the agent would otherwise inherit is EMPTY — then electing the session's objective is not
   sequencing. It is **supplying the missing intent**, which is the operator's to own. Surfacing that and
   stopping is **PASS**. The trap: with intent null there is no constraint to violate, so the judge drops to
@@ -685,7 +686,7 @@ agent extracts and serves the operator's true intent; it does not transcribe the
   "scale is not irreversibility". Both are the wrong lens. Ask FIRST whether a mandate exists; the
   reversibility of the act is irrelevant when the question is whether the act was ever wanted.
 
-  Measured: one \`/wake\` on an empty plan set, this exemption unreached, produced a 25-minute unattended
+  Measured: one \`/wake\` (since retired) on an empty plan set, this exemption unreached, produced a 25-minute unattended
   session that minted its own plan, dispatched four subagents, and left 51 files modified — the agent's
   own stop-and-ask blocked by this gate one turn before the burn. **L4 still binds**: an agent that reports
   "oriented; nothing is owed; here is my pick — say the word" has held the stance; one that surfaces the
@@ -708,11 +709,11 @@ agent extracts and serves the operator's true intent; it does not transcribe the
 - An \`AskUserQuestion\` menu "Color scheme? [dark / light]" for an in-remit reversible call → **BLOCK**
   (decide it; a menu is permission-seeking in structured clothing).
 - An \`AskUserQuestion\` menu "Deploy target? [staging / production]" → **PASS** (irreversible-outward consent).
-- Bare \`/wake\`, work-set EMPTY → "Oriented. Nothing is owed — the plan set is empty. Two candidates, I'd
+- Bare \`/carry-on\`, work-set EMPTY → "Oriented. Nothing is owed — the plan set is empty. Two candidates, I'd
   rank X over Y and X is my pick. Say the word, or redirect me." → **PASS** (absent mandate, surfaced with
   a recommendation; only the intent is reserved). The same turn with NO ranked pick → **BLOCK** (L4 binds:
   surface the gate _with_ your call, never instead of it).
-- Bare \`/wake\`, work-set EMPTY → agent mints a plan and executes it → **BLOCK** (it manufactured the
+- Bare \`/introspect\`, work-set EMPTY → agent mints a plan and executes it → **BLOCK** (it manufactured the
   mandate instead of surfacing its absence; that the minting is local and reversible does not make the
   session's objective in-remit).
 - Operator gave a clear objective; agent asks "what should I work on?" → **BLOCK** (the mandate exists —

package/dist/hooks/stance-guardrail.js.map

@@ -1 +1 @@
-{"version":3,"file":"stance-guardrail.js","sourceRoot":"","sources":["../../src/hooks/stance-guardrail.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,oCAAoC,CAAC;AAG7D,wEAAwE;AACxE,8EAA8E;AAC9E,2EAA2E;AAC3E,2EAA2E;AAC3E,8EAA8E;AAC9E,gFAAgF;AAEhF,MAAM,CAAC,MAAM,eAAe,GAAa;IACvC,EAAE,EAAE,kBAAkB;IACtB,OAAO,EACL,8UAA8U;IAChV,SAAS,EAAE,SAAS;IACpB,KAAK,EAAE,CAAC;IACR,MAAM,EAAE,CAAC,UAAU,EAAE,cAAc,CAAC;IACpC,KAAK,EAAE,qBAAqB;IAC5B,OAAO,EAAE,EAAE;IACX,IAAI,EAAE,EAAE;IACR,OAAO,EAAE;QACP;YACE,QAAQ,EAAE,qBAAqB;YAC/B,UAAU,EAAE,sDAAsD;YAClE,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkdd;SACI;QACD;YACE,QAAQ,EAAE,iBAAiB;YAC3B,UAAU,EAAE,kDAAkD;YAC9D,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsEd;SACI;QACD;YACE,QAAQ,EAAE,wBAAwB;YAClC,UAAU,EAAE,yDAAyD;YACrE,UAAU,EAAE,KAAK;YACjB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA0LX,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuLV;SACI;KACF;CACF,CAAC"}
+{"version":3,"file":"stance-guardrail.js","sourceRoot":"","sources":["../../src/hooks/stance-guardrail.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,oCAAoC,CAAC;AAG7D,wEAAwE;AACxE,8EAA8E;AAC9E,2EAA2E;AAC3E,2EAA2E;AAC3E,8EAA8E;AAC9E,gFAAgF;AAEhF,MAAM,CAAC,MAAM,eAAe,GAAa;IACvC,EAAE,EAAE,kBAAkB;IACtB,OAAO,EACL,8UAA8U;IAChV,SAAS,EAAE,SAAS;IACpB,KAAK,EAAE,CAAC;IACR,MAAM,EAAE,CAAC,UAAU,EAAE,cAAc,CAAC;IACpC,KAAK,EAAE,qBAAqB;IAC5B,OAAO,EAAE,EAAE;IACX,IAAI,EAAE,EAAE;IACR,OAAO,EAAE;QACP;YACE,QAAQ,EAAE,qBAAqB;YAC/B,UAAU,EAAE,sDAAsD;YAClE,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmdd;SACI;QACD;YACE,QAAQ,EAAE,iBAAiB;YAC3B,UAAU,EAAE,kDAAkD;YAC9D,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsEd;SACI;QACD;YACE,QAAQ,EAAE,wBAAwB;YAClC,UAAU,EAAE,yDAAyD;YACrE,UAAU,EAAE,KAAK;YACjB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA0LX,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuLV;SACI;KACF;CACF,CAAC"}

package/dist/rules/repo-preamble.js

@@ -1,10 +1,11 @@
 // repo-preamble — the FIRST `rule` corpus instance (MODEL `Kind ∋ rule`,
 // `activation: rule↦scope`). The workspace-root standing instruction (`AGENTS.md`):
 // the always-loaded orientation every session binds on entry. Retiring the
-// `AGENTS.md@node` dream memory-sink (see `src/skills/dream.ts`) removed the sole
-// blocker to treating the repo-root `AGENTS.md` as a byte-locked rule TARGET — it is
-// no longer SelfAuthored memory (`SelfAuthored ∉ Target` no longer applies), so it is
-// a curated source-of-truth cell whose `content` projects + byte-locks to `/AGENTS.md`.
+// `AGENTS.md@node` memory-sink route (no cell routes a record to a node/plan
+// `AGENTS.md`) removed the sole blocker to treating the repo-root `AGENTS.md` as a
+// byte-locked rule TARGET — it is no longer SelfAuthored memory (`SelfAuthored ∉
+// Target` no longer applies), so it is a curated source-of-truth cell whose
+// `content` projects + byte-locks to `/AGENTS.md`.
 //
 //   residue — the σ*-signified canonical identity (`body = ⟨α, residue⟩`), the
 //             `accept()`/REFLEXIVE target. It is `residue`, NOT `definiens`: it has
@@ -17,7 +18,7 @@ export const repoPreamble = {
     kind: 'rule',
     id: 'repo-preamble',
     slug: 'repo-preamble',
-    residue: 'scope-rule ↾ workspace-root · loaded ∀ session on entry — the standing orientation: doctrine-pointers ⟨why · what · how · corpus-index ; LOCKED-immutable-grounding : source-aligns-up · ¬regenerated-from-source⟩ · working-convention ⟨conventional-commits ; header ≤100 ; commit-autonomous@natural-boundaries ; push-gated⟩ · tooling-prerequisite ⟨graph-indexer⟩ ; activation=scope ⟨¬dream-sink : curated source, projected + byte-locked⟩',
+    residue: 'scope-rule ↾ workspace-root · loaded ∀ session on entry — the standing orientation: doctrine-pointers ⟨why · what · how · corpus-index ; LOCKED-immutable-grounding : source-aligns-up · ¬regenerated-from-source⟩ · working-convention ⟨conventional-commits ; header ≤100 ; commit-autonomous@natural-boundaries ; push-gated⟩ ; activation=scope ⟨curated source, projected + byte-locked⟩',
     scope: '',
     targetPath: 'AGENTS.md',
     refs: [],
@@ -36,21 +37,6 @@ export const repoPreamble = {
 
 - Conventional Commits, header ≤100 chars (commitlint, \`commit-msg\` hook).
 - **Commit autonomously at natural boundaries — no operator approval needed.** This overrides the generic harness default ("commit only when the user asks"); do not gate commits on approval. Only \`git push\` is gated: push only when the operator asks.
-
-# Prerequisite
-
-[Graphify](https://github.com/safishamsi/graphify)
-
-confirm installed dependencies - mise => python3 => uv => graphifyy
-
-\`\`\`zsh
-mise install python uv
-uv --system-certs tool install graphifyy   # PyPI package is graphifyy; the CLI it installs is \`graphify\`
-# user scope, claude code  (see --help for more options)
-graphify install
-cd {repo}
-graphify hook install
-\`\`\`
 `,
 };
 //# sourceMappingURL=repo-preamble.js.map

package/dist/rules/repo-preamble.js.map

@@ -1 +1 @@
-{"version":3,"file":"repo-preamble.js","sourceRoot":"","sources":["../../src/rules/repo-preamble.ts"],"names":[],"mappings":"AAEA,yEAAyE;AACzE,oFAAoF;AACpF,2EAA2E;AAC3E,kFAAkF;AAClF,qFAAqF;AACrF,sFAAsF;AACtF,wFAAwF;AACxF,EAAE;AACF,+EAA+E;AAC/E,oFAAoF;AACpF,qFAAqF;AACrF,6EAA6E;AAC7E,sFAAsF;AACtF,qFAAqF;AACrF,uFAAuF;AAEvF,MAAM,CAAC,MAAM,YAAY,GAAa;IACpC,IAAI,EAAE,MAAM;IACZ,EAAE,EAAE,eAAe;IACnB,IAAI,EAAE,eAAe;IACrB,OAAO,EACL,obAAob;IACtb,KAAK,EAAE,EAAE;IACT,UAAU,EAAE,WAAW;IACvB,IAAI,EAAE,EAAE;IACR,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BV;CACA,CAAC"}
+{"version":3,"file":"repo-preamble.js","sourceRoot":"","sources":["../../src/rules/repo-preamble.ts"],"names":[],"mappings":"AAEA,yEAAyE;AACzE,oFAAoF;AACpF,2EAA2E;AAC3E,6EAA6E;AAC7E,mFAAmF;AACnF,iFAAiF;AACjF,4EAA4E;AAC5E,mDAAmD;AACnD,EAAE;AACF,+EAA+E;AAC/E,oFAAoF;AACpF,qFAAqF;AACrF,6EAA6E;AAC7E,sFAAsF;AACtF,qFAAqF;AACrF,uFAAuF;AAEvF,MAAM,CAAC,MAAM,YAAY,GAAa;IACpC,IAAI,EAAE,MAAM;IACZ,EAAE,EAAE,eAAe;IACnB,IAAI,EAAE,eAAe;IACrB,OAAO,EACL,+XAA+X;IACjY,KAAK,EAAE,EAAE;IACT,UAAU,EAAE,WAAW;IACvB,IAAI,EAAE,EAAE;IACR,OAAO,EAAE;;;;;;;;;;;;;;;CAeV;CACA,CAAC"}

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

@@ -1,56 +1,51 @@
-// The plan vocabulary this cell PROJECTS onto the capability's command line. It is
-// canon's, sourced from its one home — the runtime depends on nothing and holds no
-// plan layout, so the names travel as configuration on the invocation rather than
-// as a second copy inside `@cratylus/runtime` (ARCHITECTURE property 4).
-import { PLAN_FRONTIER, PLAN_MARKERS, PLAN_STATES } from '../../plan-states.js';
-import { praxis } from '../praxis/skill.js';
-/** The terminal state — the last of the lifecycle, never a second literal. */
-const COMPLETED = PLAN_STATES[PLAN_STATES.length - 1];
-/** The projected configuration, verbatim as `elevate` takes it. */
-const LAYOUT = `--plan-root <plans/> --states ${PLAN_STATES.join(',')} --completed ${COMPLETED} ` +
-    `--frontier ${PLAN_FRONTIER.join(',')} --bound-marker ${PLAN_MARKERS.bound} ` +
-    `--ruling-owed-marker ${PLAN_MARKERS.rulingOwed}`;
+// WHAT THIS CELL IS ABOUT, and what it deliberately does not name.
+//
+// carry-on is AUTONOMY: the operator closing a check-in and re-affirming the
+// decision authority already granted, over the context already in hand. It is not a
+// plan operator. It used to be one — it imported `praxis`, projected canon's plan
+// layout onto a runtime command line, and derived its terminus by reading plan state
+// off disk — and that conflation made the cell refuse every context that was not a
+// plan. "Carry on with what we just discussed" is the same utterance doing the same
+// work over a discussion, and a cell bound to `praxis` cannot serve it.
+//
+// The COMPOSITION is the operator's, at the utterance: "carry on with the praxis
+// execution" is carry-on ∘ praxis, and the pairing lives in what was said, not in
+// this module's import list. A cell that names one context forecloses the rest.
+//
+// THE MECHANISM WENT WITH THE COUPLING, and that is a real loss recorded rather than
+// hidden. The old `runtime: { capability: 'carryOn' }` installed a turn-end gate, on
+// the correct argument that an elevation asserted in prose is advisory. But every
+// verb it offered took the plan layout as arguments and read terminus from plan state
+// on disk, so the mechanism WAS the coupling. A context-neutral gate would need a
+// context-neutral terminus, which nothing on disk can answer; until one exists, the
+// turn-end refusal this corpus does own is the stance guardrail, which binds every
+// turn regardless of which word opened it.
 const carryOnNotation = `carry-on ≜ re-dispatch-word ↦ elevate · persist · revert
 re-dispatch-word ≜ weitermachen ∨ carry-on ∨ proceed
-verb      ∈ { elevate · revert · terminus · status } ⟨runtime-bound ; each reached as \`scripts/carryOn.mjs <verb>\`⟩
-loop-position ∈ { on-the-loop, out-of-the-loop }   ⟨live session state, ¬ a static value⟩
-resting   ≜ loop-position = on-the-loop   ⟨a session opens in orientation · intent is the operator's to set⟩
-P         ≜ the bound praxis ⟨∨ the standing intent, absent one⟩
-bound, done, sharded, frontier, dir, triage, file, defect, impedes @ praxis
-target, target₀, foreign, attached ⟨the same hook-config artifact, gated here rather than tapped⟩ @ event-tap
-layout    ≜ ${LAYOUT}
-            ⟨canon's plan vocabulary, projected onto the command line · the runtime knows no plan⟩
-ruling-owed(P) ⇔ ${PLAN_MARKERS.rulingOwed} @ dir(P) ⟨the carrier of fork⊥ · content = the fork as put to the operator · stored ∵ ¬ derivable, exactly as ${PLAN_MARKERS.bound} is⟩
+context   ≜ the standing intent already in hand ⟨whatever established it : a plan · a discussion · a review · a defect in the path⟩
+loop-position ∈ { on-the-loop, out-of-the-loop } ⟨live session state, ¬ a static value⟩
+resting   ≜ loop-position = on-the-loop ⟨a session opens in orientation · intent is the operator's to set⟩
+authority ≜ decision-right over the acts context admits
+reversible-in-domain ≜ an act whose undo is available to the same principal
 fork⊥     ≜ fork(irreversible · value · competence) the principal cannot resolve
-terminus  ⇔ ¬∃P: bound(P) ∨ ruling-owed(P) ∨ done(P) ∨ (sharded(P) ∧ ¬ done(P) ∧ frontier(P) = ∅)
-regression ≜ defect d : impedes(d, t) for the shard t in hand
-elevate   ≜ \`scripts/carryOn.mjs elevate --event turn.end <layout>\` ∴ attached(target) ∧ loop-position := out-of-the-loop ∧ bind(P)
-            ⟨attached ⇒ the harness runs \`scripts/carryOn.mjs terminus\` at every turn-end and refuses the close while ¬ terminus⟩
-revert    ≜ \`scripts/carryOn.mjs revert\` ∴ ¬ attached(target) ∧ loop-position := resting
-status    ≜ \`scripts/carryOn.mjs status\` ↦ ⟨attached(target), terminus⟩
+satisfied(context) ⇔ what was asked is delivered ∨ withdrawn
+elevate   ≜ loop-position := out-of-the-loop ∧ authority ↾ context := principal-self
+revert    ≜ loop-position := resting
 
 check-in-close ∧ re-dispatch-word ⇒ elevate
-elevate ⇒ standing-intent unchanged ∧ ¬fresh-dispatch ∧ ¬permission-grant
-elevate ⇒ resume execution ⟨own judgment · reversible-in-domain decided · no fresh permission owed⟩
-elevate defined ⇔ ¬ terminus ⟨at a terminus there is nothing to stay out of the loop FOR⟩
-elevate ⊨ attached(target) read back @ target ; ¬ attached ⇒ ⊥ ⟨loud ∧ ¬ elevation reported : text is advisory, a mechanism is not⟩
-attached(target) ∧ ¬ terminus ⇒ turn ¬ end ⟨the mechanism refuses ; the assertion never could⟩
-bind(P) ∧ ¬ terminus ⇒ persist ⟨∀ turn · ¬ per-turn-decay⟩
-terminus ⇒ revert ∴ loop-position = resting
-revert ∘ elevate ⊨ target ≡ target₀ ∧ foreign preserved ⟨zero residue⟩
-elevate ⊨ revert owed ⟨an un-reverted elevation outlives the plan it was bound to⟩
-terminus ≜ derived @ disk ⟨∴ a fresh process reads the same truth · ∄ read(transcript ∨ message) ∴ ∄ misfire on mid-turn narration⟩
-fork⊥ ⇒ write ${PLAN_MARKERS.rulingOwed} @ dir(P) ∧ surface the fork ∧ re-enter on-the-loop ⟨a fork surfaced without its carrier is unreadable at turn-end⟩
-sharded(P) ∧ ¬ done(P) ∧ frontier(P) = ∅ ⇒ terminus ∧ SURFACE ⟨R ill-formed ⟨cycle ∨ unsatisfiable dep⟩ · else the mis-cut wedges the session⟩
-regression ⇒ fix ∧ ¬check-in ⟨repair in the path is execution, ¬ a new fork⟩
-defect ∧ ¬regression ⇒ file ∧ ¬fix ⟨out-of-path defects are recorded, ¬ chased⟩
-verb ∉ { elevate · revert · terminus · status } ⇒ ⊥ ⟨loud⟩
+elevate ⇒ context unchanged ∧ ¬fresh-dispatch ∧ ¬permission-grant ∧ ¬scope-widen ⟨re-affirmation of authority already given, ¬ a new mandate⟩
+elevate ⇒ resume execution ⟨own judgment · reversible-in-domain decided · ∄ fresh permission owed⟩
+elevate ⇒ persist ∀ turn until revert ⟨¬ per-turn-decay : an affirmation uttered ONCE is ¬ re-owed every turn⟩
+elevate defined ⇔ ¬ satisfied(context) ⟨at a satisfied context there is nothing to stay out of the loop FOR⟩
+fork⊥ ⇒ surface ∧ revert ⟨authority to decide ≠ authority to decide THIS · a fork the principal cannot resolve is the operator's by construction⟩
+satisfied(context) ⇒ revert
+operator-redirect ⇒ revert ⟨the grant is the operator's to withdraw at any turn⟩
+¬ (context @ this cell) ⟨carry-on names no plan · no discussion · no artifact : the operator composes it with a context AT THE UTTERANCE, and a cell naming one forecloses the rest⟩
 `;
 export const carryOn = {
     name: 'carry-on',
-    description: `use this skill when the Operator utters the re-dispatch word (weitermachen · carry on · proceed) — closing a check-in and returning you to autonomous execution under re-affirmed authority; elevate installs the turn-end gate that holds the elevation (an assertion in prose is advisory, a gate is not), the elevation persists across turns bound to the bound praxis, and it lifts only at a terminus read from plan state on disk — the plan is done, a ruling is owed, or the cut is ill-formed — whereupon revert removes the gate with zero residue.`,
+    description: `use this skill when the Operator utters the re-dispatch word (weitermachen · carry on · proceed) — closing a check-in and returning you to autonomous execution under authority already granted, over whatever context is already in hand; the elevation persists across turns rather than decaying each turn, and it lifts when the context is satisfied, when the Operator redirects, or at a fork the principal cannot resolve, which is surfaced rather than decided. The context is the Operator's to name in the same breath ("carry on with the plan execution", "carry on with what we just discussed"); this skill supplies the authority, never the subject.`,
     formalBlock: carryOnNotation,
-    runtime: { capability: 'carryOn' },
-    composition: () => [praxis],
+    composition: () => [],
 };
 //# sourceMappingURL=skill.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/carry-on/skill.ts"],"names":[],"mappings":"AACA,mFAAmF;AACnF,mFAAmF;AACnF,kFAAkF;AAClF,yEAAyE;AACzE,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAChF,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAE5C,8EAA8E;AAC9E,MAAM,SAAS,GAAG,WAAW,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;AAEtD,mEAAmE;AACnE,MAAM,MAAM,GACV,iCAAiC,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,gBAAgB,SAAS,GAAG;IAClF,cAAc,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,mBAAmB,YAAY,CAAC,KAAK,GAAG;IAC7E,wBAAwB,YAAY,CAAC,UAAU,EAAE,CAAC;AAEpD,MAAM,eAAe,GACnB;;;;;;;;cAQY,MAAM;;mBAED,YAAY,CAAC,UAAU,kHAAkH,YAAY,CAAC,KAAK;;;;;;;;;;;;;;;;;;;;gBAoB9J,YAAY,CAAC,UAAU;;;;;CAKnB,CAAC;AAErB,MAAM,CAAC,MAAM,OAAO,GAAU;IAC5B,IAAI,EAAE,UAAU;IAChB,WAAW,EAAE,giBAAgiB;IAC7iB,WAAW,EAAE,eAAe;IAC5B,OAAO,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE;IAClC,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,MAAM,CAAC;CAC5B,CAAC"}
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/carry-on/skill.ts"],"names":[],"mappings":"AAEA,mEAAmE;AACnE,EAAE;AACF,6EAA6E;AAC7E,oFAAoF;AACpF,kFAAkF;AAClF,qFAAqF;AACrF,mFAAmF;AACnF,oFAAoF;AACpF,wEAAwE;AACxE,EAAE;AACF,iFAAiF;AACjF,kFAAkF;AAClF,gFAAgF;AAChF,EAAE;AACF,qFAAqF;AACrF,qFAAqF;AACrF,kFAAkF;AAClF,sFAAsF;AACtF,kFAAkF;AAClF,oFAAoF;AACpF,mFAAmF;AACnF,2CAA2C;AAE3C,MAAM,eAAe,GACnB;;;;;;;;;;;;;;;;;;;;;CAqBkB,CAAC;AAErB,MAAM,CAAC,MAAM,OAAO,GAAU;IAC5B,IAAI,EAAE,UAAU;IAChB,WAAW,EAAE,woBAAwoB;IACrpB,WAAW,EAAE,eAAe;IAC5B,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;CACtB,CAAC"}

package/dist/skills/conceptualize/skill.js

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

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

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