@cratylus/canon 0.14.0 → 0.16.0

package/dist/skills/deliver/skill.js

@@ -1,126 +0,0 @@
-import { primePrinciple } from '../../genus/prime-principle.js';
-import { design } from '../design/skill.js';
-import { note } from '../note/skill.js';
-import { plan } from '../plan/skill.js';
-// WHY THE WHOLE CHECK RUNS HERE, ONCE. A unit proven alone has proven nothing about the
-// combination: a branch's green says nothing about the line after other landings, and an
-// implementer or assayer re-running the project's check on nearly the same tree proves
-// nothing new and spends the architect's wait for it. So the check is the integrator's, run
-// once per combination on the combined tree. It is reached only after the verdict, which is
-// what keeps the line to approved work: the assayer is the one judge of a unit and
-// acceptance rests on its verdict, never on the implementer's return, never on a merge and
-// never on a green check. Judging is a two-description act held by a party that holds the
-// design and not the spec; a party that carries the verdict onward reaches none of its own.
-//
-// A RED IS A REPORT, NEVER A PATCH. Repairing on the line would hand the architect an
-// approved-looking whole nobody judged, and would make the integrator the builder its own
-// check is meant to be independent of. The report is an address (the unit and the failing
-// check) so the architect can send it to the implementer that built the unit without
-// reading behind it; the return of a unit, of a verdict and of a report is a name and a
-// commit, never an account.
-//
-// THE LINE IS NOT MAIN, AND IT HAS ONE BIRTH. Bind, the planner's act, brings the plan's
-// integration line into being, from the commit the plan's units stand on (never from bare
-// main: a line cut from main lacks the history the units stand on, and that history then
-// conflicts at combination). The integrator finds that line and cuts nothing: a second cut
-// would compete with the first, and fail on a line that exists. Each unit is built in its
-// own isolated worktree off the line, and while the plan is bound nothing is committed on
-// main, so main carries no unjudged work; how an implementer makes and uses that worktree
-// is its own competence, and nothing here teaches it. The finished whole reaches main by
-// the operator's sign-off, which the integrator asks for and never takes: a push is a
-// release decision and a release decision is not the integrator's to make.
-//
-// RECORDS ARE WRITTEN ON THE LINE AND COMMITTED THERE AT EVERY ACT. While a plan is bound
-// the runtime writes every plan record and every note that blocks the plan or a unit of it
-// into the line's worktree, from whichever checkout the party runs in, so no unit's
-// history forks across checkouts. The runtime commits nothing: the integrator commits what
-// that worktree holds by pathspec at every act, green or red and at the close, the planner's
-// state records included, and the planner, implementer and assayer commit none of their
-// own. Records commit on a red as well as a green, because the notes and plan records
-// written while a unit is red are the trace of why it is red; the unit's work stays off the
-// line and the records do not. The plan's close is the last act: the last unit's completed
-// record and the close record are written after the last green, so only a commit at the
-// close puts them on the line, and only after it, with nothing left for lacks to print,
-// does the integrator ask the operator to release. A finding beside the path, a note that
-// blocks nothing, is written where its party runs, so gather adds those from any other
-// worktree or local branch, and lacks stays the release check that finds none. A
-// release of a line missing a record is a release that loses work no other branch holds.
-//
-// WHO OWNS WHAT, so the loop reads in order: routing by name is the architect's; binding
-// the plan, which cuts the line, and recording a unit active, completed and the plan closed
-// is the planner's; building in its own worktree off the line and verifying against the spec,
-// and writing the landing of each commit that holds the unit, is the implementer's; the
-// verdict, written to the unit's history before it is returned, is the assayer's;
-// finding the line, combining, the whole check, the unit's whole or broke written before
-// the report, the records commit at every act and the ask to release are the integrator's.
-// A finding is captured as a note by the party that met it and is never chased; when a
-// finding enters the design is the design skill's law.
-//
-// THE LEDGER IS WHERE A UNIT STANDS. Each party writes its own event to the unit's history
-// as it happens, so which commit landed a unit, what the assayer found on it and whether
-// it made the whole or broke it are read from `plan show <unit>`; no return, message or
-// memory has to carry them, and the returns stay names.
-const FORMAL_BLOCK = `shard  @ design
-anchor @ design
-yield  ≜ what execution established ∧ ¬ derivable from the design
-P      @ plan
-unit   @ plan
-advance, bind, close, closed, bound, land, assay, whole, broke @ plan
-accept @ plan ⟨the MECHANICAL half⟩
-outputs @ plan
-artifact : P → ℘(path) ⟨what landed⟩
-r      ≜ a return ⟨an ADDRESS : a name ∧ a commit · ¬ an account⟩
-conform @ signify
-capture @ note
-architect  : agent ⟨role = architect · holds the design · sends each name to the agent that acts on it⟩
-planner    @ plan
-implementer : P ⇀ agent ⟨role = implementer · builds and commits its own unit in its own worktree off line(P), never on main⟩
-assayer : unit ⇀ agent ⟨role = assayer · the ONE judge of a unit⟩
-integrator : P ⇀ agent ⟨role = integrator · one per P · finds line(P), cuts none · combines · runs gate · commits the records line(P) holds and gathers the rest at every act · asks release⟩
-operator ≜ the human who signs off a release
-achieved : unit → 𝔹 ⟨the assayer's verdict⟩
-line(P) ≜ the integration line of P ⟨¬ main · bind(P) brings it into being once, from the commit the plan's units stand on, and the integrator finds it · while bound(P) every plan record and blocking note about P is written there from any checkout · it holds every approved unit AND every record written while P ran, so releasing it loses nothing⟩
-lacks(P) ≜ every record file that any worktree of the repository, tracked or not, or any local branch holds and line(P) lacks ⟨checked from line(P)'s own worktree · it is the release check and must find none · a record file is \`records/<domain>/<ULID>.json\`, immutable and named by its ULID, so the union of two sets of them never conflicts⟩
-gather(P) ≜ every record file that another worktree or local branch holds and line(P) lacks, brought onto line(P), and then every record the worktree of line(P) holds committed ⟨done from that worktree · the records committed are every record about P, a finding beside the path among them · by pathspec, records only · the commit message is \`chore(records): <plan> <act>\`, and <act> is the unit and green or red, or close · nothing is committed when there is nothing to add⟩
-gate   ≜ the project's whole check ⟨every suite · typecheck · build : what a green line demands⟩
-verify : P × return → 𝔹 ⟨the IMPLEMENTER's · built-it-right, against spec⟩
-integrate(unit) ≜ merge artifact(unit) onto line(P) ⟨pre achieved(unit)⟩
-defect ≜ ⟨symptom, locus, provenance⟩
-impedes : defect × P → 𝔹
-cost   : act → effort
-file(d) ≜ capture(d) ⟨filed by the party that met d · its topic names the unit as \`u of plan p\` · beside the path ∴ it blocks nothing⟩
-electable ≜ { P | ¬terminal(P) ∧ ¬occupied(P) }
-terminal : P → 𝔹
-release(P) ≜ line(P) reaches main ⟨the operator's sign-off · a pull request where the repository has a forge remote and \`gh\`, otherwise the exact git command⟩
-
-∀ unit, r : ¬conform(r) ⇒ ¬accept(unit)(r)
-accepted(unit) ⇔ achieved(unit) ⟨acceptance rests on the assayer's verdict · never on r, never on a merge, never on a green gate⟩
-integrator ⊨ ¬ judges ⟨it carries a verdict onward ∧ reaches none · the verdict arrived before it was reached⟩
-integrator ⊨ takes(unit) ⇔ accepted(unit) ⟨what the architect sends it is a unit's name ∧ commit after an achieved verdict⟩
-bound(P) ⇒ bind cut line(P) ∧ the integrator finds it and cuts none ⟨the line has one birth · a line the runtime cannot find is a refusal that says what is missing⟩
-bound(P) ⇒ ∀ unit ∈ P : built in its own worktree off line(P) ∧ ∄ commit @ main ⟨work ↦ that worktree · records ↦ line(P) · main receives line(P) only at release(P)⟩
-bound(P) ⇒ every record about P is written on line(P) from any checkout ∧ the integrator commits them at every act ⟨the planner's state records included · the runtime commits nothing · planner ∧ implementer ∧ assayer commit none of them⟩
-integrate(unit) ⇒ gate ONCE on the combined tree ⟨a branch's green says nothing about the line after other landings · an implementer ∨ assayer re-running gate proves nothing new on nearly the same tree⟩
-integrate(unit) ∧ gate green ⇒ whole(unit) ∧ gather(P) ∧ report \`whole <unit> of <plan>\` ⟨whole(unit) ≜ line(P) with unit integrated ∧ gate green, recorded by the integrator with the line's commit before the report · the architect sends the report to the planner, which records advance(unit) completed ∧ hands out the newly ready names⟩
-integrate(unit) ∧ ¬ gate green ∨ a merge conflict ⇒ the unit's work OFF line(P) ⟨the merge aborted or the line returned to the commit before the combination⟩ ∧ broke(unit) ∧ gather(P) ∧ report \`red <unit> of <plan>: <failing check>\` ⟨broke(unit) records the failing check before the report · the records written while the unit was red are still committed · the architect sends the report to the implementer that built the unit · the integrator repairs nothing⟩
-∀ event ∈ { land, assay, whole, broke } of unit : written to its history as it happens, by the party it happens to ⟨land ∈ the implementer, for each commit that holds unit · assay ∈ the assayer, before its verdict is returned · whole ∨ broke ∈ the integrator, before its report · none of them a return⟩
-where unit stands ∧ on what it was accepted ⇒ read from show(unit) ⟨its ledger : the commit that landed it, what the assayer found on it, whether it made the whole or broke it · ¬ a message ∧ ¬ an agent's memory⟩
-impedes(d, unit) ⇔ d standing ⇒ ∄ r : accept(unit)(r)
-finding ∨ d ⊨ capture ⟨a note by the party that met it : implementer ∨ assayer ∨ integrator ∨ architect · the operator's steer by the architect · it reaches the architect as a note, ¬ a return⟩ ; when a finding enters the design is the law of yield ≠ ∅ @ design
-impedes(d, unit) ⇒ an implementer repairs it ⟨a regression in the path goes back to the unit's implementer by way of the architect · the integrator makes no fix⟩
-¬impedes(d, unit) ⇒ file(d) ∧ ¬fix(d) ⟨a defect BESIDE the path is filed, ¬ chased⟩
-cost(file) < cost(fix) ⟨else the gradient points at chasing · the load-bearing law⟩
-∃ P : ¬terminal(P) ⇒ ∃ P : bound(P) ⟨WIP = 1, held by bind : the planner binds it · finish before starting⟩
-elect ≜ in-flight ≻ gating ≻ operator-intent ⟨lexicographic⟩
-terminal(P) ⇒ close(P) ⟨obligation ¬ permission : the planner closes it · an unclosed terminal plan is WIP that is not work · a closed plan stays readable⟩
-closed(P) ⇒ the architect routes the close to the integrator ⟨the records written after the last combination, the planner's completed and close records among them, are committed only now⟩
-the close routed ⇒ gather(P) ∧ lacks(P) finds none ⟨no worktree and no local branch holds a record line(P) lacks⟩ ∧ ask the operator release(P) ⟨the ask comes AFTER the gather · the integrator asks · it never moves main⟩
-deliver ≜ bind ⟨planner, brings line(P) into being⟩ → send ⟨architect, by name⟩ → verify ⟨implementer in its own worktree off line(P), writes land⟩ → achieved ⟨assayer, writes assay⟩ → integrate ∧ gate ⟨integrator, once on the combined tree⟩ → whole ∨ broke ⟨integrator writes it⟩ → gather ⟨integrator, at every act : green or red⟩ → advance ⟨planner records completed⟩ → close ⟨planner⟩ → gather ⟨integrator, at the close⟩ → release ⟨operator, asked by the integrator once lacks(P) finds none⟩`;
-export const deliver = {
-    name: 'deliver',
-    description: `use this skill to make a plan's approved work whole and see it released — take each unit whose assay verdict is achieved, integrate it onto the plan's integration line, run the project's whole check once on the combined tree, and at every act commit the records the line holds by pathspec, then record the unit whole with the line's commit and report it on green, or on red or a merge conflict leave the unit's work off the line, record the unit broke with the failing check, and report the unit and the failing check. The line is the integration line the planner's bind brings into being, never from bare main; the integrator finds it and cuts none, and no agent commits on main while the plan is bound. Every record about the plan is written on the line from any checkout, and it holds the plan's whole work: every approved unit together with every plan and note record written while the plan ran, strays gathered from other worktrees and local branches, so releasing it loses nothing. Reach for it whenever an achieved unit arrives by name and commit, and when the plan closes: the records written after the last combination (the planner's completed and close records) are committed at the close, and only then does it ask the operator to release. It reads the loop in order: the architect sends each name and routes the close, the planner binds the plan, bringing its line into being, and records units active and completed and the plan closed, the implementer builds in its own worktree off the line and records the landing of its commit, and the assayer's verdict, recorded by the assayer, the one judgement of a unit, is the acceptance rather than the implementer's return; each party writes its own event to the unit's history as it happens, so where a unit stands is read from \`plan show\` and never from a message; a merge is durability, and neither a merge nor a green check accepts. It never moves main itself. It also carries the conduct of the work: one plan bound at a time, finish before starting, a defect that impedes the path goes back to its implementer by way of the architect and one beside it is only filed, and a finding is captured as a note by the party that met it, entering the design when the design skill's law says.`,
-    formalBlock: FORMAL_BLOCK,
-    composition: () => [design, plan, note],
-    preamble: primePrinciple,
-};
-//# sourceMappingURL=skill.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/deliver/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;AACxC,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAExC,wFAAwF;AACxF,yFAAyF;AACzF,uFAAuF;AACvF,4FAA4F;AAC5F,4FAA4F;AAC5F,mFAAmF;AACnF,2FAA2F;AAC3F,0FAA0F;AAC1F,4FAA4F;AAC5F,EAAE;AACF,sFAAsF;AACtF,0FAA0F;AAC1F,0FAA0F;AAC1F,qFAAqF;AACrF,wFAAwF;AACxF,4BAA4B;AAC5B,EAAE;AACF,yFAAyF;AACzF,0FAA0F;AAC1F,yFAAyF;AACzF,2FAA2F;AAC3F,0FAA0F;AAC1F,0FAA0F;AAC1F,0FAA0F;AAC1F,yFAAyF;AACzF,sFAAsF;AACtF,2EAA2E;AAC3E,EAAE;AACF,0FAA0F;AAC1F,2FAA2F;AAC3F,oFAAoF;AACpF,2FAA2F;AAC3F,6FAA6F;AAC7F,wFAAwF;AACxF,sFAAsF;AACtF,4FAA4F;AAC5F,2FAA2F;AAC3F,wFAAwF;AACxF,wFAAwF;AACxF,0FAA0F;AAC1F,uFAAuF;AACvF,iFAAiF;AACjF,yFAAyF;AACzF,EAAE;AACF,yFAAyF;AACzF,4FAA4F;AAC5F,8FAA8F;AAC9F,wFAAwF;AACxF,kFAAkF;AAClF,yFAAyF;AACzF,2FAA2F;AAC3F,uFAAuF;AACvF,uDAAuD;AACvD,EAAE;AACF,2FAA2F;AAC3F,yFAAyF;AACzF,wFAAwF;AACxF,wDAAwD;AAExD,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+eAuD6e,CAAC;AAEngB,MAAM,CAAC,MAAM,OAAO,GAAU;IAC5B,IAAI,EAAE,SAAS;IACf,WAAW,EAAE,ysEAAysE;IACttE,WAAW,EAAE,YAAY;IACzB,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC;IACvC,QAAQ,EAAE,cAAc;CACzB,CAAC"}

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

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

