@cratylus/canon 0.3.0 → 0.5.0

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.3.0",
+  "version": "0.5.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.3.0"
   },
   "devDependencies": {
-    "@cratylus/forge": "0.6.0",
-    "@cratylus/runtime": "0.2.0",
+    "@cratylus/forge": "0.7.0",
+    "@cratylus/runtime": "0.3.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/dimensions/role/build.js

@@ -1,2 +0,0 @@
-export const build = `build ≜ ⟨conceive design produce deliver⟩`;
-//# sourceMappingURL=build.js.map

package/dist/dimensions/role/build.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"build.js","sourceRoot":"","sources":["../../../src/dimensions/role/build.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,KAAK,GAAS,2CAA2C,CAAC"}

package/dist/dimensions/role/converse.d.ts

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

package/dist/dimensions/role/converse.js

@@ -1,2 +0,0 @@
-export const converse = `converse ≜ dialogue ⟨the-deliverable⟩`;
-//# sourceMappingURL=converse.js.map

package/dist/dimensions/role/converse.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"converse.js","sourceRoot":"","sources":["../../../src/dimensions/role/converse.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,QAAQ,GAAS,uCAAuC,CAAC"}

package/dist/dimensions/role/curate.js

@@ -1,2 +0,0 @@
-export const curate = `curate ≜ ⟨canonical-corpus⟩`;
-//# sourceMappingURL=curate.js.map

package/dist/dimensions/role/curate.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"curate.js","sourceRoot":"","sources":["../../../src/dimensions/role/curate.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,MAAM,GAAS,6BAA6B,CAAC"}

package/dist/dimensions/role/diagnose.js

@@ -1,2 +0,0 @@
-export const diagnose = `diagnose`;
-//# sourceMappingURL=diagnose.js.map

package/dist/dimensions/role/diagnose.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"diagnose.js","sourceRoot":"","sources":["../../../src/dimensions/role/diagnose.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,QAAQ,GAAS,UAAU,CAAC"}

package/dist/dimensions/role/document.d.ts

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

package/dist/dimensions/role/document.js

@@ -1,2 +0,0 @@
-export const document = `document ≜ ⟨reader-facing explanatory⟩`;
-//# sourceMappingURL=document.js.map

package/dist/dimensions/role/document.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"document.js","sourceRoot":"","sources":["../../../src/dimensions/role/document.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,QAAQ,GAAS,wCAAwC,CAAC"}

package/dist/dimensions/role/implement.d.ts

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

package/dist/dimensions/role/implement.js

@@ -1,2 +0,0 @@
-export const implement = `implement`;
-//# sourceMappingURL=implement.js.map

package/dist/dimensions/role/implement.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"implement.js","sourceRoot":"","sources":["../../../src/dimensions/role/implement.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,SAAS,GAAS,WAAW,CAAC"}

package/dist/dimensions/role/operate.d.ts

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

package/dist/dimensions/role/operate.js

@@ -1,2 +0,0 @@
-export const operate = `operate ≜ live-system ⟨steady-state⟩`;
-//# sourceMappingURL=operate.js.map

package/dist/dimensions/role/operate.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"operate.js","sourceRoot":"","sources":["../../../src/dimensions/role/operate.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,OAAO,GAAS,sCAAsC,CAAC"}

package/dist/dimensions/role/orchestrate.d.ts

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

package/dist/dimensions/role/orchestrate.js

@@ -1,2 +0,0 @@
-export const orchestrate = `orchestrate`;
-//# sourceMappingURL=orchestrate.js.map

package/dist/dimensions/role/orchestrate.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"orchestrate.js","sourceRoot":"","sources":["../../../src/dimensions/role/orchestrate.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,WAAW,GAAS,aAAa,CAAC"}

package/dist/dimensions/role/plan.d.ts

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

package/dist/dimensions/role/plan.js

@@ -1,2 +0,0 @@
-export const plan = `plan ≜ ⟨decompose sequence⟩`;
-//# sourceMappingURL=plan.js.map

package/dist/dimensions/role/plan.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"plan.js","sourceRoot":"","sources":["../../../src/dimensions/role/plan.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,IAAI,GAAS,6BAA6B,CAAC"}

package/dist/dimensions/role/research.d.ts

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

package/dist/dimensions/role/research.js

@@ -1,2 +0,0 @@
-export const research = `research`;
-//# sourceMappingURL=research.js.map

package/dist/dimensions/role/research.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"research.js","sourceRoot":"","sources":["../../../src/dimensions/role/research.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,QAAQ,GAAS,UAAU,CAAC"}

package/dist/dimensions/role/review.d.ts

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

package/dist/dimensions/role/review.js

@@ -1,2 +0,0 @@
-export const review = `review`;
-//# sourceMappingURL=review.js.map

package/dist/dimensions/role/review.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"review.js","sourceRoot":"","sources":["../../../src/dimensions/role/review.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,MAAM,GAAS,QAAQ,CAAC"}

package/dist/dimensions/role/test.d.ts

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

package/dist/dimensions/role/test.js

@@ -1,2 +0,0 @@
-export const test = `test ≜ ⟨exercise pass-fail-evidence⟩`;
-//# sourceMappingURL=test.js.map

package/dist/dimensions/role/test.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"test.js","sourceRoot":"","sources":["../../../src/dimensions/role/test.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,IAAI,GAAS,sCAAsC,CAAC"}

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"}