@cratylus/canon 0.18.0 → 0.20.0

package/dist/hooks/deploy-drift-notice.js

@@ -1,431 +0,0 @@
-// deploy-drift-notice — the advisory that answers, before the agent acts, whether
-// the doctrine THIS HOST runs is the doctrine the corpus renders.
-//
-// THE INCIDENT. `~/.omp/agent/agents/<name>.md` and the render tree diverged. An agent
-// edited the corpus for a full session under a superseded first principle, and every
-// gate in the repository stayed green the entire time — because every gate that
-// existed was a claim about how a target is PRODUCED, and none was a claim about what
-// a host is RUNNING. The comparison that would have caught it landed with
-// `deploy --check`: reachable, correct, and speaking only when asked. A check that
-// must be remembered is a check that will be forgotten at exactly the moment it
-// matters — the session where the doctrine is already wrong. This cell is what asks.
-//
-// SILENCE WHEN CLEAN IS THE LOAD-BEARING HALF, not a courtesy. An advisory that fires
-// every session trains its reader to skip it, and a skipped advisory is worse than an
-// absent one: it occupies the slot where a real warning would have been read. So the
-// in-sync path emits nothing at all, and the cost of that path is what makes the
-// silence affordable (below).
-//
-// IT RELAYS A REPORT, IT DOES NOT COMPUTE ONE. `deploy --check` already produces the
-// only thing worth saying — per artifact, the rendered lines this host is MISSING and
-// the superseded lines it is STILL RUNNING. "3 files differ" does not tell an agent
-// its own first principle is stale; the axiom does. Recomputing any of that here would
-// put a second home under the one claim that must never fork, and the second home
-// would be a shell script.
-//
-// WHAT IT MAY NOT DO: refuse. `ARCHITECTURE`'s fidelity ladder — a shortfall degrades
-// and warns, it never refuses and never widens. A stale deployment must not block a
-// session; it must be impossible to start one without being told.
-//
-// IT ASKS AGAIN, BECAUSE THE HOST GOES STALE MID-SESSION. Bound to `session.start`
-// alone, the cell answered a question that expires: a projection landing during the
-// session it was authored in left the rest of that session running the superseded
-// copy with nothing further to say. That is not hypothetical and it is not rare —
-// it is the ORDINARY shape of work here, where a session edits a cell, projects it,
-// and keeps going under the version it just replaced. The 16-hour-old projection of
-// an agent's own governing cell was this; so was an authored skill edit that landed under a
-// running session hours later.
-//
-// `prompt.submit` IS THE RE-ARM, and it is the same question at a finer grain rather
-// than a second mechanism. Both moments put the notice before the agent acts on an
-// instruction, where the false premise can be corrected. `turn.end` is the wrong end
-// of the turn: it speaks after the acting is done. `file.edit.post` was rejected as
-// a category error — a cell EDIT is not drift; drift begins when the render tree moves,
-// which happens under a shell command.
-//
-// A RE-ARM IS ONLY AS GOOD AS ITS SILENCE, and this one is where the silence had to be
-// re-earned. Fired every prompt, an unchanged verdict would repeat the same advisory
-// until the reader stopped seeing it — the exact failure the in-sync path was built to
-// avoid, re-entering through the door held open for the fix. So the trigger is a CHANGE
-// in the verdict, never a verdict that is merely non-empty: the worker records the last
-// verdict this session was told (keyed by ⟨harness, session⟩, carrying ⟨corpus, tree⟩ so
-// the same session moved to another checkout asks a fresh question) and speaks only when
-// the new one differs. Said once, a standing drift is then silent until it changes or is
-// repaired. THE CLEAN VERDICT IS RECORDED TOO, and that is what makes a REAPPEARING drift
-// audible: without it, drift → deploy → the identical drift again would match the stale
-// record and say nothing.
-//
-// NO SESSION IDENTITY MEANS NO SUPPRESSION, deliberately, in that direction. When the
-// payload carries no usable `session_id` or the state cannot be written, every run
-// speaks. A repeated advisory under genuine drift is noise the operator can end with one
-// command; a suppressed one is silence, and this cell's own residue says silence is
-// borrowed from the in-sync path and may never be handed to any other.
-//
-// COST, MEASURED (2026-08-05, darwin/arm64, warm page cache, 39 rendered artifacts
-// against a deployed `.claude` of ~40 files):
-//   clean path, end to end   45 ms  (10 ms shell discovery + ~35 ms comparator)
-//   drift path, end to end   60 ms  (the report is longer, and is printed)
-//
-// RE-MEASURED after the three repairs above, and reported as an A/B rather than as a
-// new absolute, because an absolute is a claim about the rig as much as the worker.
-// Same corpus, same real deployment, best-of-7, the PREVIOUS worker and this one run
-// alternately in one session:
-//   previous worker   56 ms clean · 58 ms drift
-//   this worker       56 ms clean · 56 ms drift
-// The change is free, and the whole spread between 45 and 56 belongs to the harness
-// the numbers were taken through (a `sh` under a `bash` under a timestamping
-// `python3`), not to anything the worker does. It could not have been otherwise: the
-// three facts are SUBSTITUTED AT PROJECTION, so the resolved worker does the same
-// three variable assignments it always did, and the one thing that got cheaper is the
-// non-zero path, which no longer forks `printf | tail | grep` to recover a verdict.
-//
-// RE-MEASURED AGAIN for the re-arm, same rig, same A/B discipline (best-of-7, the two
-// workers run alternately; the clean leg against a fixture host deployed from this
-// corpus's own render tree, so it is a real in-sync verdict rather than an early exit):
-//   previous worker   62 ms clean · 62 ms drift
-//   this worker       60 ms clean · 64 ms drift
-// Per run it is free — the state costs one `cat` and one small write, which is under
-// this rig's noise. THE COST THAT ACTUALLY CHANGED IS FREQUENCY, and saying so is the
-// point of measuring: the hook now runs once per PROMPT rather than once per session,
-// so a 40-prompt session pays ~2.4 s of wall clock it did not pay before, spread across
-// 40 moments where the agent is already waiting on a model. That is the price of not
-// running superseded doctrine for the other 39 of them, and it is the trade this cell
-// exists to take. The per-run number is what keeps it payable, which is why the bound
-// is held by a test rather than remembered.
-//
-// A FULL BYTE COMPARISON of every rendered artifact is therefore what runs — no
-// digest, and above all NO SAMPLE. A sample that skips the ten skills carrying the
-// prime principle reports "in sync", which is the exact failure this cell exists to end. The
-// `deploy-drift-notice` suite re-measures the clean path and fails on a regression, so
-// the number above is a held bound rather than a remembered one.
-//
-// THE CELL NAMES A CAPABILITY, NOT A PATH, and it now ASKS for everything it used to
-// infer. TWO LAWS BIND A CELL. The first: a cell must not restate a location the
-// projector already computes. The harder companion: a cell must not GUESS what the
-// projector could have told it. Three guesses lived here and all three are gone:
-//
-//   1. THE COMPARATOR'S NAME was a shell literal, because the forge CLI's name had no
-//      compile-time home the way `CLI_BIN` does. It has one now — derived, not
-//      declared: `forge/src/bin-name.ts` reads the `bin` key npm itself obeys, so
-//      there is one authored spelling in the package and the cell names the fact
-//      (`deploy-bin`) rather than repeating it.
-//   2. THE HARNESS was assumed to be claude. The tree is still identified by SHAPE —
-//      `--out` is an operator's choice and must never be assumed — but the shape it
-//      matches is now THIS harness's, because the projector substitutes this
-//      harness's hooks-file name (`harness-hooks-file`) and its own name
-//      (`harness-name`, passed to the comparator so it audits the right home). A
-//      omp session reports on the omp deployment. The pair lives on
-//      `HarnessAdapter` and reaches here through projection, which is the only stage
-//      that knows which adapter it is rendering for — the alternative was a
-//      shell-side copy of the harness registry, a second home for adapter knowledge.
-//   3. THE VERDICT was recovered by matching the report's closing line. `deploy
-//      --check` exited 1 both when the host was stale and when the check itself
-//      failed, so the exit status could not separate them and the worker read the
-//      TEXT — coupling a hook worker to the comparator's output FORMAT because its
-//      exit CONTRACT could not carry the distinction. The contract carries it now
-//      (`forge/src/deploy/check-exit.ts`: 0 in sync · 1 drift · 2 no verdict), and
-//      the one code that is forge's choice rather than POSIX's arrives as a fact.
-//
-// EVERY HOOK WORKER ON EVERY HARNESS HAD (2). This cell is only the first whose job
-// made it visible, because it is the first that has to LOOK at the deployed tree
-// rather than merely run in it — and the repair is on the shared channel, so the next
-// one asks by name instead of rediscovering the blindness.
-//
-// The `workers[].content` is the TEMPLATE the committed worker at `targetPath`
-// regenerates from — resolved bytes, byte-locked by `test/hook-rule-boundary.test.ts`.
-// The committed resolution is the OMP one (`COMMITTED_TARGET_HARNESS`), because a
-// template with an adapter-relative fact has one resolution per harness and
-// `targetPath` names one file; every DEPLOYED copy is resolved for the harness that
-// session runs. EDIT THE CELL AND REGENERATE (`pnpm canon:project:targets`) — never
-// the committed `.sh` alone.
-export const deployDriftNotice = {
-    id: 'deploy-drift-notice',
-    residue: 'advisory ↾ session.start ∧ prompt.submit ⟨re-arm ∴ mid-session projection ⇏ stale ∀remaining-turns⟩ · deployed ≢ rendered ⇒ emit ⟨superseded-lines ∧ missing-lines ; ¬count · ¬digest · ¬sample⟩ ↾ verdict ≢ last-told ⟨trigger ≜ verdict-change · ¬verdict-non-empty ∴ re-arm ⇏ re-notify · memory ↾ ⟨harness · session⟩ ∧ ⟨corpus · tree⟩ · in-sync recorded ∴ recurrence audible · ∄session-id ⇒ ¬suppress ⟨noise ≻ borrowed-silence⟩⟩ · deployed ≡ rendered ⇒ ∅ ⟨silence-when-clean MANDATORY ⟨fires ∀session ⇒ reader-skips ⇒ worse-than-absent⟩⟩ · verdict ↦ comparator ⟨corpus-owned · ¬face-computed · ¬reimplemented⟩ · corpus ↦ walk-up ⟨cwd · corpus-marker⟩ ⟨∄ ⇒ ∅ ⟨¬in-scope ∴ ¬wrong⟩⟩ · tree ↦ shape ⟨agents ∧ skills ∧ THIS-harness-hooks-file ; ¬named-path⟩ · harness ↦ projection ⟨¬inferred ∴ session-own-deployment⟩ · stale ⊻ ¬ran ↦ exit-code ⟨¬report-text ∴ format ⊥ verdict⟩ · reached ∧ ∄verdict ⇒ SAY-SO ⟨silence ≡ in-sync ∴ ¬borrowable⟩ · ¬block · exit-0 ∀error',
-    substrate: 'harness',
-    events: ['session.start', 'prompt.submit'],
-    entry: 'deploy-drift-notice.sh',
-    timeout: 10,
-    refs: [],
-    speech: [
-        {
-            id: 'drift',
-            text: 'DEPLOY DRIFT — this host runs a SUPERSEDED projection of the canon. In the report below, a `-` line is doctrine THIS SESSION is operating under and the corpus no longer says; a `+` line is what the corpus says and this host never received. Read every `-` line as a false premise, not as background. `pnpm canon:deploy` converges the host.',
-        },
-        {
-            id: 'no-verdict',
-            // `%s` is the worker's printf arg for the comparator it actually invoked. A
-            // BLIND line naming nothing sends the reader hunting for what failed.
-            text: 'DEPLOY DRIFT — the comparator (`%s`) returned no verdict, so whether this host runs the current canon is UNKNOWN. This is not an in-sync report; nothing here establishes that the doctrine in force is the corpus.',
-        },
-        {
-            id: 'no-comparator',
-            text: 'DEPLOY DRIFT — this corpus is in scope and its deploy comparator (`%s`) is not installed here, so whether this host runs the current canon is UNKNOWN. Install the workspace dependencies to make the question answerable; until then this is not an in-sync report.',
-        },
-    ],
-    workers: [
-        {
-            filename: 'deploy-drift-notice.sh',
-            targetPath: 'packages/canon/targets/guardrail/deploy-drift-notice.sh',
-            executable: true,
-            content: `#!/usr/bin/env sh
-# deploy-drift-notice — an ADVISORY, at session start and again before every
-# prompt. It asks the corpus's own deploy tool whether the tree this host RUNS is
-# the tree the corpus RENDERS, and speaks only when the answer CHANGES to "no".
-#
-# WHY (the incident): a deployed agent definition and the render tree diverged, an
-# agent ran a superseded first principle for a whole session, and every gate in the
-# repository stayed green throughout. The comparison was already reachable —
-# \`deploy --check\` — and nothing ran it, so the drift stayed silent by default.
-#
-# WHY AGAIN (the second incident): bound to session start alone, it answered a
-# question that expires. A projection landing MID-session left the rest of that
-# session running the superseded copy with nothing further to say — which is the
-# ordinary shape of work here, not an edge case. \`prompt.submit\` re-asks it in the
-# same position that made the first answer worth having: before the agent acts.
-#
-# CONTRACT:
-#   - SILENT WHEN IN SYNC. An advisory that fires every session trains its reader
-#     to skip it, and is then worse than absent.
-#   - SPEAKS ON A CHANGE, NOT ON A STATE. Re-armed per prompt, a standing drift
-#     would otherwise repeat until it stopped being read — the same failure, back
-#     through the door the re-arm opened. The last verdict this session was told is
-#     recorded; an identical one is silent.
-#   - ADVISORY ONLY. Prints to stdout and exits 0. It never emits
-#     {"decision":"block"} — a stale deployment must not block a session.
-#   - NEVER SAMPLES. The comparison is the tool's own: whole tree, byte for byte.
-#     A sample that skips the ten skills carrying the prime principle reports "in sync".
-#   - NOT A COUNT. It relays the tool's report, which carries the superseded lines
-#     still running and the rendered lines missing.
-#
-# NOTHING BELOW IS INFERRED THAT PROJECTION COULD STATE. The four values this
-# worker cannot compute for itself are SUBSTITUTED into it when the cell is
-# rendered — the comparator's name, this harness's name and hooks file, and the
-# exit code the comparator returns for drift. A copy of any of them, spelled here,
-# would be a second home in a file no compiler reads.
-#
-# COST: the cell header carries the measurement and its A/B. Not repeated here — a
-# number in two places is a number that will disagree with itself. What is worth
-# saying at this grain: the discovery below is a small fraction of it, and the rest
-# is the comparator reading both trees whole, which is the point.
-#
-# INPUT  : SessionStart / UserPromptSubmit hook JSON on stdin (cwd, session_id, ...).
-# OUTPUT : a CHANGED drift verdict -> advisory + the report; a changed unanswerable
-#          one -> a BLIND line; in sync, or unchanged since this session was told -> none.
-
-set -eu
-
-# Neither a session start nor a prompt may be broken by an advisory. Any unexpected
-# error -> silence.
-trap 'exit 0' EXIT
-
-# ── WHAT PROJECTION TOLD US ────────────────────────────────────────────────────
-# The corpus's own deploy tool. ONE authored spelling exists in the whole
-# repository — \`packages/forge/package.json\`'s \`bin\` key, the one npm obeys — and
-# \`forge/src/bin-name.ts\` derives from it, so this line is that key, relayed.
-DEPLOY_TOOL={{fact:deploy-bin}}
-
-# WHICH HARNESS THIS PROJECTION IS FOR. A hook worker is handed no identity by the
-# session it runs in, so a worker that must LOOK at a deployed tree had to guess —
-# and guessed claude, which made an omp session report on a sibling deployment.
-# These two are the adapter's own \`name\` and \`hooksFile\`, substituted at
-# projection: the omp render of this cell carries omp's.
-HARNESS={{fact:harness-name}}
-HARNESS_HOOKS_FILE={{fact:harness-hooks-file}}
-
-# The status the comparator returns when it FOUND drift. \`0\` means success to
-# POSIX and needs no telling; this one is the tool's own choice, so it is told.
-DRIFT_RC={{fact:deploy-check-drift-code}}
-
-# ── THE PAYLOAD, DRAINED ONCE ──────────────────────────────────────────────────
-# Two fields are needed and stdin can only be read once, so both come off ONE jq —
-# the same single fork the cwd lookup already cost, not a second one. \`.cwd\` says
-# which corpus; \`.session_id\` says who is being told, which is what lets a re-armed
-# advisory stay quiet about a verdict it has already delivered.
-input="$(cat 2>/dev/null || true)"
-cwd=""
-sid=""
-if command -v jq >/dev/null 2>&1 && [ -n "$input" ]; then
-	fields="$(printf '%s' "$input" | jq -r '.cwd // "", .session_id // ""' 2>/dev/null || true)"
-	{
-		read -r cwd || true
-		read -r sid || true
-	} <<EOF
-$fields
-EOF
-fi
-
-# ── WHERE ARE WE? the corpus, by its own marker ────────────────────────────────
-# \`cratylus.config.ts\` is the file \`deploy\` itself reads to learn which corpus it is
-# operating on. Walking up for it asks the same question the tool asks, instead of
-# inventing a second convention for "a checkout of the canon".
-start="\${CRATYLUS_CORPUS:-$cwd}"
-[ -n "$start" ] || start="\${CLAUDE_PROJECT_DIR:-$PWD}"
-
-root=""
-d="$start"
-while [ -n "$d" ] && [ "$d" != "/" ]; do
-	if [ -f "$d/cratylus.config.ts" ]; then
-		root="$d"
-		break
-	fi
-	d="\${d%/*}"
-done
-# NO CORPUS IN SCOPE IS SILENCE, and it is not the "clean" silence above. A session
-# outside every checkout has no rendered doctrine to be compared against, so there is
-# nothing here this hook could be right or wrong about — and speaking would fire it on
-# every unrelated session, which is the one failure that makes an advisory worthless.
-[ -n "$root" ] || exit 0
-
-# ── WHICH TREE? this harness's render tree, by its SHAPE ───────────────────────
-# A render tree is recognized by BEING one: \`agents/\` + \`skills/\` + THIS harness's
-# own hooks file. That file is what distinguishes this harness's tree from another
-# harness's tree sitting beside it, and it is named by projection rather than by
-# this script — so an omp render of this worker skips the claude tree and a claude
-# render skips the omp one. The \`--out\` dir is an operator's choice, so the tree
-# is discovered, never named.
-#
-# THE GLOB USED TO BE \`.render*\`, WHICH MADE THE PARAGRAPH ABOVE FALSE. The shape
-# test only ever ran on candidates a NAME had already selected, so "discovered, never
-# named" described the second half of a two-stage filter whose first stage was a
-# hard-coded prefix. Any operator honouring the documented freedom — \`--out
-# build/corpus\` — got silence, and silence here is indistinguishable from in-sync.
-# The rename of the corpus's own tree is what surfaced it; the defect predates it.
-#
-# So the candidate set is now DOTTED DIRECTORIES at the same depths, plus one level
-# beneath each, because a tree that splits per harness puts the shape one deeper
-# (\`.cratylus/claude\`, not \`.render-ts\`). Dotted, because that is the convention
-# for generated trees (\`.next\`, \`.turbo\`, \`.svelte-kit\`) and because walking every
-# directory in a checkout to find one that has \`agents/\` is a cost this hook cannot
-# pay on every prompt. The shape test is still what decides; the glob now only bounds
-# where to look, and it no longer bounds it to one spelling.
-tree="\${CRATYLUS_RENDER_TREE:-}"
-if [ -z "$tree" ]; then
-	for c in \\
-		"$root"/.*/ "$root"/*/.*/ "$root"/*/*/.*/ \\
-		"$root"/.*/*/ "$root"/*/.*/*/ "$root"/*/*/.*/*/; do
-		case "$c" in
-		*/node_modules/*) continue ;;
-		*/.git/*) continue ;;
-		*/./ | */../) continue ;;
-		esac
-		c="\${c%/}"
-		[ -d "$c/agents" ] && [ -d "$c/skills" ] && [ -f "$c/$HARNESS_HOOKS_FILE" ] || continue
-		tree="$c"
-		break
-	done
-fi
-# A corpus that has rendered nothing for THIS harness has nothing to be compared
-# against — the same not-in-scope silence, one step in.
-[ -n "$tree" ] || exit 0
-
-# ── WHAT WAS THIS SESSION ALREADY TOLD? ────────────────────────────────────────
-# The re-arm's whole cost is here. Asked before every prompt, an unchanged verdict
-# repeated until the reader stopped seeing it would be the in-sync failure re-entering
-# through the door opened to fix the stale one. So one small file per session holds the
-# last verdict delivered, and the trigger is the DIFFERENCE.
-#
-# The key is \`⟨harness, session⟩\` and the CONTENT carries \`⟨corpus, tree⟩\`: two
-# harnesses in one session audit two hosts and must not overwrite each other's answer,
-# and the same session moved to another checkout is asking a different question rather
-# than repeating one. A session id that is not a plain token is treated as absent —
-# nothing here builds a path out of an unexamined payload field.
-state=""
-case "$sid" in
-'' | *[!A-Za-z0-9._-]*) ;;
-*)
-	stash="\${TMPDIR:-/tmp}/cratylus-deploy-drift"
-	if [ -d "$stash" ] || mkdir -p "$stash" 2>/dev/null; then
-		state="$stash/$HARNESS-$sid"
-	fi
-	;;
-esac
-
-# \`changed <verdict>\` — record it as the last thing this session was told, and
-# answer whether it DIFFERS from what was recorded before.
-#
-# NO STATE MEANS EVERY RUN SPEAKS, and the asymmetry is deliberate. Without a session
-# id there is nothing to suppress against, and a repeated advisory under real drift is
-# noise one \`deploy\` ends, while a suppressed one is SILENCE — which this cell spends
-# its whole contract making mean "in sync", and may therefore lend to nothing else.
-changed() {
-	now="$root|$tree|$1"
-	[ -n "$state" ] || return 0
-	last=""
-	[ ! -f "$state" ] || last="$(cat "$state" 2>/dev/null || true)"
-	printf '%s' "$now" >"$state" 2>/dev/null || true
-	[ "$last" != "$now" ]
-}
-
-# ── WHAT ASKS? the tool, never a reimplementation ──────────────────────────────
-cli="\${CRATYLUS_DEPLOY_CHECK:-}"
-if [ -z "$cli" ]; then
-	if [ -x "$root/node_modules/.bin/$DEPLOY_TOOL" ]; then
-		cli="$root/node_modules/.bin/$DEPLOY_TOOL"
-	elif command -v "$DEPLOY_TOOL" >/dev/null 2>&1; then
-		cli="$DEPLOY_TOOL"
-	fi
-fi
-if [ -z "$cli" ]; then
-	if changed "no-comparator"; then
-		printf '{{speech:no-comparator}}\\n' "$DEPLOY_TOOL"
-	fi
-	exit 0
-fi
-
-# \`--harness\` is what makes the audited HOME this session's. Without it the tool
-# resolves its default root, so an omp tree would be compared against the claude
-# deployment — a report that is about neither.
-# The tool reports and repairs nothing, so it is safe to point at a host mid-work.
-set +e
-out="$("$cli" deploy --check \\
-	--harness "$HARNESS" \\
-	--agents-dir "$tree/agents" \\
-	--skills-dir "$tree/skills" \\
-	--hooks-dir "$tree" 2>&1)"
-rc=$?
-set -e
-
-# rc 0 IS the tool's verdict that no artifact is stale and none is absent (a foreign
-# artifact is reported by it, and is not a defect). The silence is earned here, and
-# nowhere else — every other exit takes a branch below.
-#
-# IT IS RECORDED ANYWAY, and that is what makes a RETURNING drift audible: drift, then
-# a deploy, then the identical drift again would match a record that still said "drift"
-# and be swallowed. Recording the clean verdict makes the second one a change. Its own
-# result is discarded — a host that has just gone from stale to in-sync gets no all-clear
-# either, because silence-when-clean is unconditional.
-if [ "$rc" -eq 0 ]; then
-	changed in-sync || true
-	exit 0
-fi
-
-# WHICH KIND OF NON-ZERO — asked of the EXIT CODE, which is a contract, and not of
-# the report's wording, which is a format. Drift has a code of its own; everything
-# else that is not success is the check failing to produce a verdict, including the
-# codes this worker was never told about (a crash, a signal, a missing file). The
-# two demand opposite responses: relaying a broken tool as drift fabricates a
-# verdict, and relaying it as silence is the bypass-by-omission this cell exists to
-# end.
-#
-# THE REPORT IS PART OF THE VERDICT, not decoration on it. Two drifts that differ in
-# WHICH doctrine is superseded are two things to be told, so the report's bytes are what
-# the session remembers — a key of "drift" alone would announce the first stale artifact
-# and swallow every one after it.
-if [ "$rc" -eq "$DRIFT_RC" ]; then
-	if changed "drift
-$out"; then
-		printf '%s\\n' '{{speech:drift}}'
-		printf '%s\\n' "$out"
-	fi
-else
-	if changed "no-verdict $rc
-$out"; then
-		printf '{{speech:no-verdict}}\\n' "$cli"
-	fi
-fi
-exit 0
-`,
-        },
-    ],
-};
-//# sourceMappingURL=deploy-drift-notice.js.map