package/dist/skills/design/skill.js

@@ -1,95 +0,0 @@
-import { primePrinciple } from '../../genus/prime-principle.js';
-// THE DURATIVE HALF. `plan` and `deliver` are per-effort; this cell is the one that
-// persists across every effort, and that asymmetry is the whole point of the trio.
-//
-// It exists because the corpus could DO long-horizon work and could only THINK in
-// single sittings: every conceptual cell (conceptualize · signify · materialize ·
-// exemplify) is episodic — invoked on a source, emits a result, finishes — while the
-// planning cell alone bound, elected and persisted across sessions. So a project's
-// concepts were re-derived per session, per agent, forever. The superseded `praxis`
-// measured exactly that against itself: sixteen retired plans, twenty-five laws
-// established, zero surviving into any corpus.
-//
-// The second reason is verification. Acceptance keyed to a work-unit's own criteria
-// is a CLOSED loop — the unit is graded against its own account of itself, so an
-// implementer that satisfies the letter passes while the system stays incoherent. A
-// second, independent statement of what should exist is what makes validation an
-// operation rather than a re-reading of the claim. That statement is this lattice.
-const FORMAL_BLOCK = `anchor ≜ a concept's name ⟨the project's own · answers to no cold decode⟩
-gloss  ≜ what a concept IS ⟨one line · reconstruction-grade⟩
-C      ≜ the concept lattice ⟨the project's durative model⟩
-c      ≜ a concept ⟨c ∈ C⟩
-concept ≜ ⟨ anchor(c) , gloss(c) , factors(c) ⟩
-factors : C → ℘(C) ⟨what c decomposes into⟩
-primitive(c) ⇔ factors(c) = ∅ ⟨held by VALUE ⟨anchor · gloss⟩⟩
-composite(c) ⇔ factors(c) ≠ ∅ ⟨held by REFERENCE ⟨anchor · factor-anchors⟩ @ materialize⟩
-closure : C → ℘(C) ⟨closure(c) ≜ { c } ∪ ⋃ { closure(f) | f ∈ factors(c) }⟩
-denotes : anchor ⇀ C
-shard(c) ≜ ⟨ c , closure(c) ⟩ handed down ⟨what a planner is handed · one concept with everything it stands on⟩
-cut    ≜ the architect's choice of shards to hand the planner
-history(c) ≜ every version ∧ retraction of c, in order ⟨resident · ¬ deleted⟩
-settled(c) ⇔ c has exactly one current version
-live(c) ⇔ settled(c) ∧ that version ¬ a retraction
-withdrawn(c) ⇔ settled(c) ∧ c retracted
-diverged(c) ⇔ ¬settled(c) ⟨concurrent sessions wrote c differently ∧ merged · state, ¬ error⟩
-incoherent(C) ⇔ a law below broken across concepts by a merge ∧ kept on each branch
-yield  ≜ what execution established ∧ ¬ derivable from C @ deliver
-self   ≜ the principal ⟨the architect · the design-holder · ¬ delegable⟩
-author : C ⇀ self
-show(C) ≜ \`scripts/design.mjs show [<concept>]\` ↦ C root to primitive ∨ one c in full
-define(c) ≜ \`scripts/design.mjs define <anchor> --gloss <g> [--factors <anchor>]…\`
-supersede(c) ≜ \`scripts/design.mjs amend <concept> [--anchor <a>] [--gloss <g>] [--factors <anchor>]…\` ⟨a new version of the SAME c · amending a withdrawn c reinstates it⟩
-retract(c) ≜ \`scripts/design.mjs retract <concept>\` ⟨c withdrawn · no successor version⟩
-reconcile(c) ≜ \`scripts/design.mjs reconcile <concept> [--anchor <a>] [--gloss <g>] [--factors <anchor>]…\` ⟨one version superseding every current version of c⟩
-trace(c) ≜ \`scripts/design.mjs trace <concept>\` ↦ ⟨history(c), closure(c), blast(c)⟩ ⟨how c came to be · what it stands on · what stands on it⟩
-
-∀ define ∨ supersede ∨ retract ∨ reconcile : \`--author <who> --reason <why> --cause <what caused it>\` ⟨a set-valued flag repeats, one member each⟩
-∀ c : ∃! anchor(c) ∧ ∀ a ∈ dom(denotes) : ∃! denotes(a) ⟨one live concept per anchor⟩
-withdrawn(c) ⇒ anchor(c) held until supersede(c) reinstates it
-∀ c : gloss(c) ≠ ∅
-∀ c : closure(c) finite ⟨factors acyclic ∴ a lattice, ¬ a graph⟩ ∧ ∀ f ∈ factors(c) : live(f)
-∃ d : live(d) ∧ c ∈ factors(d) ⇒ ¬ retract(c) ⟨what live concepts factor on cannot be withdrawn⟩
-amend(C) ≜ supersede ⟨∄ overwrite ; a live c is NEVER edited in place⟩
-    ⟨the protection is ¬ a rule about honesty : an editable lattice lets the agent
-     adjust the concept its artifact failed, ∴ acceptance-against-C goes CIRCULAR
-     with one extra step ∧ the loop manufactures its own evidence⟩
-supersede(c) ⇒ the prior version stays in history(c) ⟨residence, ¬ deletion : trace(c) reads
-    the history without a VCS query ∴ the lattice is self-describing⟩
-c becomes another concept ⇒ retract(c) ∧ define(c') ⟨¬ supersede : a new version is the SAME concept⟩
-∀ define ∨ supersede ∨ retract ∨ reconcile : reason ≠ ∅ ⟨attribution ∧ order are what make
-    retroactive justification DETECTABLE : the amendment postdates the artifact it excuses⟩
-reconcile ⊨ amend(C) ∧ ¬ an acceptance ⟨THE separation · a reconciliation never shares a write
-    with an acceptance it bears on ; fused, the second witness collapses into the first⟩
-diverged(c) ⇒ reconcile(c) ⟨an ordinary write on c refuses⟩
-incoherent(C) ⇒ repaired by ordinary writes, one at a time
-reconcile ⊨ self ⟨reconciliation of the design is the architect's alone⟩
-planner ∨ implementer ∨ assayer ⊨ diverged ∨ incoherent ⇒ report ∧ ¬ resolve
-blast(c) ≜ { d ∈ C | c ∈ closure(d) } ⟨DERIVED, ¬ guessed · what the normal form buys⟩
-churn(primitive) high ⇒ conceptualization wrong ⟨primitives near-stable · composites move⟩
-shard(c) states what must hold ∧ why ∧ ¬ how ⟨how a harness or a codebase achieves it is the plan's⟩
-a quirk met while realizing shard(c) ⇒ the planner's ∧ the implementer's to solve ∧ ¬ a reason to amend(c)
-cut ⊨ self ⟨the CHOICE of shards is the design-holder's ; a planner receiving a shard may
-    ¬ redraw it · a boundary it cannot plan is SURFACED⟩
-yield ≠ ∅ ⇒ a hypothesis self rectifies against its expertise ∧ the field's practice, ¬ a fact to copy into C ⟨every input,
-    the operator's included, and every delegate's finding, which reaches self as a note⟩ ; a survivor
-    bearing on the bound plan ⇒ capture a decision note on the topic of its concept, blocking nothing, ∧
-    amend(C) when that plan completes, for a following plan sequenced after the work it depends on ; any other survivor ⇒ amend(C) at once
-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 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)`;
-export const design = {
-    name: 'design',
-    description: `use this skill to build and hold a project's DURATIVE conceptual model — the one artifact that outlives every plan: each concept's anchor, gloss and factorization, amended only by append-only supersession, and cut into shards a planner can take, each stating what and why, never how. Its verbs show the design or one concept, define, amend, retract and reconcile a concept, and trace how one came to be, what it stands on and what stands on it. Reach for it FIRST on any long-horizon effort, before any work is decomposed, and again whenever execution or the operator establishes something the model does not yet hold: every such input is a hypothesis the holder rectifies first, and a survivor bearing on a shard a bound plan realizes is held as a note until that plan completes while any other is amended at once, and a plan found built on a wrong shard stops until the shard is corrected once and the plan re-planned. It is what acceptance is judged against, so without it verification has no referent and degrades into re-reading the implementer's own claim.`,
-    formalBlock: FORMAL_BLOCK,
-    runtime: { capability: 'design' },
-    composition: () => [],
-    preamble: primePrinciple,
-};
-//# sourceMappingURL=skill.js.map

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

