@cratylus/canon 0.1.0 → 0.1.2

package/dist/hooks/memory-consolidation-nudge.js

@@ -1,148 +0,0 @@
-// memory-consolidation-nudge — an ADVISORY Stop hook (the harness half of the
-// memory-consolidation protocol). On turn.end (Stop only — NOT SubagentStop), it
-// cheaply counts the agent's unconsolidated EPISODIC records and, over a
-// conservative watermark, prints a non-blocking advisory to run a hot-path dream.
-//
-// WHY THIS EXISTS (the harness half of the memory dimension):
-//   Per-turn ENCODE grows the raw EPISODIC log; only /dream folds + drains it. An
-//   agent that never dreams accretes an unbounded raw log and loses the
-//   consolidation window while context is still hot. This hook is the ambient
-//   reminder: it observes the backlog the agent cannot see from inside the turn
-//   and surfaces "time to consolidate" — without ever wedging the turn.
-//
-// ADVISORY, NEVER BLOCKING (the load-bearing contract):
-//   Unlike stance-guardrail, this hook NEVER emits `{"decision":"block"}`. It
-//   prints an advisory line to stdout and exits 0. Memory consolidation is a
-//   soft, recoverable duty; blocking a turn on an un-run ritual would wedge real
-//   work for no correctness gain. The nudge is intentionally soft.
-//
-// HOME DERIVATION (the Stop-env caveat — flagged, not faked):
-//   A top-level Stop hook fires in the harness env and carries NO agent_type
-//   (that is a SubagentStop field), so the agent's home is not handed in. The
-//   worker derives it best-effort, in order: (1) $CLAUDE_AGENT_HOME override;
-//   (2) match the hook JSON's session_id against the memory session registry
-//   `~/.agents/*/sessions/<id>.json` (the liveness registry the `memory` tool keeps —
-//   the correct derivation whenever wake has registered the session); (3) the sole
-//   `~/.agents/*` home when exactly one exists. If none resolves, it exits 0
-//   SILENTLY — a KNOWN LIMITATION (no reliable home ⇒ no honest count), never a
-//   fabricated count.
-//
-// The `workers[].content` is the TEMPLATE the committed worker at `targetPath`
-// regenerates from — resolved bytes, byte-locked by `test/hook-rule-boundary.test.ts`.
-// EDIT THE CELL AND REGENERATE (`pnpm canon:project:targets`) — never the committed
-// `.sh` alone; a hand-edit drifts the anchor and the byte-lock goes red.
-//
-// THIS CELL ONCE IMPORTED `CLI_BIN` FROM `@cratylus/runtime`, and it was the last
-// breach of ARCHITECTURE's property 1 — meaning and mechanism never reference each
-// other. The rationale on record was that "the worker names it inside a shell string
-// no compiler reads", which is true and beside the point: the import is an edge
-// whether or not a compiler follows the value into the string. The worker now names
-// the FACT it needs (`{{fact:runtime-bin}}`) and the PROJECTOR substitutes; the cell
-// names a capability, never an implementation. `$MEMORY_BIN` stays the override and
-// the test seam; the resolved name is only its DEFAULT.
-//
-// WHAT IT SAYS TO AN AGENT lives in `speech`, not in the shell. Those two strings are
-// the only bytes here that land in a reader's context, so they are the only ones a
-// reader-density gate should score — and they had no declared home until this seam.
-export const memoryConsolidationNudge = {
-    id: 'memory-consolidation-nudge',
-    residue: 'advisory ↾ turn-end · owed ⇒ emit hot-path-dream advisory ⟨¬block · exit-0 · ¬wedge-turn⟩ · owed ↦ runtime ⟨backlog ∨ store-pressure ∨ scope-drift ; ¬face-computed⟩ · home ↦ $env ∨ runtime(session) ⟨¬derivable ⇒ silent⟩ · fail-open ∀error',
-    substrate: 'harness',
-    events: ['turn.end'],
-    entry: 'memory-consolidation-nudge.sh',
-    timeout: 10,
-    refs: [],
-    speech: [
-        {
-            id: 'owed',
-            text: 'MEMORY — a consolidation is owed (unfolded records, an oversized store, or scope drift). Consider a hot-path /dream to fold, drain and depalimpsest while context is hot.',
-        },
-        {
-            id: 'blind',
-            // `%s` is the worker's printf arg for `$MEM` — the bin actually consulted. A
-            // BLIND nudge that named no binary would send the reader hunting for which one.
-            text: 'MEMORY — the runtime did not answer whether a consolidation is owed (`%s memory audit` failed). The nudge is BLIND until that is fixed; this is not a clear verdict.',
-        },
-    ],
-    workers: [
-        {
-            filename: 'memory-consolidation-nudge.sh',
-            targetPath: 'packages/canon/targets/guardrail/memory-consolidation-nudge.sh',
-            executable: true,
-            content: `#!/usr/bin/env sh
-# memory-consolidation-nudge — an ADVISORY Stop hook. It asks the memory runtime
-# whether a consolidation is owed and, if so, prints a non-blocking reminder to
-# run a hot-path /dream. It NEVER blocks the turn.
-#
-# WHY (the harness half of the memory dimension): per-turn ENCODE grows the raw
-# EPISODIC log and the prose stores only ever grow; only /dream folds, drains and
-# depalimpsests them. This is the ambient reminder to do it while context is hot.
-#
-# THE FACE ASKS, IT DOES NOT KNOW. Both questions this hook needs — which home
-# owns this session, and whether a dream is owed — are answered by the runtime:
-#
-#   memory home  --session <id>   -> the owning home (registry lookup)
-#   memory audit --home <h> --owed -> "owed" | "clear"
-#
-# It previously derived the home by scanning ~/.agents/* and counted the backlog
-# by awk-ing EPISODIC.jsonl. Both made a harness FACE read the being's memory
-# layout, and the second put a second home on the "is a dream owed" predicate —
-# one that measured only raw-record count, so an oversized prose store never
-# raised a signal at all.
-#
-# CONTRACT:
-#   - ADVISORY ONLY. Prints to stdout and exits 0. It NEVER emits
-#     {"decision":"block"} — a soft, recoverable duty must not wedge a turn.
-#   - FAILS OPEN + SILENT. Any error (no runtime, no home, no jq) -> exit 0, no
-#     output. A reminder that misfires on its own flakiness is worse than a
-#     missed one.
-#   - Stop ONLY (turn.end). Registered on subagent.end it would nudge transient
-#     sub-turns; the dimension home is the top-level agent's.
-#
-# INPUT  : Claude Code Stop hook JSON on stdin (session_id, cwd, ...).
-# OUTPUT : owed -> one advisory line + exit 0; else nothing.
-
-set -eu
-
-# A Stop hook must never break a session. Any unexpected error -> allow the stop.
-trap 'exit 0' EXIT
-
-# The runtime bin. \$MEMORY_BIN is the override and the test seam.
-MEM="\${MEMORY_BIN:-{{fact:runtime-bin}}}"
-command -v "\$MEM" >/dev/null 2>&1 || exit 0
-
-input="\$(cat 2>/dev/null || true)"
-
-# --- resolve the home: explicit override, else ask the registry ----------------
-home="\${CLAUDE_AGENT_HOME:-}"
-if [ -z "\$home" ]; then
-	sid=""
-	if command -v jq >/dev/null 2>&1 && [ -n "\$input" ]; then
-		sid="\$(printf '%s' "\$input" | jq -r '.session_id // empty' 2>/dev/null || true)"
-	fi
-	[ -n "\$sid" ] || exit 0
-	home="\$("\$MEM" memory home --session "\$sid" 2>/dev/null || true)"
-fi
-[ -n "\$home" ] || exit 0
-
-# --- ask whether a dream is owed ------------------------------------------------
-# The verdict and the FAILURE are separated deliberately. Every runtime call here is
-# \`2>/dev/null || true\` so a reminder can never fail a turn — correct, but it made an
-# unreachable runtime yield an EMPTY verdict, which is exactly what "clear" yields. So
-# a broken runtime read as a clean bill of health, silently and forever: the nudge
-# would stop existing and nothing would say so. \`if signal absent then pass\` is a
-# bypass by omission; this inverts it to \`if signal absent then SAY SO\`, while still
-# never blocking.
-if verdict="\$("\$MEM" memory audit --home "\$home" --owed 2>/dev/null)"; then
-	if [ "\$verdict" = "owed" ]; then
-		printf '{{speech:owed}}\\n'
-	fi
-else
-	printf '{{speech:blind}}\\n' "\$MEM"
-fi
-exit 0
-`,
-        },
-    ],
-};
-//# sourceMappingURL=memory-consolidation-nudge.js.map

