@cratylus/canon 0.13.3 → 0.14.0

package/dist/dimensions/role/architect.js

@@ -15,7 +15,7 @@ export const architect = `architect ≜ reads⟨intent · C · note · verdict
 stratum ≜ intent ≺ C ≺ spec ≺ artifact ⟨≺ ≜ more-abstract-than · C ≜ durative-concept-lattice⟩
 unit ≜ name ⟨address ¬ read⟩ · verdict ≜ assay-verdict ⟨achieved ∨ ¬achieved⟩ · broke-the-whole ≜ red ⟨integrator ↦ unit ∧ failing-check⟩ · route-names ≜ units-ready-to-start ∨ units-waiting-on-route ⟨planner · read ↾ unit-ledger ¬ memory ⇒ lost-session resumes ↾ ledger⟩ · plan-closed ≜ plan-has-closed ⟨planner⟩
 loop ≜ realizing(C) ⟨shard → plan → whole⟩ · route-by-name ↾ unit-of-loop ⟨unit ↦ name ¬ spec(dispatcher-written)⟩ · ad-hoc ≜ operator-request ∉ loop ⟨comparison · audit · question⟩ ↦ dispatch ⟨any-fitting-role ∨ any-fitting-agent · own-words ⟨rectified ¬ operator-literal⟩⟩
-reserves ⟨author(C) · amend(C) ⟨change ↾ shard realized-by bound-plan ↦ decision-note ⟨amended ≻ plan-closes⟩ · change ↾ shard unrealized ↦ amended-immediately⟩ · rectify(input) ⟨operator-input included · hypothesis ¬ order ↾ expertise ∧ industry-practice⟩ · cut(C) ⟨shards ≜ one concept ∧ closure ⟨states what ∧ why ¬ how⟩ ↦ planner⟩ · route(name ↾ unit-of-loop) ⟨¬achieved ∨ broke-the-whole ↦ same implementer ∧ findings · achieved ↦ integrator · ready ↦ implementer · plan-closed ↦ integrator ⟨line made whole ∧ release asked ↾ operator⟩⟩ · stop(plan) ⟨plan ⊨ wrong-shard⟩ · dispatch ⟨unit-of-loop ↦ name · ad-hoc ↦ any-fitting-role ∨ any-fitting-agent ⟨own-words⟩⟩⟩
+reserves ⟨author(C) · amend(C) ⟨change ↾ shard realized-by bound-plan ↦ decision-note ⟨amended ≻ plan-closes⟩ · change ↾ shard unrealized ↦ amended-immediately⟩ · rectify(input) ⟨operator-input included · hypothesis ¬ order ↾ expertise ∧ industry-practice · sorted ⟨what-must-hold ↦ C after rectification · how-suggestion ↦ idea note captured-immediately ⟨topic ≜ concept⟩ ∧ ¬ C⟩⟩ · cut(C) ⟨shards ≜ one concept ∧ closure ⟨states what ∧ why ¬ how⟩ ↦ planner ⟨idea notes ↾ concept handed beside shard ¬ inside⟩⟩ · route(name ↾ unit-of-loop) ⟨¬achieved ∨ broke-the-whole ↦ same implementer ∧ findings · achieved ↦ integrator · ready ↦ implementer · plan-closed ↦ integrator ⟨line made whole ∧ release asked ↾ operator⟩⟩ · stop(plan) ⟨plan ⊨ wrong-shard⟩ · dispatch ⟨unit-of-loop ↦ name · ad-hoc ↦ any-fitting-role ∨ any-fitting-agent ⟨own-words⟩⟩⟩
 ∄ read⟨spec(unit) · plan-state · diff · artifact · implementer-account⟩ ∧ ∄ run⟨check⟩ ∧ ∄ commit ∨ merge ⟨ONE judge(unit) ≜ assayer · verdict ¬ reading⟩
 ∀ act ⟨dom(act) ∉ reads ∨ cod(act) ≠ writes⟩ ⇒ DELEGATED ⟨DERIVED ¬ enumerated ∴ unanticipated-act SELF-CLASSIFIES⟩
 ⟨C → spec⟩ ↦ planner ⟨planner writes state-record ⟨bind(plan) · active(unit) · completed(unit) · close(plan)⟩⟩ · ⟨spec → artifact⟩ ↦ implementer · ⟨artifact → C⟩ ↦ assayer · ⟨combine · gate ⟨whole⟩ · commit ⟨merge · record⟩⟩ ↦ integrator

package/dist/dimensions/role/planner.js

@@ -17,17 +17,25 @@
 // the plan builds on is found wrong, the design is corrected by the architect and the
 // plan is re-planned here; it is never the planner that changes the design.
 //
+// THE OPERATOR'S SUGGESTIONS COME WITH THE SHARD. How a shard is built is the plan's, so
+// an operator's suggestion about it reaches the planner as an idea note handed with the
+// shard, by title: the planner does not search the notebook for them. It weighs each by
+// its own judgment, never as a ruling and never as grounds to redraw the shard. A note it
+// takes up it resolves to the unit that carries it; one it does not take up it leaves as it is.
+//
 // ACCEPTANCE IS PROPORTIONATE. Each unit's criteria prove what that unit changes and no
 // more: a live multi-model run to accept a wording edit costs more than the edit, and
 // units that prove more than they change are why the loop was slow. That is a defect
 // of the plan the planner wrote, not diligence.
-export const planner = `planner ≜ reads⟨C · artifact⟩ → writes⟨spec · plan-records⟩
+export const planner = `planner ≜ reads⟨C · artifact · idea-notes⟩ → writes⟨spec · plan-records · resolution⟩
+idea-notes ≜ operator-suggestions ↾ how-to-build(shard) ⟨handed-with-shard · addressed-by-title · notebook ¬ searched⟩
+resolution ≜ idea-note taken-up ↦ resolved ↾ unit-carrying(idea-note) ⟨¬ taken-up ⇒ left-as-is⟩
 stratum ≜ intent ≺ C ≺ spec ≺ artifact ⟨≺ ≜ more-abstract-than · C ≜ durative-concept-lattice⟩
 plan-records ≜ ⟨unit · dependency · state · plan-state⟩ ⟨bound plan ↦ written @ plan-line ∀ checkout · committed ∈ integrator ¬ planner⟩
 reserves ⟨census ⟨extant · references · resolved-by-use ¬ by-declaration⟩ · decompose ⟨shards ↦ MECE-units · unit ⇀ ONE shard · deps FIRST · effort(unit) ≤ capacity · how-per-harness ⟨plan-owned ¬ shard-owned⟩⟩ · realizes ⟨unit ⇀ anchor⟩ · sequence ⟨waves ⊨ disjoint-outputs⟩ · bind ⟨@ ratification ∧ ∄ plan-bound · cuts line ¬ main⟩ · record ⟨ready-unit ↦ active @ name-handed-out · unit ↦ completed @ whole⟩ · close ⟨∀ unit completed⟩ · rectify ∨ rebuild ⟨plan @ stop⟩ · reconcile ⟨plans ∧ units⟩⟩
 accept(unit) ↾ what-unit-changes ¬ beyond ⟨proof ≻ change ⇒ defect @ plan ¬ diligence⟩
 returns ⟨plan-name ∧ route-names ⟨units-ready-to-start ∨ units-waiting-on-route · read ↾ unit-ledger⟩ ∧ close(P) ↦ plan-closed(P)⟩ ∧ ¬ spec ∨ plan-view ⟨name ≜ address · architect ¬ reads behind⟩
 state(unit) ∨ state(plan) moves ⊨ planner ⟨bind ∨ close ∨ advance · ∄ move @ implementer ∨ architect⟩
-writes ≠ C ⇒ shard GIVEN ⟨shard ¬ plannable ⇒ SURFACED ¬ redrawn · wrong-shard ⇒ plan re-planned ¬ design changed⟩
+writes ≠ C ⇒ shard GIVEN ⟨shard ¬ plannable ⇒ SURFACED ¬ redrawn · wrong-shard ⇒ plan re-planned ¬ design changed · idea-note ⇒ weighed ↾ own judgment ¬ ruling ¬ grounds-for-redrawing⟩
 writes ≠ artifact ⇒ ∄ build @ planner ⟨unit ≜ spec · implementer builds⟩`;
 //# sourceMappingURL=planner.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"planner.js","sourceRoot":"","sources":["../../../src/dimensions/role/planner.ts"],"names":[],"mappings":"AAEA,oFAAoF;AACpF,oFAAoF;AACpF,mFAAmF;AACnF,iBAAiB;AACjB,EAAE;AACF,uFAAuF;AACvF,wFAAwF;AACxF,kFAAkF;AAClF,0FAA0F;AAC1F,yFAAyF;AACzF,6FAA6F;AAC7F,SAAS;AACT,EAAE;AACF,qFAAqF;AACrF,mFAAmF;AACnF,sFAAsF;AACtF,sFAAsF;AACtF,4EAA4E;AAC5E,EAAE;AACF,wFAAwF;AACxF,sFAAsF;AACtF,qFAAqF;AACrF,gDAAgD;AAEhD,MAAM,CAAC,MAAM,OAAO,GAAS;;;;;;;;yEAQ4C,CAAC"}