package/dist/hooks/deploy-drift-notice.js.map

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

package/dist/rules/repo-preamble.d.ts

@@ -1,2 +0,0 @@
-import type { RuleCell } from '@cratylus/schema';
-export declare const repoPreamble: RuleCell;

package/dist/rules/repo-preamble.js

@@ -1,49 +0,0 @@
-// repo-preamble — the FIRST `rule` corpus instance (MODEL `Kind ∋ rule`,
-// `activation: rule↦scope`). The workspace-root standing instruction (`AGENTS.md`):
-// the always-loaded orientation every session binds on entry. Retiring the
-// `AGENTS.md@node` memory-sink route (no cell routes a record to a node/plan
-// `AGENTS.md`) removed the sole blocker to treating the repo-root `AGENTS.md` as a
-// byte-locked rule TARGET — it is no longer SelfAuthored memory (`SelfAuthored ∉
-// Target` no longer applies), so it is a curated source-of-truth cell whose
-// `content` projects + byte-locks to `/AGENTS.md`.
-//
-//   residue — the σ*-signified canonical identity (`body = ⟨α, residue⟩`), the
-//             `accept()`/REFLEXIVE target. It is `residue`, NOT `definiens`: it has
-//             already paid the `∖ fired(α)` subtraction (`schema/src/rule-cell.ts`).
-//   content — the VERBATIM directive payload, regenerated to `targetPath` by
-//             `project-targets` and byte-locked by `test/hook-rule-boundary.test.ts`.
-//             `content`, NOT `body`: `body(c) = ⟨α, residue⟩` is the whole cell, and
-//             this is the sibling of `HookWorker.content` (`schema/src/rule-cell.ts`).
-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 ⟨¬say-so⟩ ; green-field ⟨constrains-only-where-declared ; ¬compatibility-goal⟩ ; library-first ⟨maintained · small-API · ¬workflow-engine ; wrapped behind a cratylus capability⟩ ; branching=git-flow dev/main ⟨¬release · ¬hotfix branches ; change-branch ← dev ; local merge → dev once the check passes on the merged result ; dev → main by PR = release ↦ operator ; ¬direct-commit@main⟩ ; the-check ⟨pnpm check = pre-push = CI ; build · lint · typecheck · deterministic tests ; deps declared ; omp version stated, ¬prerequisite⟩ ; history ⟨review ; ¬refusal⟩ ; commit-own-paths ⟨by name ; ¬amend · ¬rewrite-shared⟩⟩ ; activation=scope ⟨curated source, projected + byte-locked⟩',
-    scope: '',
-    targetPath: 'AGENTS.md',
-    refs: [],
-    content: `# AGENTS
-
-**CRITICAL INVARIANT:** You **MUST Read** these documents upon session-start:
-
-- [\`CANON.md\`](./CANON.md) — **overview and primer**
-- [\`CRATYLISM\`](./packages/canon/src/genus/prime-principle.ts) — The First Principle (**LOCKED**)
-- [\`VISION.md\`](./VISION.md) — **why** the canon exists
-- [\`MODEL.md\`](./MODEL.md) — **what** exists: conceptual objectives and acceptance criteria
-- [\`ENGINE.md\`](./ENGINE.md) — **how** primitives are discovered, validated, and projected
-- [\`ARCHITECTURE\`](./ARCHITECTURE.md) — purpose and relationship of the packages, and the seams that separate their concerns.
-
-## Working conventions
-
-- Conventional Commits, header ≤100 chars (commitlint, \`commit-msg\` hook).
-- **Commit autonomously at natural boundaries,** without asking; this overrides the generic harness default of committing only when the user asks. Pushing a branch needs no say-so.
-- **Green-field register:** existing code, records, and docs constrain work only where explicitly declared; compatibility is never a goal.
-- **Reach for an established library before writing or adopting machinery.** Where a well-known problem has an actively maintained, widely used library with a small API, use it; never adopt a workflow or orchestration engine. Wrap it behind cratylus's own capability, so agents learn one small cratylus API, not the library's.
-- **Branching: Git flow's \`dev\`/\`main\` split, without release or hotfix branches.** Each change is made on a short-lived branch from \`dev\` and merged locally into \`dev\` once \`pnpm check\` passes on the merged result. Release is a pull request from \`dev\` into \`main\`, and it is the operator's. Never commit to \`main\` directly.
-- **One check:** \`pnpm check\` builds, lints, typechecks and runs the deterministic tests, and fails when any of them fails. The \`pre-push\` hook runs it, and CI runs exactly it after checkout and \`pnpm install\`, with nothing before or after. Every dependency it needs is declared in the workspace's manifests; nothing checks what else is installed.
-- **Tests cover cratylus's own deterministic code only:** the check tests cratylus's code and the files it produces, never by starting omp, an agent or a model. Agent behaviour is judged in real use. The supported omp version is 18.10.2; the check neither needs nor starts omp, and after an omp upgrade the operator or the architect tries one real session by hand.
-- **History is controlled by review, not by refusal:** no hook, CI step or command refuses a change to existing records; the concept journal stays append-only because its verbs only append.
-- **Commit only what you changed:** stage and commit your own paths by name, never everything in the tree, and never amend or rewrite shared history.
-`,
-};
-//# sourceMappingURL=repo-preamble.js.map