package/dist/hooks/memory-consolidation-nudge.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"memory-consolidation-nudge.js","sourceRoot":"","sources":["../../src/hooks/memory-consolidation-nudge.ts"],"names":[],"mappings":"AAEA,8EAA8E;AAC9E,iFAAiF;AACjF,yEAAyE;AACzE,kFAAkF;AAClF,EAAE;AACF,8DAA8D;AAC9D,kFAAkF;AAClF,wEAAwE;AACxE,8EAA8E;AAC9E,gFAAgF;AAChF,wEAAwE;AACxE,EAAE;AACF,wDAAwD;AACxD,8EAA8E;AAC9E,6EAA6E;AAC7E,iFAAiF;AACjF,mEAAmE;AACnE,EAAE;AACF,8DAA8D;AAC9D,6EAA6E;AAC7E,8EAA8E;AAC9E,8EAA8E;AAC9E,6EAA6E;AAC7E,sFAAsF;AACtF,mFAAmF;AACnF,6EAA6E;AAC7E,gFAAgF;AAChF,sBAAsB;AACtB,EAAE;AACF,+EAA+E;AAC/E,uFAAuF;AACvF,oFAAoF;AACpF,yEAAyE;AACzE,EAAE;AACF,kFAAkF;AAClF,mFAAmF;AACnF,qFAAqF;AACrF,gFAAgF;AAChF,oFAAoF;AACpF,qFAAqF;AACrF,oFAAoF;AACpF,wDAAwD;AACxD,EAAE;AACF,sFAAsF;AACtF,mFAAmF;AACnF,oFAAoF;AAEpF,MAAM,CAAC,MAAM,wBAAwB,GAAa;IAChD,EAAE,EAAE,4BAA4B;IAChC,OAAO,EACL,gPAAgP;IAClP,SAAS,EAAE,SAAS;IACpB,MAAM,EAAE,CAAC,UAAU,CAAC;IACpB,KAAK,EAAE,+BAA+B;IACtC,OAAO,EAAE,EAAE;IACX,IAAI,EAAE,EAAE;IACR,MAAM,EAAE;QACN;YACE,EAAE,EAAE,MAAM;YACV,IAAI,EAAE,2KAA2K;SAClL;QACD;YACE,EAAE,EAAE,OAAO;YACX,6EAA6E;YAC7E,gFAAgF;YAChF,IAAI,EAAE,sKAAsK;SAC7K;KACF;IACD,OAAO,EAAE;QACP;YACE,QAAQ,EAAE,+BAA+B;YACzC,UAAU,EACR,gEAAgE;YAClE,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwEd;SACI;KACF;CACF,CAAC"}