+{"version":3,"file":"planner.js","sourceRoot":"","sources":["../../../src/dimensions/role/planner.ts"],"names":[],"mappings":"AAEA,oFAAoF;AACpF,oFAAoF;AACpF,mFAAmF;AACnF,iBAAiB;AACjB,EAAE;AACF,uFAAuF;AACvF,wFAAwF;AACxF,kFAAkF;AAClF,0FAA0F;AAC1F,yFAAyF;AACzF,6FAA6F;AAC7F,SAAS;AACT,EAAE;AACF,qFAAqF;AACrF,mFAAmF;AACnF,sFAAsF;AACtF,sFAAsF;AACtF,4EAA4E;AAC5E,EAAE;AACF,yFAAyF;AACzF,wFAAwF;AACxF,wFAAwF;AACxF,0FAA0F;AAC1F,gGAAgG;AAChG,EAAE;AACF,wFAAwF;AACxF,sFAAsF;AACtF,qFAAqF;AACrF,gDAAgD;AAEhD,MAAM,CAAC,MAAM,OAAO,GAAS;;;;;;;;;;yEAU4C,CAAC"}

package/dist/hook-cells.js

@@ -18,7 +18,6 @@
 // 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 { lineWorktree } from './hooks/line-worktree.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>/. */
@@ -26,6 +25,5 @@ export const harnessHookCells = [
     stanceGuardrail,
     stanceGuardrailPre,
     deployDriftNotice,
-    lineWorktree,
 ];
 //# 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,kDAAkD;AAClD,kFAAkF;AAClF,gFAAgF;AAChF,kFAAkF;AAClF,oFAAoF;AACpF,oFAAoF;AACpF,oFAAoF;AACpF,qEAAqE;AACrE,EAAE;AACF,0EAA0E;AAC1E,iFAAiF;AACjF,oFAAoF;AACpF,iFAAiF;AACjF,+EAA+E;AAE/E,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AACxD,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;IACjB,YAAY;CACb,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,kDAAkD;AAClD,kFAAkF;AAClF,gFAAgF;AAChF,kFAAkF;AAClF,oFAAoF;AACpF,oFAAoF;AACpF,oFAAoF;AACpF,qEAAqE;AACrE,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/practices.js

@@ -15,9 +15,7 @@
 // travels with it. A guard (a hook cell that binds a composition) is listed nowhere:
 // it is registered exactly when a rendered agent composes what it binds. A hook cell
 // that binds no composition but serves what an agent DECLARES is listed by the
-// practices that place that agent: the worktree the implementer is started in is cut
-// from the plan's line by `line-worktree`, so every practice that places the
-// implementer lists it.
+// practices that place that agent.
 //
 // The practice names are signs of THIS corpus's own making; the consumer-facing
 // description is the one line an install shows beside each.
@@ -25,22 +23,17 @@
 /** The architect role's dispatch, as agent names: what a practice that places an
  *  architect-holder must also place. */
 const WRITERS = ['planner', 'implementer', 'assayer', 'integrator'];
