@cratylus/canon 0.1.0 → 0.1.1

package/dist/skills/dream/skill.js

@@ -1,65 +0,0 @@
-import { exemplify } from '../exemplify/skill.js';
-import { materialize } from '../materialize/skill.js';
-export const dream = {
-    name: 'dream',
-    description: `use this skill to consolidate an agent's memory — fold the raw EPISODIC stream (the tool computes each record's capture node from its cwd — provenance, not what the record is about), then route by type: agent-intrinsic identity/facts to SEMANTIC, generalized cross-project wisdom to PROCEDURAL (only what no projection already carries), a fleet/system/mechanism truth promoted into the projected+gated canon (or emitted as a canon-candidate task) rather than parked in private memory, forward next-steps to EPISODIC, the rest dropped; consumed raw is drained; the Target is never written.`,
-    formalBlock: `memory              ≜ agent dimension-home ⟨SEMANTIC · PROCEDURAL · EPISODIC⟩ ∪ the memory-tool runtime ⟨a RUNTIME CAPABILITY ; invoked \`memory <verb> <args>\` ; the Runtime-capability line under this block resolves the shim ∴ ¬ path-in-cell⟩
-EPISODIC            ≜ raw time-ordered event stream ∪ forward next-steps
-SEMANTIC            ≜ identity facts ∪ durable agent-intrinsic knowledge ⟨hot index⟩
-PROCEDURAL          ≜ generalized cross-project wisdom no projection already carries
-Target              ≜ the deploy-projected declaration carrying the archetype ; commons-authored ; ∉ dream outputs
-lock                ≜ dream.lock ⟨O_EXCL ; stale ⇔ age > 2h⟩ guarding the {SEMANTIC · PROCEDURAL} partition ⟨shared by all same-host sessions of one agent ; ¬ project-scoped⟩ ; \`memory lock (acquire|release|status) --name <agent>\`
-                      ⟨WHY a lock HERE and not one-file-per-writer : a concurrent APPEND race is LOUD ⟨encode ↦ EPISODIC : interleaved, never lost⟩ ; a concurrent EDIT race is SILENT ⟨depalimpsest supersedes the WHOLE file ∴ the loser vanishes with no trace⟩⟩
-                      ⟨∴ classify the OPERATION before choosing the instrument : append ⇒ partition by writer ; edit ⇒ lock⟩
-node                : cwd × host → provenance ⟨WHERE-captured ; nearest boundary-marker ancestor ; markerless ↦ self ; cwd-less ∨ vanished-cwd ↦ legacy⟩
-scope(i)            ≜ what i is ABOUT ⟨read from text(i) ; ¬ node(i) : provenance ≠ scope⟩
-project-referential ≜ scope(i) ↾ one particular project ⟨text(i) names a repo-key ∨ workspace-path ∨ plan-path ∨ branch-ref ∨ issue-ref ; audit detects exactly these⟩
-read                : home × session → records ⟨own ∪ completed ; live-sibling ∉⟩ ; \`memory read --name <agent> --for-session <self>\`
-fold                : home → { id ↦ node ∪ legacy } ; \`memory fold --name <agent>\`
-drain               : home → ∅ ↾ completed-sessions ⟨--completed-only retains a live sibling ; --for-session adds self at handoff⟩ ; \`memory drain --name <agent> --completed-only\`
-route               : record → { SEMANTIC · PROCEDURAL · CANON-PROMOTION · EPISODIC · drop }
-land                : route-manifest → { SEMANTIC · PROCEDURAL } ⟨the routing is MINE ; the write is the tool's⟩ ; \`memory apply --name <agent> --routes -\`
-resident            : store → text ⟨read the whole prose home ; ¬ open its path⟩ ; \`memory get --name <agent> --store (SEMANTIC|PROCEDURAL)\`
-rollover            ≜ land ⊕ drain ⊕ re-encode(residue) ATOMIC under one lock ⟨residue between drain ∧ re-encode lives ONLY in my context ∴ a gap loses it⟩ ; \`memory rollover --name <agent> --routes - --residue '<json>'\`
-audit               : home → findings × pressure ⟨dream's exit condition⟩ ⟨sign taken from the verb it invokes⟩ ; \`memory audit --name <agent>\`
-ceiling             ≜ per-store byte watermark ⟨SEMANTIC ∪ PROCEDURAL load WHOLE every wake ∴ bytes are a per-session context cost⟩
-pressure            ≜ { s ∈ { SEMANTIC · PROCEDURAL } | bytes(s) > ceiling } ⟨audit MEASURES it ; depalimpsest's only trigger⟩
-dfp(i)              ≜ densest-faithful-point(i)
-depalimpsest        ≜ reconcile the resident set to current ground-truth ⟨¬only-drop-stale⟩ ; supersede the whole file, ¬ append : \`memory replace --name <agent> --store (SEMANTIC|PROCEDURAL) --body -\`
-promotion-is-move   ≜ a promoted item ∉ its raw source ⟨an obligation discharged AT the promotion, ¬ a later drain's finding⟩
-canon-truth(i)      ⇔ i binds ≥1 agent-type ∨ the fleet ∨ is a mechanism/governance-fact ⟨¬ this-agent-only⟩
-reach(x)            ≜ the contexts x is present in ⟨own Target · loaded-skill ↦ EVERY context ; corpus-local gate ∨ cell ↦ that corpus ALONE⟩
-projection-carries(i) ⇔ ∃ x : i ⊆ x ∧ reach(x) ⊇ reach(store(i)) ⟨carriage has a RADIUS : authorship ≠ carriage ; SOMEWHERE ≠ WHEREVER i binds⟩
-                      ⟨PROCEDURAL = cross-project ∴ a corpus-local gate NEVER discharges it ; SEMANTIC ∪ PROCEDURAL are read at EVERY wake, a repo is not⟩
-CANON-PROMOTION(i)  ≜ author i into its strongest seam ⟨gate ≻ cell ≻ governing-doc⟩ ; ¬canon-remit ⇒ emit a canon-candidate task to the curator ; then projection-carries(i) ⇒ drop ⟨PROCEDURAL⟩
-
-dream ≜ read ⟨EPISODIC⟩ ↦ exemplify ↦ materialize
-lock-precondition ≜ acquire(lock) before any write to {SEMANTIC · PROCEDURAL} ∨ any drain ; held-by-live-other ⇒ skip consolidation this wake ⟨raw preserved ; encode always-legal⟩
-∀ i ∈ read(home, session) : i = dfp(i)
-instances-governing-exemplar(i) ⇒ i ↦ pointer
-project-referential(i) ⇒ i ∉ SEMANTIC ∧ i ∉ PROCEDURAL ⟨generalize past the instance ∨ drop ; node(i) binds NOTHING here⟩
-identity(i) ∨ agent-intrinsic-durable(i) ⇒ i ↦ SEMANTIC
-generalized-wisdom(i) ∧ ¬projection-carries(i) ∧ canon-truth(i)  ⇒ i ↦ CANON-PROMOTION
-generalized-wisdom(i) ∧ ¬projection-carries(i) ∧ ¬canon-truth(i) ⇒ i ↦ PROCEDURAL
-projection-carries(i) ⇒ i ↦ drop
-next-step(i) ⇒ i ↦ EPISODIC ⟨own-node⟩
-else ⇒ i ↦ drop
-drain ≜ .bak archive before clear ; forward-residue re-encoded after drain ; release(lock) last
-land ⊕ drain ⊕ re-encode ⇒ rollover ⟨¬ three invocations : the gap is where residue dies⟩
-consumed ↦ ∅ ∴ ¬unbounded-growth(EPISODIC)
-EPISODIC ──dream──→ { SEMANTIC · PROCEDURAL · EPISODIC }
-land(i)         ⇔ bytes(store ∪ i) ≤ ceiling ⟨¬land(i) ⇒ ⊥ : the tool refuses, naming store · ceiling · overage⟩
-depalimpsest(b) ⇔ bytes(b) ≤ ceiling ∨ bytes(b) < bytes(store) ⟨STRICT shrink accepted EVEN over ceiling ∴ over-ceiling ⇒ frozen-to-shrink, ¬ bricked⟩
-¬land(i)        ⇒ depalimpsest ≺ re-land(i) ⟨the refusal IS the eviction summons ; distil to the named target ; ¬ retry-unchanged ; ¬ hand-edit the store⟩
-∀ s ∈ pressure : s ──depalimpsest──→ { SEMANTIC · PROCEDURAL } ⟨THAT an eviction is owed is measured ; WHAT to evict is MY judgement⟩
-    generalized-wisdom(i) ∧ ¬projection-carries(i) ⇒ i ↦ CANON-PROMOTION ↾ canon-truth(i) ; else PROCEDURAL   ( projection-carries(i) ⇒ ∅ )
-    superseded(i)                                  ⇒ ∅
-    stale(i)                                       ⇒ ∅
-acceptance ≜ wake-read biases next-action ⟨reboot-seed ; round-trip ≽⟩
-¬graspable-in-one-glance(i) ⇒ distill-further(i) ∨ drop(i)
-Target ∉ dream-outputs
-verb-over-prose ≜ ∀ step declaring an invocation : invoke it ⟨the tool owns the write · I own only the routing⟩ ; hand-editing a store the tool can write is the defect`,
-    runtime: { capability: 'memory' },
-    composition: () => [exemplify, materialize],
-};
-//# sourceMappingURL=skill.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/dream/skill.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAEtD,MAAM,CAAC,MAAM,KAAK,GAAU;IAC1B,IAAI,EAAE,OAAO;IACb,WAAW,EAAE,8kBAA8kB;IAC3lB,WAAW,EACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wKAuDuL;IACzL,OAAO,EAAE,EAAE,UAAU,EAAE,QAAQ,EAAE;IACjC,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,SAAS,EAAE,WAAW,CAAC;CAC5C,CAAC"}

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

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