package/dist/hooks/resume-availability-notice.d.ts

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

package/dist/hooks/resume-availability-notice.js

@@ -1,50 +0,0 @@
-// resume-availability-notice — the SessionStart note. It tells the agent that
-// memory exists and that `/wake` reconstitutes it, and does nothing else.
-//
-// WHY A NOTE AND NOT AN ACTION: reconstitution is the operator's call, not the
-// harness's. The agent may already have been woken, may deliberately be wanted
-// cold, or may simply have been started without it. A hook cannot tell which,
-// so it must not decide — it makes the option visible and leaves the choice
-// where it belongs.
-//
-// THE VERB-FREE LAW IS LOAD-BEARING, not tidiness. Every memory verb that
-// touches the registry REGISTERS the session, and registration is exactly what
-// distinguishes a woken session from an encode-only one (`SessionEntry.origin`).
-// A note that called any such verb would register the session itself and make
-// every session look woken — destroying the very signal that lets the agent
-// notice it was NOT woken. So: no `session begin`, no `register`, no `read`, no
-// `encode`. It reads nothing, writes nothing, and needs no home.
-export const resumeAvailabilityNotice = {
-    id: 'resume-availability-notice',
-    residue: 'emit ↾ session.start · fixed-text · ¬verb ⟨any registry touch ⇒ every session reads woken ∴ origin destroyed⟩ · ¬read · ¬write · ¬home-derivation · reconstitution ↦ operator ⟨may have run it · may refuse it · may have forgotten⟩ · exit-0 ∀error',
-    substrate: 'harness',
-    events: ['session.start'],
-    entry: 'resume-availability-notice.sh',
-    timeout: 5,
-    refs: [],
-    workers: [
-        {
-            filename: 'resume-availability-notice.sh',
-            targetPath: 'packages/canon/targets/guardrail/resume-availability-notice.sh',
-            executable: true,
-            content: `#!/usr/bin/env sh
-# resume-availability-notice — a SessionStart note. Emits ONE fixed line telling
-# the agent that memory skills exist and that /wake reconstitutes it.
-#
-# It calls NO memory verb. That is a hard requirement, not a style choice: every
-# registry-touching verb registers the session, and registration is what marks a
-# session as woken. A note that registered would make every session look woken
-# and destroy the signal it exists to support.
-#
-# Reads nothing, writes nothing, derives no home. Always exits 0.
-
-set -eu
-trap 'exit 0' EXIT
-
-printf 'MEMORY — this agent has persistent memory. /wake reconstitutes it (prior state, standing plan, continuity); /dream consolidates it. Neither runs automatically.\\n'
-exit 0
-`,
-        },
-    ],
-};
-//# sourceMappingURL=resume-availability-notice.js.map