@@ -1 +0,0 @@
-{"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/event-tap/skill.d.ts

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

package/dist/skills/event-tap/skill.js

@@ -1,44 +0,0 @@
-// COMPOSES NOTHING, and it never borrowed anything either. The retired
-// `composition: () => [introspect]` edge produced `Composed from /introspect.` on the
-// projected artifact while this block defined every sign it uses locally — `target`,
-// `target₀`, `foreign`, `attached`, `lifecycle`, `record` — and named none of
-// introspect's. A declared dependency with no borrow is a claim the artifact makes
-// and the cell cannot honour. The `runtime` capability below is the real coupling and
-// it stays: its four verbs take no corpus vocabulary, and `target` is the ADAPTER's to
-// name.
-const EVENT_TAP_BLOCK = `event-tap    ≜ install → observe → read → uninstall
-capability   ≜ eventTap ⟨runtime-bound ; every verb reached as \`scripts/eventTap.mjs <verb>\`⟩
-verb         ∈ { install · uninstall · read · status }
-lifecycle    ≜ the harness-neutral moment taxonomy ⟨session.start · session.end · prompt.submit · turn.end · tool.use.pre · tool.use.post · subagent.start · context.compact.pre · … ⟩
-E            ⊆ lifecycle
-sink         ≜ append-only capture path ⟨one record per line⟩
-record       ≜ ⟨event ∈ lifecycle, payload⟩
-order(read)  ≜ position ⟨∄ fabricated timestamp⟩
-target       ≜ the harness's own hook-config artifact ⟨\`--settings <path>\` ; absent ↦ the harness default ; the ADAPTER names it, ¬ this cell⟩
-target₀      ≜ target before install
-foreign      ≜ every target key ∧ every hook entry this tap did not write
-attached     : target → 𝔹
-
-install(E, sink) ≜ \`scripts/eventTap.mjs install --events <e₁,e₂,…> --sink <path>\` ∴ attached(target)
-uninstall        ≜ \`scripts/eventTap.mjs uninstall\` ∴ ¬ attached(target)
-read             ≜ \`scripts/eventTap.mjs read\` ↦ { record }
-status           ≜ \`scripts/eventTap.mjs status\` ↦ ⟨attached(target), E⟩
-
-passive ⊨ ¬ block ∧ ¬ deny ∧ ¬ mutate(host-control-flow) ⟨observe only ; ∀ verb⟩
-uninstall ∘ install ⊨ target ≡ target₀ ∧ foreign preserved ⟨zero residue⟩
-e ∈ E ∧ e ∉ lifecycle ⇒ ⊥ ⟨loud⟩
-verb ∉ { install · uninstall · read · status } ⇒ ⊥ ⟨loud⟩
-E = ∅ ⇒ ¬ attached(target)
-¬ attached(target) ⇒ read ↦ ∅
-status ≜ derived from target ⟨¬ in-memory ∴ a fresh process reads the same truth⟩
-observe ≜ the host writes each occurrence of E to sink ⟨∄ agent turn between fire ∧ capture⟩
-self-observation ≜ install ↾ own-lifecycle ∴ read ⊨ evidence(own-behavior) ⟨¬ recollection⟩
-install ⊨ uninstall owed ⟨an uninstalled tap outlives the question it was installed to answer⟩`;
-export const eventTap = {
-    name: 'event-tap',
-    description: `use this skill to attach a passive observer to an agent's own lifecycle — install a tap on a chosen set of harness-neutral events (session.start, turn.end, tool.use.pre, …), let the host append each occurrence to a capture sink, read the captured records back as evidence of what actually happened, and uninstall the tap with zero residue; the four verbs are install, uninstall, read, status, and the tap never blocks, denies, or alters what it observes.`,
-    formalBlock: EVENT_TAP_BLOCK,
-    runtime: { capability: 'eventTap' },
-    composition: () => [],
-};
-//# sourceMappingURL=skill.js.map

package/dist/skills/event-tap/skill.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/event-tap/skill.ts"],"names":[],"mappings":"AAEA,uEAAuE;AACvE,sFAAsF;AACtF,qFAAqF;AACrF,8EAA8E;AAC9E,mFAAmF;AACnF,sFAAsF;AACtF,uFAAuF;AACvF,QAAQ;AAER,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;+FA2B0F,CAAC;AAEnH,MAAM,CAAC,MAAM,QAAQ,GAAU;IAC7B,IAAI,EAAE,WAAW;IACjB,WAAW,EAAE,wcAAwc;IACrd,WAAW,EAAE,eAAe;IAC5B,OAAO,EAAE,EAAE,UAAU,EAAE,UAAU,EAAE;IACnC,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;CACtB,CAAC"}

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

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

package/dist/skills/note/skill.js

@@ -1,57 +0,0 @@
-// THE NOTEBOOK'S OWN RULES, and no one else's. This cell routes the reader's notebook
-// intents to the `note` capability and is the one home of the three kinds: the
-// runtime carries a kind as a label it never interprets, so nothing else spells them.
-//
-// It rectifies an earlier ledger skill kept outside this corpus. That one addressed a
-// note by a sequential number, grew a note in place by appending "derived" material
-// beside a frozen definition, treated a withdrawal as one more kind, and taught its
-// reader the mechanics of how the ledger was stored. Here a note is addressed by its
-// title, every change is a whole new version, withdrawal is a verb, and the reader meets
-// only notes. No kind is privileged to block: any live note that names a plan or unit
-// owes a ruling, whatever its kind.
-//
-// COMPOSES NOTHING. The `runtime` capability below is the real coupling; its verbs take
-// the notebook's words and nothing borrowed.
-const NOTE_BLOCK = `note         ≜ show → capture → revise → resolve → retract → reconcile
-route        ≜ \`scripts/note.mjs <verb>\` ⟨runtime-bound : every verb reaches the note capability⟩
-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
-kind(n)      ∈ { idea · question · decision } ⟨a label the runtime never interprets⟩
-topic(n)     ≜ what the note is about ⟨the notebook groups by kind, then topic⟩
-body(n)      ≜ the note's whole statement
-blocks(n)    ≜ the plans ∧ units n names ⟨a plan by its name · a unit as \`u of plan p\`, bare u only where the unit's name is its own⟩
-live(n)      ≜ n captured ∧ ¬ 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⟩
-holders(t)   ≜ { n | live(n) ∧ title(n) = t } ∪ { n | diverged(n) ∧ ∃ v ∈ versions(n) : title(v) = t }
-incoherent(t) ⇔ |holders(t)| > 1 ⟨a merge left title t held by more than one note ; show prints each holder with its identity beside t⟩
-by           ≜ \`--author <who> --reason <why> --cause <what caused it>\` ⟨every write carries it⟩
-
-show(n?)     ≜ \`scripts/note.mjs show [<title>]\` ↦ owed rulings, diverged notes ∧ incoherent titles first, then the notebook by kind, then topic ∨ n in full ⟨every version of a diverged n · every holder of an incoherent title⟩
-capture(n)   ≜ \`scripts/note.mjs capture <title> --kind <k> --topic <t> --body <b> [--blocks <plan or unit>]… <by>\`
-revise(n)    ≜ \`scripts/note.mjs revise <title> [--title <new title>] [--kind <k>] [--topic <t>] [--body <b>] [--blocks <plan or unit>]… <by>\` ⟨a field left out carries over ; \`--blocks ''\` ↦ blocks(n) = ∅⟩
-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 ∧ 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 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 · 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), 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: () => [],
-};
-//# sourceMappingURL=skill.js.map

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

@@ -1 +0,0 @@
-{"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.d.ts

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

package/dist/skills/plan/skill.js

@@ -1,143 +0,0 @@
-import { primePrinciple } from '../../genus/prime-principle.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
-// switch settles into whichever posture its last tool call left it in, which in a
-// tool-driven session is always the making. That is the drift, and it is structural
-// rather than a lapse of attention.
-//
-// What remains here is the middle term only: decomposition, dependency, waves, and
-// 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
-// survives 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 (a
-// declared glob against fifteen written paths among them) 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 = `shard @ design
-c @ design
-anchor @ design
-closure @ design
-withdrawn @ design
-P ≜ a plan : the units realizing a set of shards
-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) ∧ 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)
-footprint : P → ℘(path) ⟨what landing unit actually changed⟩
-occurs : anchor → ℘(path) ⟨every site SPELLING it · the site DEFINING it is ONE⟩
-accept : P → (return → 𝔹) ⟨MECHANICAL only · the semantic half is @ deliver⟩
-pre : P → return
-spec(unit) ≜ ⟨ realizes(unit), intent(unit), static(unit), deps(unit), outputs(unit), accept(unit) ⟩
-census : intent → ⟨scope, static, deps, occurs⟩ ⟨delegable-to agent⟩
-capacity ≜ the effort one implementer finishes in one dispatch ⟨DECLARED by the implementer's harness · ¬ a constant here⟩
-effort(unit) ≜ what building ∧ proving unit costs ⟨reading included⟩
-slices : P → ℘(℘(P))
-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 }
-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) = ∅⟩
-planner ≜ the planner ⟨bounded to its shards⟩
-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 ⟨the planner's ∧ the implementer's read · ¬ the architect's⟩
-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), brings P's integration line into being, once⟩
-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⟩
-land(unit) ≜ \`scripts/plan.mjs land <unit> --plan <p> --commit <c>\`
-assay(unit) ≜ \`scripts/plan.mjs assay <unit> --plan <p> --commit <c> --verdict <achieved|not-achieved> [--missing <part>]…\`
-whole(unit) ≜ \`scripts/plan.mjs whole <unit> --plan <p> --commit <c>\`
-broke(unit) ≜ \`scripts/plan.mjs broke <unit> --plan <p> --check <check>\`
-
-∀ verb ≠ show : \`--author <who> --reason <why> --cause <what caused it>\` ⟨a set-valued flag repeats, one member each⟩
-∀ unit : realizes(unit) = the anchor of ONE shard ⟨TOTALITY is the gate · a unit citing no concept is work whose purpose cannot be stated ∴ REFUSED at authoring, ¬ warned⟩
-shard ¬ how ∴ how it is realized on each harness is the plan's
-∀ 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⟩
-∃ 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⟩
-drifted(unit) ⇒ response ↾ what moved ⟨nothing ⇒ repin · gloss ⇒ repin ∨ revise(unit) ∧ repin, by what the new gloss adds ∨ drops · anchor ∨ factors ⇒ revise(unit) ∧ repin · re-cut ⇔ shard itself moved⟩
-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 ⟨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 NECESSARY ¬ sufficient : a deletion dangles a reference⟩
-⊨ disjoint-outputs ⇒ dispatch(wave(n)) needs-no-isolation
-∀ 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 ∴ 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 ∧ 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.`,
-    formalBlock: FORMAL_BLOCK,
-    runtime: { capability: 'plan', configuration: LIFECYCLE },
-    composition: () => [design, note],
-    preamble: primePrinciple,
-};
-//# sourceMappingURL=skill.js.map

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

@@ -1 +0,0 @@
-{"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"}