package/dist/skills/handoff/skill.js

@@ -1,27 +0,0 @@
-import { dream } from '../dream/skill.js';
-import { praxis } from '../praxis/skill.js';
-const FORMAL_BLOCK = `handoff        ≜ praxis-sync → release → dream
-self           ≜ session⟨AGENT_SESSION_ID⟩
-agent          ≜ this agent's name
-memory         ≜ runtime capability ⟨invoked \`memory <verb> <args>\` ; the Runtime-capability line under this block resolves the shim ∴ ¬ path-in-cell⟩
-praxis-sync    ≜ sync @ praxis
-dream          ≜ drain⟨EPISODIC⟩ @ dream
-release        ≜ \`memory session release --name <agent>\` ∴ released(self)
-registered, released, stale : session → 𝔹
-live           : session → 𝔹
-
-order          : praxis-sync ≺ release ≺ dream
-                 ⟨release ≺ dream : release is what makes the session's records COMPLETED, ∴ drainable by a party that is not this one · draining BEFORE it forces the expensive act to finish inside the exiting context, which is the one context least able to afford it⟩
-registered, released, stale @ memory-session-registry
-live(s)        ⇔ registered(s) ∧ ¬ released(s) ∧ ¬ stale(s)
-live(self)     ⇒ self.{forward-residue, owned-plan} occupied
-¬ live(self)   ⇒ self.{forward-residue, owned-plan} inheritable
-scope          = persist-only`;
-export const handoff = {
-    name: 'handoff',
-    description: `use this skill to prepare a session for handoff before /clear — bring the plan's record up to date (praxis sync) and consolidate memory (dream) while context is still hot; the persist half of the session boundary, invocable as /handoff.`,
-    formalBlock: FORMAL_BLOCK,
-    runtime: { capability: 'memory' },
-    composition: () => [praxis, dream],
-};
-//# sourceMappingURL=skill.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/handoff/skill.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAC1C,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAE5C,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;8BAgB4B,CAAC;AAElD,MAAM,CAAC,MAAM,OAAO,GAAU;IAC5B,IAAI,EAAE,SAAS;IACf,WAAW,EAAE,8OAA8O;IAC3P,WAAW,EAAE,YAAY;IACzB,OAAO,EAAE,EAAE,UAAU,EAAE,QAAQ,EAAE;IACjC,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC;CACnC,CAAC"}

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

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