package/dist/hooks/resume-availability-notice.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"resume-availability-notice.js","sourceRoot":"","sources":["../../src/hooks/resume-availability-notice.ts"],"names":[],"mappings":"AAEA,8EAA8E;AAC9E,0EAA0E;AAC1E,EAAE;AACF,+EAA+E;AAC/E,+EAA+E;AAC/E,8EAA8E;AAC9E,4EAA4E;AAC5E,oBAAoB;AACpB,EAAE;AACF,0EAA0E;AAC1E,+EAA+E;AAC/E,iFAAiF;AACjF,8EAA8E;AAC9E,4EAA4E;AAC5E,gFAAgF;AAChF,iEAAiE;AAEjE,MAAM,CAAC,MAAM,wBAAwB,GAAa;IAChD,EAAE,EAAE,4BAA4B;IAChC,OAAO,EACL,sPAAsP;IACxP,SAAS,EAAE,SAAS;IACpB,MAAM,EAAE,CAAC,eAAe,CAAC;IACzB,KAAK,EAAE,+BAA+B;IACtC,OAAO,EAAE,CAAC;IACV,IAAI,EAAE,EAAE;IACR,OAAO,EAAE;QACP;YACE,QAAQ,EAAE,+BAA+B;YACzC,UAAU,EACR,gEAAgE;YAClE,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;CAgBd;SACI;KACF;CACF,CAAC"}

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

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

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