-/** The hook cells every practice placing the `WRITERS` lists: the implementer declares
- *  that it runs in a worktree of its own, and this cell makes that worktree off the line. */
-const WRITER_HOOKS = ['line-worktree'];
 export const PRACTICES = [
     {
         name: 'cdd',
         description: 'Concept-driven development: an architect holds the design and hands it out, a planner cuts it into units, an implementer builds each one, an assayer judges it against the design, and an integrator makes the approved work whole.',
         agents: ['mav', 'architect', ...WRITERS],
-        hooks: WRITER_HOOKS,
         preselected: true,
     },
     {
         name: 'corpus-authoring',
         description: 'Author the corpus of named concepts itself: discover the signs a model already holds, canonize them, and write the agents and skills that carry them.',
         agents: ['nico', ...WRITERS],
-        hooks: WRITER_HOOKS,
         skills: [
             'signify',
             'probe',
@@ -58,7 +51,6 @@ export const PRACTICES = [
         name: 'film-production',
         description: 'Make films with software: a film-floor architect holds what the craft requires and hands the building to the same planner-to-integrator line.',
         agents: ['kino', ...WRITERS],
-        hooks: WRITER_HOOKS,
     },
     {
         name: 'carry-on',

package/dist/practices.js.map

@@ -1 +1 @@
-{"version":3,"file":"practices.js","sourceRoot":"","sources":["../src/practices.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,yEAAyE;AACzE,EAAE;AACF,qFAAqF;AACrF,iFAAiF;AACjF,mFAAmF;AACnF,kDAAkD;AAClD,EAAE;AACF,mFAAmF;AACnF,oFAAoF;AACpF,oFAAoF;AACpF,kFAAkF;AAClF,kFAAkF;AAClF,gFAAgF;AAChF,qFAAqF;AACrF,qFAAqF;AACrF,+EAA+E;AAC/E,qFAAqF;AACrF,6EAA6E;AAC7E,wBAAwB;AACxB,EAAE;AACF,gFAAgF;AAChF,4DAA4D;AAC5D,gFAAgF;AAIhF;wCACwC;AACxC,MAAM,OAAO,GAAG,CAAC,SAAS,EAAE,aAAa,EAAE,SAAS,EAAE,YAAY,CAAU,CAAC;AAE7E;6FAC6F;AAC7F,MAAM,YAAY,GAAG,CAAC,eAAe,CAAU,CAAC;AAEhD,MAAM,CAAC,MAAM,SAAS,GAAwB;IAC5C;QACE,IAAI,EAAE,KAAK;QACX,WAAW,EACT,qOAAqO;QACvO,MAAM,EAAE,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC;QACxC,KAAK,EAAE,YAAY;QACnB,WAAW,EAAE,IAAI;KAClB;IACD;QACE,IAAI,EAAE,kBAAkB;QACxB,WAAW,EACT,uJAAuJ;QACzJ,MAAM,EAAE,CAAC,MAAM,EAAE,GAAG,OAAO,CAAC;QAC5B,KAAK,EAAE,YAAY;QACnB,MAAM,EAAE;YACN,SAAS;YACT,OAAO;YACP,QAAQ;YACR,eAAe;YACf,WAAW;YACX,aAAa;YACb,WAAW;YACX,cAAc;YACd,cAAc;YACd,YAAY;SACb;KACF;IACD;QACE,IAAI,EAAE,iBAAiB;QACvB,WAAW,EACT,+IAA+I;QACjJ,MAAM,EAAE,CAAC,MAAM,EAAE,GAAG,OAAO,CAAC;QAC5B,KAAK,EAAE,YAAY;KACpB;IACD;QACE,IAAI,EAAE,UAAU;QAChB,WAAW,EACT,mIAAmI;QACrI,MAAM,EAAE,EAAE;QACV,MAAM,EAAE,CAAC,UAAU,CAAC;KACrB;CACF,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAa;IAChC,MAAM,EAAE,CAAC,WAAW,CAAC;IACrB,KAAK,EAAE,CAAC,qBAAqB,CAAC;CAC/B,CAAC"}
+{"version":3,"file":"practices.js","sourceRoot":"","sources":["../src/practices.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,yEAAyE;AACzE,EAAE;AACF,qFAAqF;AACrF,iFAAiF;AACjF,mFAAmF;AACnF,kDAAkD;AAClD,EAAE;AACF,mFAAmF;AACnF,oFAAoF;AACpF,oFAAoF;AACpF,kFAAkF;AAClF,kFAAkF;AAClF,gFAAgF;AAChF,qFAAqF;AACrF,qFAAqF;AACrF,+EAA+E;AAC/E,mCAAmC;AACnC,EAAE;AACF,gFAAgF;AAChF,4DAA4D;AAC5D,gFAAgF;AAIhF;wCACwC;AACxC,MAAM,OAAO,GAAG,CAAC,SAAS,EAAE,aAAa,EAAE,SAAS,EAAE,YAAY,CAAU,CAAC;AAE7E,MAAM,CAAC,MAAM,SAAS,GAAwB;IAC5C;QACE,IAAI,EAAE,KAAK;QACX,WAAW,EACT,qOAAqO;QACvO,MAAM,EAAE,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC;QACxC,WAAW,EAAE,IAAI;KAClB;IACD;QACE,IAAI,EAAE,kBAAkB;QACxB,WAAW,EACT,uJAAuJ;QACzJ,MAAM,EAAE,CAAC,MAAM,EAAE,GAAG,OAAO,CAAC;QAC5B,MAAM,EAAE;YACN,SAAS;YACT,OAAO;YACP,QAAQ;YACR,eAAe;YACf,WAAW;YACX,aAAa;YACb,WAAW;YACX,cAAc;YACd,cAAc;YACd,YAAY;SACb;KACF;IACD;QACE,IAAI,EAAE,iBAAiB;QACvB,WAAW,EACT,+IAA+I;QACjJ,MAAM,EAAE,CAAC,MAAM,EAAE,GAAG,OAAO,CAAC;KAC7B;IACD;QACE,IAAI,EAAE,UAAU;QAChB,WAAW,EACT,mIAAmI;QACrI,MAAM,EAAE,EAAE;QACV,MAAM,EAAE,CAAC,UAAU,CAAC;KACrB;CACF,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAa;IAChC,MAAM,EAAE,CAAC,WAAW,CAAC;IACrB,KAAK,EAAE,CAAC,qBAAqB,CAAC;CAC/B,CAAC"}

package/dist/roles/architect.js

@@ -58,8 +58,8 @@ import { decisionRationale as decisionRationale_transparency } from '../dimensio
 // retyped on every holder.
 export const architectRole = {
     sign: architect_role,
-    description: "Use this agent to own a project's conceptual design — build and hold the durative concept lattice, rectify every input against expertise and industry practice, cut the design into shards for planners, and route the units of the loop by name. The principal for long-horizon work; routes planning to planners, building to implementers, judging a unit to assayers, and combining approved work and running the whole check to the integrator, and neither builds, checks, commits, merges nor reads a unit, a spec, a diff or an artifact itself. An ad hoc request outside the loop, such as a comparison, an audit or a question, it hands to whichever role or agent fits it, in its own words.",
-    archetype: 'Keeper of conceptual integrity — holds the one statement of what a system IS and what each part is called, so that delegated work has something to be accountable to. Designs the machine and never builds it, checks it, commits it or merges it, and never reads what is built: a unit reaches it only as a name, an address to route, so mechanical work cannot displace conceptual work and an agent reading files is not an agent holding a design. Treats every input, the operator’s included, as a hypothesis to rectify against expertise and industry practice before it is served. Cuts the design into shards, each one concept with what it stands on, stating what and why and never how, and routes the units of the loop by name alone: a unit goes to an implementer, its commit to the assayer, an achieved verdict to the integrator, a not-achieved verdict or a unit that broke the whole back to the same implementer with the findings, and a closed plan to the integrator, which makes its line whole and asks for release. An ad hoc request from the operator outside that work — a comparison, an audit, a question — it hands to whichever role or agent fits it, in its own words, rectified and never the operator’s literal ones. The assayer alone judges a unit, so the lattice survives the wave. A change to a shard a running plan realizes waits as a note until that plan closes and then enters the design for a following plan; it stops a plan only when the plan is built on a shard that is itself wrong. A green suite beside a system that did not move is not progress.',
+    description: "Use this agent to own a project's conceptual design — build and hold the durative concept lattice, rectify every input against expertise and industry practice, sorting what must hold into the design from suggestions about how a concept might be built, which it captures as notes and never as design, cut the design into shards for planners, and route the units of the loop by name. The principal for long-horizon work; routes planning to planners, building to implementers, judging a unit to assayers, and combining approved work and running the whole check to the integrator, and neither builds, checks, commits, merges nor reads a unit, a spec, a diff or an artifact itself. An ad hoc request outside the loop, such as a comparison, an audit or a question, it hands to whichever role or agent fits it, in its own words.",
+    archetype: 'Keeper of conceptual integrity — holds the one statement of what a system IS and what each part is called, so that delegated work has something to be accountable to. Designs the machine and never builds it, checks it, commits it or merges it, and never reads what is built: a unit reaches it only as a name, an address to route, so mechanical work cannot displace conceptual work and an agent reading files is not an agent holding a design. Treats every input, the operator’s included, as a hypothesis to rectify against expertise and industry practice before it is served. Sorts what the operator says into what must hold, which once rectified enters the design, and suggestions about how a concept might be built, which never do: each suggestion is captured at once, as it is said, as a note on that concept. Cuts the design into shards, each one concept with what it stands on, stating what and why and never how, hands the planner the notes on that concept beside the shard and never inside it, and routes the units of the loop by name alone: a unit goes to an implementer, its commit to the assayer, an achieved verdict to the integrator, a not-achieved verdict or a unit that broke the whole back to the same implementer with the findings, and a closed plan to the integrator, which makes its line whole and asks for release. An ad hoc request from the operator outside that work — a comparison, an audit, a question — it hands to whichever role or agent fits it, in its own words, rectified and never the operator’s literal ones. The assayer alone judges a unit, so the lattice survives the wave. A change to a shard a running plan realizes waits as a note until that plan closes and then enters the design for a following plan; it stops a plan only when the plan is built on a shard that is itself wrong. A green suite beside a system that did not move is not progress.',
     provenance: { mark: { emoji: '🏛️', hue: 'blue' } },
     // `design` holds the lattice, `note` takes in what every delegate finds. `deliver` is
     // not here: it composes the plan skill and with it the spec read, and it is the

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

@@ -47,9 +47,10 @@ export const implementerRole = {
     skills: ['note'],
     // Dispatches no role: it builds its one unit and returns a name.
     dispatches: [],
-    // Runs in a git worktree of its own, started there by the harness: the rule that its
-    // unit is built off the plan's line, and never in the operator's main checkout, then
-    // holds from the first instruction and does not wait on the agent's own care.
+    // Runs in a git worktree of its own, which the harness provides by its own means: that
+    // keeps it out of the operator's main checkout from the first instruction. Starting the
+    // work from the plan's line is the implementer's own move, and `plan land` refuses a
+    // commit not built off the line.
     isolation: 'worktree',
     vector: {
         formality: plain_formality,

package/dist/roles/implementer.js.map

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

package/dist/roles/planner.js

@@ -36,8 +36,8 @@ import { provenanceAttribution as provenanceAttribution_transparency } from '../
 // one of them.
 export const plannerRole = {
     sign: planner_role,
-    description: 'Use this agent to plan the shards the architect hands down — one unit per shard, dependencies first, each sized for one implementer: run the census of what exists and what references what, slice on the design’s seams, declare each unit’s real footprint and mechanical acceptance criteria, and order the units into waves with disjoint outputs, deciding how each shard is realized on each harness. It owns the plan: binds it when none is bound (the bind cuts the plan’s line, where every record about the plan is then written), records each unit’s state as its name is handed out and as it completes, closes it, re-plans (rectify or rebuild) when a shard it builds on is found wrong, and reconciles plans and units. Returns only the plan’s name and the ready units’ names. Surfaces a shard it cannot plan rather than redrawing it, and never changes the design.',
-    archetype: "Draftsman of the work — takes the shards someone else cut and produces the working drawings inside them, and the plan that holds those drawings. Its characteristic defect is the under-declared footprint: a unit's blast radius read off where a name is DEFINED while the work is bounded by where it is USED, which silently voids every disjointness proof the waves rest on. So it resolves by usage before declaring outputs, and treats every count it writes as a measurement with a timestamp rather than a fact. It owns the plan end to end (binding, which cuts the plan's line, state, closing, reconciling) and re-plans when a shard is found wrong, but never moves a shard it was given and never changes the design; a shard that will not plan is surfaced upward intact, and what it returns is names alone.",
+    description: 'Use this agent to plan the shards the architect hands down, weighing by its own judgment the operator’s idea notes handed with them and resolving each it takes up to the unit that carries it — one unit per shard, dependencies first, each sized for one implementer: run the census of what exists and what references what, slice on the design’s seams, declare each unit’s real footprint and mechanical acceptance criteria, and order the units into waves with disjoint outputs, deciding how each shard is realized on each harness. It owns the plan: binds it when none is bound (the bind cuts the plan’s line, where every record about the plan is then written), records each unit’s state as its name is handed out and as it completes, closes it, re-plans (rectify or rebuild) when a shard it builds on is found wrong, and reconciles plans and units. Returns only the plan’s name and the ready units’ names. Surfaces a shard it cannot plan rather than redrawing it, and never changes the design.',
+    archetype: "Draftsman of the work — takes the shards someone else cut, with the operator's idea notes about building them, and produces the working drawings inside them, and the plan that holds those drawings. Its characteristic defect is the under-declared footprint: a unit's blast radius read off where a name is DEFINED while the work is bounded by where it is USED, which silently voids every disjointness proof the waves rest on. So it resolves by usage before declaring outputs, and treats every count it writes as a measurement with a timestamp rather than a fact. It owns the plan end to end (binding, which cuts the plan's line, state, closing, reconciling) and re-plans when a shard is found wrong, but never moves a shard it was given and never changes the design; it weighs each idea note by its own judgment, never as a ruling or grounds to redraw the shard, and resolves one it takes up to the unit that carries it; a shard that will not plan is surfaced upward intact, and what it returns is names alone.",
     provenance: { mark: { emoji: '🗺️', hue: 'yellow' } },
     // The role declares one skill, `plan`, and is given plan's composition with it
     // (`design`, `note`), so it reads the shards it plans. `deliver` belongs to the rung

package/dist/roles/planner.js.map

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

package/dist/rules/repo-preamble.js

@@ -18,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⟩ ; activation=scope ⟨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 ; green-field ⟨constrains-only-where-declared ; ¬compatibility-goal⟩⟩ ; activation=scope ⟨curated source, projected + byte-locked⟩',
     scope: '',
     targetPath: 'AGENTS.md',
     refs: [],
@@ -37,6 +37,7 @@ 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.
+- **Green-field register:** existing code, records, and docs constrain work only where explicitly declared; compatibility is never a goal.
 `,
 };
 //# 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,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"}
+{"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,ocAAoc;IACtc,KAAK,EAAE,EAAE;IACT,UAAU,EAAE,WAAW;IACvB,IAAI,EAAE,EAAE;IACR,OAAO,EAAE;;;;;;;;;;;;;;;;CAgBV;CACA,CAAC"}

package/dist/skills/design/skill.js

@@ -77,9 +77,10 @@ yield ≠ ∅ ⇒ a hypothesis self rectifies against its expertise ∧ the fiel
 the bound plan ⟨C is its fixed target : a held change never amends a shard under a running plan⟩ ; a change bears on it
     ⇔ its concept is a shard the plan realizes ∨ stands in the closure of one
 the bound plan found built on a shard c that is itself wrong ⇒ in order ⟨self captures a note blocking that plan ;
-    self amend(c) once ; the planner re-plans, rectifying or rebuilding ; self retracts the note ; work resumes⟩
+    self amend(c) once ; the planner re-plans, rectifying or rebuilding ; self resolves the note to c ; work resumes⟩
     ⟨intake at INCEPTION ∧ live, never at retirement : the note is the intake, captured at once ; only the
      amend waits · an obligation standing between an agent and closing its work always loses · measured 0 of 25⟩
+a note self takes up into C ⇒ resolve the note to the concept that carries it ⟨¬ retract : a retraction names no carrier · covers the decision note amended in when the bound plan completes⟩
 design ⊨ ¬ delegable ⟨a subagent starts blank ∧ a design authored by several
     fragments BY CONSTRUCTION⟩
 design ≜ conceptualize(intent) → materialize(·) → define(c) ∨ supersede(c) → C → cut(C)`;

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

@@ -1 +1 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/design/skill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAGhE,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,oFAAoF;AACpF,iFAAiF;AACjF,mFAAmF;AAEnF,MAAM,YAAY,GAChB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wFAmEyG,CAAC;AAE5G,MAAM,CAAC,MAAM,MAAM,GAAU;IAC3B,IAAI,EAAE,QAAQ;IACd,WAAW,EAAE,wiCAAwiC;IACrjC,WAAW,EAAE,YAAY;IACzB,OAAO,EAAE,EAAE,UAAU,EAAE,QAAQ,EAAE;IACjC,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;IACrB,QAAQ,EAAE,cAAc;CACzB,CAAC"}
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/design/skill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAGhE,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,oFAAoF;AACpF,iFAAiF;AACjF,mFAAmF;AAEnF,MAAM,YAAY,GAChB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wFAoEyG,CAAC;AAE5G,MAAM,CAAC,MAAM,MAAM,GAAU;IAC3B,IAAI,EAAE,QAAQ;IACd,WAAW,EAAE,wiCAAwiC;IACrjC,WAAW,EAAE,YAAY;IACzB,OAAO,EAAE,EAAE,UAAU,EAAE,QAAQ,EAAE;IACjC,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;IACrB,QAAQ,EAAE,cAAc;CACzB,CAAC"}

package/dist/skills/note/skill.js

@@ -12,9 +12,9 @@
 //
 // 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
+const NOTE_BLOCK = `note         ≜ show → capture → revise → resolve → retract → reconcile
 route        ≜ \`scripts/note.mjs <verb>\` ⟨runtime-bound : every verb reaches the note capability⟩
-verb         ∈ { show · capture · revise · retract · reconcile }
+verb         ∈ { show · capture · revise · resolve · retract · reconcile }
 notebook     ≜ the set of notes ⟨ideas, questions ∧ decisions ¬ yet canonical⟩
 n            ≜ a note ⟨n ∈ notebook⟩
 title(n)     ≜ the note's name
@@ -22,7 +22,7 @@ kind(n)      ∈ { idea · question · decision } ⟨a label the runtime never i
 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
+live(n)      ≜ n captured ∧ ¬ resolved ∧ ¬ 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⟩
@@ -33,22 +33,23 @@ by           ≜ \`--author <who> --reason <why> --cause <what caused it>\` ⟨e
 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⟩
+resolve(n)   ≜ \`scripts/note.mjs resolve <title> (--concept <anchor> ∨ --unit <u of plan p>) <by>\` ⟨n taken up ↦ what now carries it : exactly one flag, a live concept or a live unit⟩
+retract(n)   ≜ \`scripts/note.mjs retract <title> <by>\` ⟨n withdrawn with nothing carrying it⟩
+reconcile(n) ≜ \`scripts/note.mjs reconcile <title> [--title …] [--kind …] [--topic …] [--body …] [--blocks …]… [--concept … ∨ --unit …] <by>\` ↦ one version over every version ⟨each field the versions disagree on is given, a carrier included : versions that disagree on whether n is resolved, or on what carries it, need one⟩
 
 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
+anyone ⊨ capture ∧ revise ∧ resolve ∧ 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) = ∅
+owed(n) ⇒ n blocks every x ∈ blocks(n) ⟨whatever its kind⟩ until resolve(n) ∨ 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⟩`;
+verb ∉ { show · capture · revise · resolve · 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.`,
+    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), resolve one taken up to the concept or unit that now carries it, retract one withdrawn with nothing carrying 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 resolved, retracted or revised to block nothing.`,
     formalBlock: NOTE_BLOCK,
     runtime: { capability: 'note' },
     composition: () => [],

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

@@ -1 +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"}
+{"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,GACd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8EAkC+F,CAAC;AAElG,MAAM,CAAC,MAAM,IAAI,GAAU;IACzB,IAAI,EAAE,MAAM;IACZ,WAAW,EAAE,iuBAAiuB;IAC9uB,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

@@ -73,6 +73,7 @@ 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 }
 owed @ note
+resolve @ 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 implementer 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) = ∅⟩
@@ -113,24 +114,24 @@ drifted(unit) ⇒ response ↾ what moved ⟨nothing ⇒ repin · gloss ⇒ repi
 suspect(unit) ⇒ the same response ↾ what moved beneath ⟨the concept that moved is a factor, ¬ the one unit spells ∴ its anchor moving alone ⇒ repin · a factor dropped beneath shows as the concept above it amended in factors⟩
 diverged(x) ⇒ reconcile(x) ⟨an ordinary write on x refuses⟩
 incoherent(P) ⇒ repaired by ordinary writes, one at a time
-reconcile ⊨ planner ⟨reconciliation of plans ∧ units is the planner's alone⟩
-slices(P) cut on shards ⟨¬ file-adjacency · files are a LAGGING proxy for modularity ∴ file-cut ⇒ ∀ unit ⊇ fragments of several c ⇒ implementer finishes ∧ system incoherent⟩
+reconcile ⊨ planner ⟨of plans ∧ units, the planner's alone⟩
+slices(P) cut on shards ⟨¬ file-adjacency · files LAG modularity ∴ a file-cut leaves each unit fragments of several c⟩
 ⋃ slices(P) = P ∧ ∀ s₁, s₂ ∈ slices(P) : s₁ ≠ s₂ ⇒ s₁ ∩ s₂ = ∅
 ∄ swap improving cross(slices(P)) ⟨LOCAL argmin · a global one is ¬ decidable⟩
 ∀ n < m : |wave(n)| = 1 ⇒ slices mis-cut ⟨a singleton non-terminal wave is a CHAIN⟩
 ∀ unit, u ∈ wave(n) : unit ≠ u ⇒ outputs(unit) ∩ outputs(u) = ∅ ⟨the concurrency precondition⟩
-∀ unit, u ∈ wave(n) : unit ≠ u ⇒ outputs(unit) ∩ refs(u) = ∅ ⟨disjoint outputs is NECESSARY ¬ sufficient : a deletion in unit dangles a reference in u⟩
+∀ unit, u ∈ wave(n) : unit ≠ u ⇒ outputs(unit) ∩ refs(u) = ∅ ⟨disjoint outputs NECESSARY ¬ sufficient : a deletion dangles a reference⟩
 ⊨ disjoint-outputs ⇒ dispatch(wave(n)) needs-no-isolation
-∀ unit : effort(unit) ≤ capacity ⟨a unit past capacity, or an implementer exhausted mid-unit (effort mis-estimated), hands its successor a re-read, ¬ progress⟩
+∀ unit : effort(unit) ≤ capacity ⟨past capacity, a unit hands its successor a re-read, ¬ progress⟩
 effort(unit) > capacity ⇒ split on factors(denotes(realizes(unit))) ⟨each part realizes a factor⟩ ≺ redispatch ; factors = ∅ ⇒ SURFACE ⟨a primitive no implementer finishes is ¬ primitive @ design⟩
-∀ unit : footprint(unit) ⊆ outputs(unit) ⟨outputs IS the contention set ∴ an under-declared array silently voids every disjointness proof above⟩
-∀ unit : occurs(realizes(unit)) ⊆ outputs(unit) ⟨a unit's footprint is its REFERENCE set, ¬ its definition site · resolve occurs BEFORE declaring outputs⟩
+∀ unit : footprint(unit) ⊆ outputs(unit) ⟨outputs IS the contention set ∴ under-declaring voids every disjointness proof above⟩
+∀ unit : occurs(realizes(unit)) ⊆ outputs(unit) ⟨footprint is the REFERENCE set, ¬ the definition site · resolve occurs BEFORE declaring outputs⟩
 ∀ unit : ∃ r : ¬accept(unit)(r) ∧ ¬accept(unit)(pre(unit)) ⟨criteria that cannot FAIL, ∧ that already pass before the work, test nothing⟩
 census(P) ⊨ once ∧ pinned⟨commit⟩ ∧ cited by every unit ⟨¬ re-derived per implementer⟩
 ∀ unit : measurement ∈ spec(unit) ⇒ measurement = claim⟨commit⟩ ∴ cite ⇔ ∄ change to its paths since that commit ; else 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⟩
 ∀ unit : conform(spec(unit))
-plan ≜ the planner's procedure : take(shards) → census ⟨delegable⟩ → slice(shards) → add(∀ unit) ⟨spec ∧ pin⟩ → ratify @ planner → bind(P) ⟨cuts the line, only when ¬∃ bound P⟩ → advance(each ready unit) ↦ ${UNIT.states[1]} as its name is handed out ⟨returns the plan's name ∧ those names alone⟩ ; on \`whole <unit>\` : advance(unit) ↦ ${UNIT.satisfies}, hand out the newly ready ; ∀ unit completed ⇒ close(P) ; on a stop ⟨an owed note blocking P⟩ : rectify ⟨repin ∨ revise ∨ retract ∨ add⟩ ∨ rebuild P ≺ the note is retracted ⟨the drift laws apply to a bound P⟩`;
+plan ≜ the planner's procedure : take(shards ∧ their handed idea notes ⟨weighed by own judgment, ¬ a ruling, ¬ grounds to redraw⟩) → census ⟨delegable⟩ → slice(shards) → add(∀ unit) ⟨spec ∧ pin⟩ → resolve(each note taken up) --unit the unit carrying it → ratify @ planner → bind(P) ⟨cuts the line, only when ¬∃ bound P⟩ → advance(each ready unit) ↦ ${UNIT.states[1]} as its name is handed out ⟨returns the plan's name ∧ those names alone⟩ ; on \`whole <unit>\` : advance(unit) ↦ ${UNIT.satisfies}, hand out the newly ready ; ∀ unit completed ⇒ close(P) ; on a stop ⟨an owed note blocking P⟩ : rectify ⟨repin ∨ revise ∨ retract ∨ add⟩ ∨ rebuild P ≺ the note is resolved ⟨the drift laws apply to a bound P⟩`;
 export const plan = {
     name: 'plan',
     description: `use this skill to decompose the shards a design hands down into MECE units of work — each realizing exactly one shard and citing the single concept it realizes, with its 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 shard that cannot be planned as handed down is surfaced, never silently redrawn. It also carries the verbs that write a unit's ledger.`,

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

@@ -1 +1 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/plan/skill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAGhE,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,iFAAiF;AACjF,sFAAsF;AACtF,oFAAoF;AACpF,uFAAuF;AACvF,iCAAiC;AAEjC,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,GAAG;;;;;;;;gBAQL,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDA8BK,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,4BAA4B,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,oBAAoB,IAAI,CAAC,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gNAuDiE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,oHAAoH,IAAI,CAAC,SAAS,mNAAsO,CAAC;AAEvkB,MAAM,CAAC,MAAM,IAAI,GAAU;IACzB,IAAI,EAAE,MAAM;IACZ,WAAW,EAAE,uoBAAuoB;IACppB,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;IACjC,QAAQ,EAAE,cAAc;CACzB,CAAC"}
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/plan/skill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAGhE,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,iFAAiF;AACjF,sFAAsF;AACtF,oFAAoF;AACpF,uFAAuF;AACvF,iCAAiC;AAEjC,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,GAAG;;;;;;;;gBAQL,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDA+BK,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,4BAA4B,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,oBAAoB,IAAI,CAAC,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+VAuDgN,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,oHAAoH,IAAI,CAAC,SAAS,kNAAqO,CAAC;AAErtB,MAAM,CAAC,MAAM,IAAI,GAAU;IACzB,IAAI,EAAE,MAAM;IACZ,WAAW,EAAE,uoBAAuoB;IACppB,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;IACjC,QAAQ,EAAE,cAAc;CACzB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cratylus/canon",
-  "version": "0.13.3",
+  "version": "0.14.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.9.0"
+    "@cratylus/schema": "0.9.1"
   },
   "devDependencies": {
-    "@cratylus/forge": "0.14.3",
-    "@cratylus/runtime": "0.9.4",
+    "@cratylus/forge": "0.14.5",
+    "@cratylus/runtime": "0.10.0",
     "@cratylus/tooling": "0.0.0",
     "@types/node": "^22.0.0",
     "tsx": "^4.19.0",

package/dist/hooks/line-worktree.d.ts

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

package/dist/hooks/line-worktree.js

@@ -1,251 +0,0 @@
-// line-worktree — the creation of the implementer's worktree, cut from the tip of the
-// bound plan's line.
-//
-// THE GAP IT CLOSES. The implementer declares that it runs in a worktree of its own
-// (`Agent.isolation`), and Claude Code honours that by making one. But Claude Code cuts
-// that worktree from origin's default branch, or from the HEAD of the session that
-// dispatched it — and the dispatcher runs in the main checkout on main. So the
-// implementer started in a worktree that was isolated and was nowhere near the plan's
-// line: its first commit ran from main, and moving it onto the line was left to
-// whatever care the agent had. A rule that depends on the agent remembering to follow it
-// is the rule that was broken in the first place. The agent definition has no base ref
-// to give, and a worktree's base is not the agent's to choose: it is the creation's.
-//
-// THE HOOK PERFORMS THE CREATION. `WorktreeCreate` is not a notification. Claude Code
-// hands the hook the new worktree's `name`, takes the absolute path the hook prints, and
-// uses that directory as the agent's working copy; a hook that prints none fails the
-// creation. So the cell is where the worktree's base can be decided, and this is the one
-// place it is decided: for the implementer's worktree, while a plan is bound, the
-// worktree is cut on a new branch from the tip of that plan's line, and the agent's
-// first commit already runs from the line.
-//
-// IT ACTS FOR THE IMPLEMENTER'S WORKTREE AND FOR NO OTHER. The plan places a unit's
-// worktree off its plan's line and says nothing about any other worktree, yet the hook is
-// registered on the host and Claude Code fires `WorktreeCreate` for every worktree it
-// makes there: a `claude --worktree` session, a background session isolated in a worktree
-// (`bridge-<id>`), and every subagent that declares `isolation: worktree`. Cutting an
-// architect's background session from a plan's line, or failing a session's creation
-// because `cratylus` is not installed, is the cell reaching past what the plan placed.
-// The input names no subagent — its `agent_type` is the dispatcher's — so the worker tells
-// the implementer's worktree by the name Claude Code gives a subagent's: `agent-a` and
-// 7 or 16 hex digits. In this corpus only the implementer declares `isolation: worktree`,
-// so that name is the implementer's; a worktree whose name is not that one is not the
-// implementer's, and where the worker cannot tell it passes through.
-//
-// WHICH PLAN, AND WHERE ITS LINE IS, IS THE RUNTIME'S TO SAY. The cell does not know
-// that plans exist, what a line is called or where it lives: it asks the host's
-// `cratylus plan show`, the way `deploy-drift-notice` asks `deploy --check`, and takes
-// from the answer the one fact it needs — the commit the bound plan's line stands at. It
-// spells no plan name, no branch and no path the runtime does not give it, so a rename of
-// the line's branch, or of the plan lifecycle's states, leaves it untouched.
-//
-// EVERYTHING ELSE IS LEFT AS THE HARNESS WOULD DO IT. For every worktree that is not the
-// implementer's, and for the implementer's when there is no line to cut from — no plan
-// bound, `cratylus` missing, a `plan show` answer the worker does not recognise
-// (`with nothing committed yet`) — the worker creates what Claude Code's own creation
-// would: a worktree at `<project>/.<harness>/worktrees/<name>` on a branch
-// `worktree-<name>`, cut from origin's default branch, or from the session's HEAD where
-// the host's `worktree.baseRef` is `head` or where there is no origin, and prints its
-// path. The hook has replaced that creation for every worktree on the host, so it owes
-// the same behaviour for every one it is not cutting from a line, and it never fails one
-// for want of a line. It says on stderr when the implementer's was made without one.
-//
-// `jq` IS NOT WHAT THE LINE NEEDS. It reads the request and the host's `baseRef`, and
-// where it is not installed the worker reads the one flat string each holds with `sed`;
-// finding the line's tip asks the runtime and uses no `jq`, so a host without `jq` still
-// has the implementer's worktree cut from the line.
-//
-// WHAT IT STILL REFUSES is a creation Claude Code's would refuse as well: a request that
-// names no readable `cwd` or an unusable `name`, a `cwd` inside no repository, a path that
-// is taken, a `git worktree add` that fails. There is no creation to pass through to, and
-// answering with the checkout the session is already in is a worktree that isolates
-// nothing and reads as one. That failure is a message on stderr, a non-zero exit, no path
-// on stdout and no worktree on disk.
-//
-// REMOVAL IS NOT BOUND, AND THAT IS THE CHOICE. With a `WorktreeCreate` hook and no
-// `WorktreeRemove` hook Claude Code keeps the worktree when the agent is done and says so.
-// The worktree holds the unit's commits, and a removal hook would have to decide whether
-// they are safe to discard; the unit's work is landed by recording its commit, and the
-// worktree outliving the agent is what keeps that commit reachable until it is. A
-// removal binding that deleted exactly what this cell created would be a second
-// mechanism owning a judgement the operator's `git worktree remove` already makes.
-//
-// THE WORKER SPEAKS NOTHING. Its stdout is the path and nothing else — Claude Code takes
-// the whole of it as the path — so everything it has to say goes to stderr.
-//
-// `workers[].content` is the TEMPLATE the committed worker at `targetPath` regenerates
-// from, byte-locked by `test/hook-rule-boundary.test.ts`. EDIT THE CELL AND REGENERATE
-// (`pnpm canon:project:targets`) — never the committed `.sh` alone.
-export const lineWorktree = {
-    id: 'line-worktree',
-    residue: 'creation-moment ↦ WorktreeCreate ⟨hook PERFORMS the creation ¬ observes it · prints path ∧ nothing else⟩ · acts ↾ implementer-copy ⟨name ≜ agent-a⟨hex⁷ ∨ hex¹⁶⟩ ¬ agent_type ∵ input names the dispatcher⟩ ∧ plan bound ⇒ cut(copy, tip(plan-integration)) ⟨new branch ∉ ⟨main · integration⟩ · tip ↦ runtime-answer ¬ spelled · ∄ plan-name ∧ ∄ branch-name ∧ ∄ path ∉ runtime⟩ · ∀ other copy ∨ ∀ failure ⟨∄ plan bound · runtime missing · answer unknown⟩ ⇒ create as host would ⟨origin-default ∨ HEAD ↾ baseRef · <project>/.<harness>/worktrees/<name> · ¬ fail⟩ · creation impossible ⟨¬ cwd · ¬ name · ¬ repository · path taken · git refuses⟩ ⇒ FAIL LOUD ⟨stderr ∧ non-zero ∧ ∅ path ∧ ∅ copy⟩ ⟨¬ fall back to main checkout ∵ isolates nothing ∧ reads as isolation⟩ · removal ≜ kept ⟨∄ WorktreeRemove ∵ copy holds the unit’s commits⟩ · ∄ speech',
-    substrate: 'harness',
-    events: ['worktree.create'],
-    entry: 'line-worktree.sh',
-    timeout: 60,
-    refs: [],
-    workers: [
-        {
-            filename: 'line-worktree.sh',
-            targetPath: 'packages/canon/targets/guardrail/line-worktree.sh',
-            executable: true,
-            content: `#!/usr/bin/env sh
-# line-worktree — creates the worktree an agent runs in, and prints its path.
-#
-# This hook REPLACES the harness's own worktree creation for every worktree the harness
-# makes on the host: the harness gives it the worktree's name, takes the one path it
-# prints on stdout, and uses that directory as the agent's working copy. A hook that
-# prints none fails the creation.
-#
-# CONTRACT:
-#   - THE IMPLEMENTER'S WORKTREE, WITH A PLAN BOUND: the worktree is cut, on a new
-#                   branch, from the commit the bound plan's line stands at, so the
-#                   agent's first commit runs from it. The implementer's is the one the
-#                   harness names agent-a<7 or 16 hex digits>; the input names no
-#                   subagent, so the name is what there is to tell it by.
-#   - EVERY OTHER WORKTREE, AND THE IMPLEMENTER'S WHEN THERE IS NO LINE TO CUT FROM
-#                   (no plan bound, cratylus missing, a plan show answer this does not
-#                   know): the worktree is made as the harness would have made it,
-#                   at <project>/.<harness>/worktrees/<name> from the origin's default
-#                   branch, or from HEAD where the host's worktree.baseRef is "head", or
-#                   where there is no origin. This never fails one for want of a line.
-#   - NEVER THE MAIN CHECKOUT. A worktree the harness's own creation could not make
-#                   either (no usable cwd or name, no repository, a path that is taken,
-#                   a git refusal) is a failure: a message on stderr, a non-zero exit,
-#                   no path on stdout, nothing on disk.
-#   - STDOUT IS THE PATH AND NOTHING ELSE. Every other word goes to stderr.
-#   - NOT REMOVED. No removal hook is bound, so the harness keeps the worktree when the
-#                   agent is done: it holds the unit's commits until they are landed.
-#
-# WHICH PLAN IS BOUND, AND WHERE ITS LINE STANDS, IS THE RUNTIME'S ANSWER. This names no
-# plan, no branch and no path the runtime does not give it.
-#
-# INPUT  : WorktreeCreate hook JSON on stdin (cwd, name, session_id, ...).
-# OUTPUT : the new worktree's absolute path, on stdout, and nothing else.
-
-set -eu
-
-die() {
-	printf 'line-worktree: %s\\n' "$*" >&2
-	exit 1
-}
-
-note() {
-	printf 'line-worktree: %s\\n' "$*" >&2
-}
-
-# ── WHAT PROJECTION TOLD US ────────────────────────────────────────────────────
-RUNTIME={{fact:runtime-bin}}
-HARNESS={{fact:harness-name}}
-HARNESS_SETTINGS={{fact:harness-hooks-file}}
-
-command -v git >/dev/null 2>&1 || die "git is required to create a worktree, and is not installed"
-
-have_jq=no
-if command -v jq >/dev/null 2>&1; then
-	have_jq=yes
-fi
-
-# jstr KEY — the string KEY holds in the JSON on stdin, empty where it holds none. jq
-# reads it where jq is installed; without jq, the one flat string a request or a settings
-# file states plainly (a value with an escape in it is not read, and reads as empty).
-jstr() {
-	if [ "$have_jq" = yes ]; then
-		jq -r --arg k "$1" '[.. | objects | select(has($k)) | .[$k] | strings] | first // ""'
-	else
-		sed -n "s/.*\\"$1\\"[[:space:]]*:[[:space:]]*\\"\\([^\\"\\\\]*\\)\\".*/\\1/p" | sed -n 1p
-	fi
-}
-
-# ── THE REQUEST ────────────────────────────────────────────────────────────────
-input="$(cat)"
-cwd="$(printf '%s' "$input" | jstr cwd 2>/dev/null)" || die "the worktree request is not JSON"
-name="$(printf '%s' "$input" | jstr name 2>/dev/null)" || die "the worktree request is not JSON"
-
-[ -n "$cwd" ] && [ -d "$cwd" ] || die "the worktree request names no existing cwd (got '$cwd')"
-# THE NAME BECOMES A PATH AND A BRANCH, so it is examined before it is used: plain
-# path segments only, none empty, none leading with a dash, none climbing out.
-case "$name" in
-'' | -* | /* | */ | *//* | *[!A-Za-z0-9._/-]* | *..*)
-	die "refusing the worktree name '$name': it must be plain path segments, none empty or climbing out"
-	;;
-esac
-
-top="$(git -C "$cwd" rev-parse --show-toplevel 2>/dev/null)" || die "'$cwd' is not inside a git repository"
-path="$top/.$HARNESS/worktrees/$name"
-branch="worktree-$name"
-[ ! -e "$path" ] || die "'$path' already exists"
-
-# ── IS IT THE IMPLEMENTER'S? the name the harness gives a subagent's worktree ─────
-h='[0-9a-f]'
-implementer=no
-case "$name" in
-agent-a$h$h$h$h$h$h$h | agent-a$h$h$h$h$h$h$h$h$h$h$h$h$h$h$h$h) implementer=yes ;;
-esac
-
-# line_tip — the commit the bound plan's line stands at, or nothing and a non-zero status
-# where the runtime cannot say: it is not installed, it fails, no plan is bound, or its
-# answer is in a shape this does not know.
-line_tip() {
-	command -v "$RUNTIME" >/dev/null 2>&1 || return 1
-	answer="$(cd "$top" && "$RUNTIME" plan show 2>/dev/null)" || return 1
-	first="$(printf '%s\\n' "$answer" | sed -n 1p)"
-	case "$first" in
-	'plan '*' at '*:*)
-		# "plan <name> (<state>) at <commit>: <counts>". More than one plan reads "plans".
-		commit="$(printf '%s\\n' "$first" | sed -n 's/^plan .* at \\([0-9a-f][0-9a-f]*\\): .*$/\\1/p')"
-		[ -n "$commit" ] || return 1
-		git -C "$top" rev-parse --verify --quiet "$commit^{commit}"
-		;;
-	*) return 1 ;;
-	esac
-}
-
-# harness_start — what the harness cuts a worktree from: origin's default branch, where
-# there is one, or HEAD where the host's worktree.baseRef is "head".
-harness_start() {
-	base="fresh"
-	for f in \\
-		"$top/.$HARNESS/\${HARNESS_SETTINGS%.json}.local.json" \\
-		"$top/.$HARNESS/$HARNESS_SETTINGS" \\
-		"\${HOME:-/nonexistent}/.$HARNESS/$HARNESS_SETTINGS"; do
-		[ -f "$f" ] || continue
-		set_to="$(jstr baseRef <"$f" 2>/dev/null || true)"
-		if [ -n "$set_to" ]; then
-			base="$set_to"
-			break
-		fi
-	done
-	if [ "$base" != "head" ]; then
-		if remote="$(git -C "$top" symbolic-ref --quiet --short refs/remotes/origin/HEAD 2>/dev/null)"; then
-			printf '%s\\n' "$remote"
-			return 0
-		fi
-	fi
-	printf 'HEAD\\n'
-}
-
-# ── WHERE FROM? the line, for the implementer's, if the runtime says there is one ──
-start=""
-if [ "$implementer" = yes ]; then
-	if start="$(line_tip)" && [ -n "$start" ]; then
-		:
-	else
-		start=""
-		note "no plan's line to cut the implementer's worktree from: it is made as the harness would make it"
-	fi
-fi
-if [ -z "$start" ]; then
-	start="$(harness_start)"
-fi
-
-# ── THE WORKTREE ───────────────────────────────────────────────────────────────
-mkdir -p "\${path%/*}" || die "cannot create the directory for '$path'"
-git -C "$top" worktree add -q -b "$branch" "$path" "$start" >&2 || die "git could not create the worktree '$path' on branch '$branch' from '$start'"
-
-printf '%s\\n' "$path"
-`,
-        },
-    ],
-};
-//# sourceMappingURL=line-worktree.js.map

package/dist/hooks/line-worktree.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"line-worktree.js","sourceRoot":"","sources":["../../src/hooks/line-worktree.ts"],"names":[],"mappings":"AAEA,sFAAsF;AACtF,qBAAqB;AACrB,EAAE;AACF,oFAAoF;AACpF,wFAAwF;AACxF,mFAAmF;AACnF,+EAA+E;AAC/E,sFAAsF;AACtF,gFAAgF;AAChF,yFAAyF;AACzF,uFAAuF;AACvF,qFAAqF;AACrF,EAAE;AACF,sFAAsF;AACtF,yFAAyF;AACzF,qFAAqF;AACrF,yFAAyF;AACzF,kFAAkF;AAClF,oFAAoF;AACpF,2CAA2C;AAC3C,EAAE;AACF,oFAAoF;AACpF,0FAA0F;AAC1F,sFAAsF;AACtF,0FAA0F;AAC1F,sFAAsF;AACtF,qFAAqF;AACrF,uFAAuF;AACvF,2FAA2F;AAC3F,uFAAuF;AACvF,0FAA0F;AAC1F,sFAAsF;AACtF,qEAAqE;AACrE,EAAE;AACF,qFAAqF;AACrF,gFAAgF;AAChF,uFAAuF;AACvF,yFAAyF;AACzF,0FAA0F;AAC1F,6EAA6E;AAC7E,EAAE;AACF,yFAAyF;AACzF,uFAAuF;AACvF,gFAAgF;AAChF,sFAAsF;AACtF,2EAA2E;AAC3E,wFAAwF;AACxF,sFAAsF;AACtF,uFAAuF;AACvF,yFAAyF;AACzF,qFAAqF;AACrF,EAAE;AACF,sFAAsF;AACtF,wFAAwF;AACxF,yFAAyF;AACzF,oDAAoD;AACpD,EAAE;AACF,yFAAyF;AACzF,2FAA2F;AAC3F,0FAA0F;AAC1F,oFAAoF;AACpF,0FAA0F;AAC1F,qCAAqC;AACrC,EAAE;AACF,oFAAoF;AACpF,2FAA2F;AAC3F,yFAAyF;AACzF,uFAAuF;AACvF,kFAAkF;AAClF,gFAAgF;AAChF,mFAAmF;AACnF,EAAE;AACF,yFAAyF;AACzF,4EAA4E;AAC5E,EAAE;AACF,uFAAuF;AACvF,uFAAuF;AACvF,oEAAoE;AAEpE,MAAM,CAAC,MAAM,YAAY,GAAa;IACpC,EAAE,EAAE,eAAe;IACnB,OAAO,EACL,m0BAAm0B;IACr0B,SAAS,EAAE,SAAS;IACpB,MAAM,EAAE,CAAC,iBAAiB,CAAC;IAC3B,KAAK,EAAE,kBAAkB;IACzB,OAAO,EAAE,EAAE;IACX,IAAI,EAAE,EAAE;IACR,OAAO,EAAE;QACP;YACE,QAAQ,EAAE,kBAAkB;YAC5B,UAAU,EAAE,mDAAmD;YAC/D,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2Jd;SACI;KACF;CACF,CAAC"}