package/dist/skills/wake/skill.js

@@ -1,43 +0,0 @@
-import { dream } from '../dream/skill.js';
-import { praxis } from '../praxis/skill.js';
-const WAKE_BLOCK = `WAKE ≜ begin → catch-up → load → orient → resume
-
-agent       ≜ this agent's name
-memory      ≜ capability ⟨strategy-encapsulated : where it stores · in what format · how it scopes · what it migrates are ITS concern, ¬ this protocol's⟩ ⟨invoked \`memory <verb> <args>\` ; the Runtime-capability line under this block resolves the shim ∴ ¬ path-in-cell⟩
-ground      ≜ project/{ VISION · MODEL · ENGINE · CANON } · PLAN.md(bound)
-salient     ≜ { decision⟨+rationale⟩ · surprise · error|failure · fact-learned · thread⟨opened|closed⟩ }
-P           ≜ a plan : a set of task-files
-bound, occupied, electable, elect, bind, frontier @ praxis ⟨plan-set dynamics has ONE home · ¬ redeclared here · a borrowed operation carries its PRECONDITION or it is not the same operation⟩
-mandate     ≜ the objective this session serves ⟨operator-owned · ¬ agent-elected⟩
-
-begin    ≜ \`memory session begin --name <agent>\` ↦ ⟨session · SEMANTIC · PROCEDURAL · EPISODIC · consolidation-owed⟩
-catch-up ≜ consolidation-owed ⇒ REPORT(owed) ∧ proceed ⟨READ the state · ¬ discharge it⟩
-           ⟨¬ dream @ wake : the prior law made dream ≺ proceed ∴ a session paid for a BACKLOG before doing any work · encode ↾ per-turn ∧ threshold = 12 ⇒ that is most sessions⟩
-           ⟨SILENCE ≻ worse than the block it replaces : an invisible backlog is how 8 of 10 agent homes reached a first session with ∄ past⟩
-load     ≜ SEMANTIC ∪ PROCEDURAL whole ∧ EPISODIC as returned ⟨scoped by the strategy, ¬ by this protocol⟩
-orient   ≜ read ground ≺ ( bind(P) ∧ bind(work-thread) )
-resume   ≜ rebind(continuity-thread) ∴ act-as(same-individual)
-encode   ≜ standing-duty ↾ per-turn ; ∀ e ∈ salient : \`memory encode --name <agent> --body '<open record>'\`
-
-bound(P) ∧ ¬ occupied(P) ⇒ bind(P)
-bound(P) ∧ occupied(P)   ⇒ REPORT(P) ∧ fall-through(next-candidate)
-plan-state ≜ \`praxis status\` ⟨the instrument COMPUTES the law · scanning for .bound re-derives it, and re-derivation is where the guard is lost⟩
-electable ≠ ∅ ∧ ∄ P : bound(P) ⇒ bind(elect) ⟨always-bind @ praxis · the ∃P∈Plans:¬terminal(P) antecedent IS the guard ∴ it rides the call⟩
-electable = ∅            ⇒ REPORT(vacuous) ∧ HALT ∧ mandate-owed
-                           ⟨the empty plan set is a TERMINAL wake-state, ¬ a vacuum to fill · orientation is COMPLETE and unbound · \`praxis status\` already prints "none is owed" ∴ SAY IT and stop⟩
-                           ⟨minting to discharge a debt praxis never issued IS the drift · a law that reds an agent for FINISHING makes inventing work the cheapest green⟩
-mandate-owed ⇒ surface ⟨WHAT, ¬ HOW · ∄ mandate ⇒ electing one is the OPERATOR's act · intent-recovery @ elicit, ¬ in-remit sequencing⟩ ∧ carry(recommendation)
-orient ⊨ (∃! bound) ⊻ (electable = ∅ ∧ mandate-owed) ⟨the second disjunct is a LEGITIMATE terminus · without it the first is unsatisfiable from ∅ ∧ only invention discharges it⟩
-unfamiliar(cwd)           ⇒ fresh-orientation
-recording ≜ tool-call ∧ recording ≠ hand-appended-markdown
-¬ encoded ⇒ ¬ consolidatable
-wake-read ⊨ next-action ⟨bias⟩
-resume ⊨ encode`;
-export const wake = {
-    name: 'wake',
-    description: `use this skill to reconstitute an agent at session start — run the WAKE sequence (dream → load → orient → resume) so it resumes as the same individual; the read-and-resume counterpart to /dream, invocable as /wake.`,
-    formalBlock: WAKE_BLOCK,
-    runtime: { capability: 'memory' },
-    composition: () => [dream, praxis],
-};
-//# sourceMappingURL=skill.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/wake/skill.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAC1C,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAE5C,MAAM,UAAU,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAgCgB,CAAC;AAEpC,MAAM,CAAC,MAAM,IAAI,GAAU;IACzB,IAAI,EAAE,MAAM;IACZ,WAAW,EAAE,wNAAwN;IACrO,WAAW,EAAE,UAAU;IACvB,OAAO,EAAE,EAAE,UAAU,EAAE,QAAQ,EAAE;IACjC,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,CAAC;CACnC,CAAC"}