package/dist/rules/repo-preamble.js.map

@@ -1 +0,0 @@
-{"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,89BAA89B;IACh+B,KAAK,EAAE,EAAE;IACT,UAAU,EAAE,WAAW;IACvB,IAAI,EAAE,EAAE;IACR,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;CAsBV;CACA,CAAC"}

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

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

package/dist/skills/introspect/skill.js

@@ -1,55 +0,0 @@
-import { primePrinciple } from '../../genus/prime-principle.js';
-export const introspect = {
-    name: 'introspect',
-    description: `use this skill when an agent needs to self-audit — compare each factor's defined values (each at its enforcement level) against the values actually in effect this session, and name the cause of every divergence.`,
-    formalBlock: `A          ≜ the agent introspecting itself
-O_text     ≜ enumerate(\`###\` factor headings @ A's live Target) ⟨READ · ¬ recalled · \`##\` ≜ a group ∴ ∉ O⟩
-O_bind     ≜ enumerate(binding factors @ \`cratylus catalog\`) ⟨never text · compiled to harness tool · dispatch · model-role settings⟩
-O          ≜ O_text ∪ O_bind ⟨∄ fixed-list ∵ corpus declares its own catalog · enforcement-level ≜ an attribute of each entry ∴ ∉ O⟩
-|O|        ≜ |O_text| + |O_bind| ⟨the DENOMINATOR⟩
-V          ≜ the entry value-space { one-entry · entry-set · one-entry-per-slot · unobservable } ⟨entry ≜ value @ level { advisory · firm · fixed }⟩
-src_def    ≜ A's in-prompt \`###\` Target factors ∪ agent/<A>.md ⟨front-matter ↦ O_bind⟩ ⟨the entries held per factor⟩
-src_rt     ≜ runtime sources observed this session { live tool/action-set · live dispatchable agents · live model · system-prompt-as-given · autonomy-mode + transient-elevation · deployed front-matter⟨color · mark⟩ · env · granted-permissions }
-addresses  : O → concept @ A's identity ⟨name · description · mark · key ≜ ∅⟩ ∪ each factor's role ⟨the concept the fragment must express⟩
-
-def        : O → V @ src_def
-rt         : O → V @ src_rt
-decode     : O → concept ≜ decode_cold(def(o)) ⟨isolated tool-less read of the declared sign · its own priors · zero project-causes⟩
-why        : div → causes
-
-harness-override    ≜ runtime substituted the value ⟨tool-gating · model-pin · env⟩
-deploy-drift        ≜ deployed def ≠ source vector ⟨stale ∨ partial deploy⟩
-profile-projection  ≜ def projected at a reader/profile that reshaped the value
-transient-elevation ≜ a session act flipped it ⟨autonomy human-in-the-loop ↦ human-on-the-loop⟩
-composer-dropped    ≜ projection dropped a facet ⟨the color/mark regression class⟩
-env-conditioned     ≜ a host/env fact changed the effective value
-unobservable        ≜ runtime value ¬ inspectable ∴ report-as-such ∧ ¬ guess
-misnomer            ≜ def faithfully in effect yet the wrong sign for its concept ⟨match(o) ∧ ¬ signifies(o) · a signification defect at def, ¬ a configuration one; the class that hides when rt conforms to a def that is itself mis-signified⟩
-K_cfg      ≜ { harness-override · deploy-drift · profile-projection · transient-elevation · composer-dropped · env-conditioned · unobservable }
-causes          ≜ K_cfg ∪ { misnomer }
-
-∀ o ∈ O : rt(o) @ src_rt
-¬ ( rt ≜ def )
-match(o)     ≜ def(o) ≅ rt(o) ⟨values ∧ their levels⟩
-signifies(o) ≜ decode(o) ≅ addresses(o)
-sound(o)     ≜ match(o) ∧ signifies(o)
-div          ≜ { o ∈ O | ¬ sound(o) }
-¬ match(o)                ⇒ why(o) ∈ K_cfg
-match(o) ∧ ¬ signifies(o) ⇒ why(o) = misnomer
-why(o)       ∈ causes , o ∈ div
-row(o)       ≜ ⟨ o, def(o), rt(o), match(o), signifies(o), why(o) ↾ o ∈ div ⟩
-summary      ≜ { ⟨ o, why(o) ⟩ | o ∈ div }
-report       ≜ ⟨ |O|, { row(o) | o ∈ O }, summary ⟩ ⟨|O| STATED⟩
-introspect(A) ≜ report
-|{ row(o) }| ≠ |O| ⇒ ⊥
-rt(o) ⊨ EXERCISED ⟨¬ inferred-from-absence⟩
-¬ exercised(o) ⇒ why(o) = unobservable ∧ why(o) ≠ harness-override
-
-¬ edit(agent/<A>.md) ∧ ¬ redeploy ∧ ¬ mint(V)
-why(o) ∈ K_cfg            ⇒ reconcile @ { create-agent · deploy }
-why(o) = misnomer         ⇒ reconcile @ signify ≺ { create-agent · deploy }
-O · causes        @ live-anatomy`,
-    composition: () => [],
-    preamble: primePrinciple,
-};
-//# sourceMappingURL=skill.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/introspect/skill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAGhE,MAAM,CAAC,MAAM,UAAU,GAAU;IAC/B,IAAI,EAAE,YAAY;IAClB,WAAW,EAAE,qNAAqN;IAClO,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCA8CqC;IAClD,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;IACrB,QAAQ,EAAE,cAAc;CACzB,CAAC"}