@cratylus/canon 0.2.0 → 0.3.0

package/dist/dimensions/autonomy/human-on-the-loop.js

@@ -4,7 +4,7 @@
 // phase-STATE, not a static value: the `⟨resting · phase-state⟩` residue declares
 // this as the RESTING / initial position (a session opens in orientation, intent
 // the operator's to set) while marking that the live position shifts —
-// `carry-on` elevates it to out-of-the-loop, held until the bound praxis
+// `carry-on` elevates it to out-of-the-loop, held until the bound plan
 // completes or an unresolvable fork re-enters on-the-loop. See skills/carry-on.
 export const humanOnTheLoop = `human-on-the-loop ⟨resting · phase-state⟩`;
 //# sourceMappingURL=human-on-the-loop.js.map

package/dist/dimensions/autonomy/human-on-the-loop.js.map

@@ -1 +1 @@
-{"version":3,"file":"human-on-the-loop.js","sourceRoot":"","sources":["../../../src/dimensions/autonomy/human-on-the-loop.ts"],"names":[],"mappings":"AAEA,4EAA4E;AAC5E,kFAAkF;AAClF,+EAA+E;AAC/E,kFAAkF;AAClF,iFAAiF;AACjF,uEAAuE;AACvE,yEAAyE;AACzE,gFAAgF;AAChF,MAAM,CAAC,MAAM,cAAc,GAAa,2CAA2C,CAAC"}
+{"version":3,"file":"human-on-the-loop.js","sourceRoot":"","sources":["../../../src/dimensions/autonomy/human-on-the-loop.ts"],"names":[],"mappings":"AAEA,4EAA4E;AAC5E,kFAAkF;AAClF,+EAA+E;AAC/E,kFAAkF;AAClF,iFAAiF;AACjF,uEAAuE;AACvE,uEAAuE;AACvE,gFAAgF;AAChF,MAAM,CAAC,MAAM,cAAc,GAAa,2CAA2C,CAAC"}

package/dist/hook-cells.js

@@ -6,8 +6,11 @@
 // (claude adapter: `turn.end` → Stop, `subagent.end` → SubagentStop) and carries
 // their VERBATIM worker payloads so the projector stages them under `hooks/<id>/`
 // (no file copy — the bytes come from the cell). Only `harness`-substrate cells
-// register in settings.json; a `git`-substrate cell (praxis-continuity) fires in
-// git's process and is byte-locked but not serialized here.
+// register in settings.json, and every surviving cell is one: the corpus's single
+// `git`-substrate cell, `praxis-continuity`, retired with the praxis plan mirror it
+// nudged about. The routing for a non-harness substrate is not hypothetical — it is
+// exercised the moment such a cell exists again — but nothing carries it today, and
+// a header claiming a live example is a claim a reader cannot check.
 //
 // The cell shapes are the schema's type kernel (`@cratylus/schema`); this
 // module is the composition root that NAMES the concrete cells and nothing more.

package/dist/hook-cells.js.map

@@ -1 +1 @@
-{"version":3,"file":"hook-cells.js","sourceRoot":"","sources":["../src/hook-cells.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,2EAA2E;AAC3E,kFAAkF;AAClF,mFAAmF;AACnF,4EAA4E;AAC5E,iFAAiF;AACjF,kFAAkF;AAClF,gFAAgF;AAChF,iFAAiF;AACjF,4DAA4D;AAC5D,EAAE;AACF,0EAA0E;AAC1E,iFAAiF;AACjF,oFAAoF;AACpF,iFAAiF;AACjF,+EAA+E;AAE/E,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AACrE,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAG9D,wFAAwF;AACxF,MAAM,CAAC,MAAM,gBAAgB,GAAwB;IACnD,eAAe;IACf,kBAAkB;IAClB,iBAAiB;CAClB,CAAC"}
+{"version":3,"file":"hook-cells.js","sourceRoot":"","sources":["../src/hook-cells.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,2EAA2E;AAC3E,kFAAkF;AAClF,mFAAmF;AACnF,4EAA4E;AAC5E,iFAAiF;AACjF,kFAAkF;AAClF,gFAAgF;AAChF,kFAAkF;AAClF,oFAAoF;AACpF,oFAAoF;AACpF,oFAAoF;AACpF,qEAAqE;AACrE,EAAE;AACF,0EAA0E;AAC1E,iFAAiF;AACjF,oFAAoF;AACpF,iFAAiF;AACjF,+EAA+E;AAE/E,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AACrE,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAG9D,wFAAwF;AACxF,MAAM,CAAC,MAAM,gBAAgB,GAAwB;IACnD,eAAe;IACf,kBAAkB;IAClB,iBAAiB;CAClB,CAAC"}

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

@@ -33,7 +33,7 @@
 // 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 a `praxis` edit that landed under a
+// an agent's own governing cell was this; so was a `plan` 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

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

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

package/dist/hooks/stance-guardrail-pre.js

@@ -46,9 +46,9 @@ export const stanceGuardrailPre = {
 #   ambiguity, a substantive intent-extracted dispatch.
 #
 # SAFETY MODEL (mirrors stance-guardrail):
-#   - OFF BY DEFAULT (git config agentfactory.stanceGuard true).
-#   - AGENT-SCOPED (agent_type in the allowlist; default: nico mav). agent_type is
-#     present only for subagents / --agent mode; a top-level session call fails open.
+#   - SCOPE-ENROLLED, exactly as its twin: a scope carrying a stance manifest is judged and
+#     every other scope is silent. No repo opt-in, no allowlist — the projection that places a
+#     persona also enrolls it, and declining the guard means declining the persona.
 #   - FAILS OPEN. Any error (no jq, judge failure, bad input) -> exit 0 (allow the call).
 #   - LOOP-SAFE. A re-entry cap: never deny an identical tool_input twice (there is no
 #     stop_hook_active analog for PreToolUse), so it can never wedge a call.
@@ -98,27 +98,22 @@ input="$(cat)"
 [ -n "$input" ] || allow
 command -v jq >/dev/null 2>&1 || allow  # no jq -> cannot parse -> fail open
 
-# --- opt-in gate (off by default) -----------------------------------------------------------
-# Per-repo, lives in .git/config, never checked in. Resolve relative to the hook's cwd.
+# The per-repo opt-in is GONE, for the reason its twin states: it asked whether a guard may run in
+# a DIRECTORY, and a stance belongs to the agent, not the checkout. \`cwd\` survives it — the worker
+# still runs where the session runs.
 cwd="$(printf '%s' "$input" | jq -r '.cwd // empty' 2>/dev/null || true)"
 [ -n "$cwd" ] && cd "$cwd" 2>/dev/null || true
-enabled="$(git config --bool agentfactory.stanceGuard 2>/dev/null || echo false)"
-[ "$enabled" = "true" ] || allow
-
-# --- agent-scope gate -----------------------------------------------------------------------
-# Only enforce for the configured agents (default: the principal-self agents).
-# agent_type is present only for a subagent / --agent tool call; absent for the top-level
-# session -> fail open (unless STANCE_GUARD_AGENTS=*), exactly like the Stop guard.
-agent_type="$(printf '%s' "$input" | jq -r '.agent_type // empty' 2>/dev/null || true)"
-allowlist="\${STANCE_GUARD_AGENTS:-$(git config agentfactory.stanceGuardAgents 2>/dev/null || echo 'nico mav')}"
-if [ "$allowlist" != "*" ]; then
-	[ -n "$agent_type" ] || allow  # cannot identify the agent -> fail open
-	in_scope=false
-	for a in $allowlist; do
-		[ "$a" = "$agent_type" ] && in_scope=true && break
-	done
-	[ "$in_scope" = true ] || allow
-fi
+
+# --- scope gate: the persona's OWN stance manifest -------------------------------------------
+# The twin of the turn-end guard's gate, and inverted for the same reason: an allowlist here was
+# a runtime self-filter over an enrollment the corpus already derives, and it had drifted the way
+# such a list always drifts. Presence of a manifest in this persona's own scope IS enrollment.
+# Absent → silence, never an error, so an unenrolled launch is untouched.
+stance_scope="$(printf '%s' "$input" | jq -r '.stance_scope // empty' 2>/dev/null || true)"
+[ -n "$stance_scope" ] || allow
+manifest="$stance_scope/stance/manifest.json"
+[ -f "$manifest" ] || allow
+agent_type="$(jq -r '.agent // empty' "$manifest" 2>/dev/null || true)"
 
 # --- extract the judged payload, branched by tool -------------------------------------------
 tool_name="$(printf '%s' "$input" | jq -r '.tool_name // empty' 2>/dev/null || true)"

package/dist/hooks/stance-guardrail-pre.js.map

@@ -1 +1 @@
-{"version":3,"file":"stance-guardrail-pre.js","sourceRoot":"","sources":["../../src/hooks/stance-guardrail-pre.ts"],"names":[],"mappings":"AAEA,sFAAsF;AACtF,mFAAmF;AACnF,uFAAuF;AACvF,SAAS;AACT,wFAAwF;AACxF,6FAA6F;AAC7F,0FAA0F;AAC1F,uFAAuF;AACvF,qEAAqE;AACrE,EAAE;AACF,wEAAwE;AACxE,sFAAsF;AACtF,iFAAiF;AACjF,mFAAmF;AACnF,sFAAsF;AACtF,qFAAqF;AACrF,sFAAsF;AACtF,sFAAsF;AACtF,mEAAmE;AACnE,2DAA2D;AAC3D,mDAAmD;AAEnD,MAAM,CAAC,MAAM,kBAAkB,GAAa;IAC1C,EAAE,EAAE,sBAAsB;IAC1B,OAAO,EACL,iWAAiW;IACnW,SAAS,EAAE,SAAS;IACpB,KAAK,EAAE,CAAC;IACR,MAAM,EAAE,CAAC,sBAAsB,EAAE,uBAAuB,CAAC;IACzD,KAAK,EAAE,yBAAyB;IAChC,OAAO,EAAE,EAAE;IACX,IAAI,EAAE,EAAE;IACR,OAAO,EAAE;QACP;YACE,QAAQ,EAAE,yBAAyB;YACnC,UAAU,EAAE,0DAA0D;YACtE,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiKd;SACI;KACF;CACF,CAAC"}
+{"version":3,"file":"stance-guardrail-pre.js","sourceRoot":"","sources":["../../src/hooks/stance-guardrail-pre.ts"],"names":[],"mappings":"AAEA,sFAAsF;AACtF,mFAAmF;AACnF,uFAAuF;AACvF,SAAS;AACT,wFAAwF;AACxF,6FAA6F;AAC7F,0FAA0F;AAC1F,uFAAuF;AACvF,qEAAqE;AACrE,EAAE;AACF,wEAAwE;AACxE,sFAAsF;AACtF,iFAAiF;AACjF,mFAAmF;AACnF,sFAAsF;AACtF,qFAAqF;AACrF,sFAAsF;AACtF,sFAAsF;AACtF,mEAAmE;AACnE,2DAA2D;AAC3D,mDAAmD;AAEnD,MAAM,CAAC,MAAM,kBAAkB,GAAa;IAC1C,EAAE,EAAE,sBAAsB;IAC1B,OAAO,EACL,iWAAiW;IACnW,SAAS,EAAE,SAAS;IACpB,KAAK,EAAE,CAAC;IACR,MAAM,EAAE,CAAC,sBAAsB,EAAE,uBAAuB,CAAC;IACzD,KAAK,EAAE,yBAAyB;IAChC,OAAO,EAAE,EAAE;IACX,IAAI,EAAE,EAAE;IACR,OAAO,EAAE;QACP;YACE,QAAQ,EAAE,yBAAyB;YACnC,UAAU,EAAE,0DAA0D;YACtE,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4Jd;SACI;KACF;CACF,CAAC"}

package/dist/hooks/stance-guardrail.js

@@ -49,8 +49,13 @@ export const stanceGuardrail = {
 #     electing the session's objective is supplying intent, not sequencing — the operator's to own
 #
 # SAFETY MODEL:
-#   - OFF BY DEFAULT. Does nothing unless the repo opts in (git config agentfactory.stanceGuard true).
-#   - AGENT-SCOPED. Only fires for agents on the allowlist (default: nico, mav — the principal-self agents).
+#   - SCOPE-ENROLLED. Fires for a scope carrying a stance manifest, and for no other. Enrollment
+#     is PRESENCE: the projection places a manifest in each persona's own scope, so composing the
+#     cell enrolls the persona and nothing central lists anybody. A bare launch carries the
+#     dispatcher and no manifest, and is therefore silent by placement.
+#   - NO REPO OPT-IN. There was one, per-repo in .git/config, and it asked the wrong question:
+#     whether a guard may run in a DIRECTORY. The off switch is launching \`omp\` rather than a
+#     persona — declining to BE the agent, instead of being it unjudged.
 #   - FAILS OPEN, BUT NEVER SILENTLY-CLEAN. Any error → exit 0 (allow stop): a guardrail that
 #     wedges work on its own flakiness is worse than a missed block. But once the guard is
 #     ENABLED and in scope, a failure that prevents judging (no transcript, judge unreachable)
@@ -85,6 +90,9 @@ JUDGE_CMD="\${STANCE_JUDGE_CMD:-sh $SELF_DIR/stance-judge.sh}"
 # a host and point outside a sandboxed deploy, which is the class of bug that put
 # \`\$HOME/.claude\` in the sibling worker and made it read another harness's tree.
 NEUTRAL_ROOT="$(dirname -- "$(dirname -- "$(dirname -- "$SELF_DIR")")")/.agents"
+# The DEFAULT rubric. A persona's own manifest may name another — that is the
+# strategy seam: one opinionated implementation, each persona free to bind a
+# different contract without the dispatcher learning anything about either.
 RUBRIC="\${STANCE_RUBRIC:-$NEUTRAL_ROOT/stance-guardrail/stance-judge-prompt.md}"
 
 # A Stop hook must never break a session. Trap any unexpected error → allow the stop.
@@ -102,6 +110,15 @@ allow_stop() { exit 0; }  # emit nothing; the agent is permitted to stop.
 # turn. Reached only AFTER the opt-in and allowlist checks, so a repo that never enabled
 # the guard stays silent.
 dark() {
+	# THE HEARTBEAT, and the reason the log is worth keeping. A VERDICT row and a
+	# DARK row are both evidence the guard RAN; only an EMPTY log means it never
+	# did. Recording judged turns alone made "not judged" and "no session" read
+	# identically — measured on a live host: an endpoint behind the advisor role
+	# accepted connections and never answered, and five hours of one session were
+	# unjudged while leaving no trace whatsoever to notice it by.
+	if [ -n "\${verdict_log:-}" ]; then
+		printf 'DARK\\t\\t%s\\n' "\$1" >> "\$verdict_log" 2>/dev/null || true
+	fi
 	printf 'STANCE GUARDRAIL — DARK: %s. This turn was NOT judged; the absence of a block is an absence of a verdict, not a clean one.\\n' "\$1"
 	exit 0
 }
@@ -138,32 +155,55 @@ verdict_log="$state_dir/$session.verdicts"
 block_count="$(cat "$count_file" 2>/dev/null || echo 0)"
 case "$block_count" in *[!0-9]*) block_count=0 ;; esac
 
-# --- opt-in gate (off by default) -----------------------------------------------------------
-# Per-repo, lives in .git/config, never checked in. A fresh clone is opted out.
-# Resolve relative to the hook's cwd (the project), which is where the flag lives.
+# The per-repo opt-in is GONE, and its absence is the point. It answered "may a guard run in this
+# DIRECTORY", which is a category error: a stance is a property of the agent, not of the checkout
+# it happens to be standing in. Worse, it made the stance OPTIONAL AT RUNTIME for an agent already
+# launched as itself — the ambient form, when the whole reason this harness half exists is that
+# identity alone erodes. The off switch is launching \`omp\` instead of \`mav\`: declining to be the
+# persona, rather than being it unjudged.
 cwd="$(printf '%s' "$input" | jq -r '.cwd // empty' 2>/dev/null || true)"
 [ -n "$cwd" ] && cd "$cwd" 2>/dev/null || true
-enabled="$(git config --bool agentfactory.stanceGuard 2>/dev/null || echo false)"
-[ "$enabled" = "true" ] || allow_stop
-
-# --- agent-scope gate -----------------------------------------------------------------------
-# Only enforce the stance for the configured agents (the principal-self agents by default).
-# agent_type identifies the agent (verified by an introspective-hook capture): it is PRESENT for an
-# --agent / @mention launch — top-level INCLUDED (a session started as @nico reports agent_type=nico)
-# — and for every SubagentStop; it is ABSENT only for a DEFAULT top-level session (plain claude, no
-# --agent). When absent we do NOT enforce: a session that never declared itself a principal should not
-# get the principal rubric. STANCE_GUARD_AGENTS=* overrides to enforce on everyone (a blunt instrument).
-agent_type="$(printf '%s' "$input" | jq -r '.agent_type // empty' 2>/dev/null || true)"
-allowlist="\${STANCE_GUARD_AGENTS:-$(git config agentfactory.stanceGuardAgents 2>/dev/null || echo 'nico mav')}"
-
-if [ "$allowlist" != "*" ]; then
-	[ -n "$agent_type" ] || allow_stop  # cannot identify the agent → fail open
-	in_scope=false
-	for a in $allowlist; do
-		[ "$a" = "$agent_type" ] && in_scope=true && break
-	done
-	[ "$in_scope" = true ] || allow_stop
-fi
+
+# --- scope gate: the persona's OWN stance manifest -------------------------------------------
+# COMPOSITION IS THE SCOPE, NOT A RUNTIME SELF-FILTER — MODEL.md's ENFORCED clause, and this
+# gate used to violate it outright. It read an allowlist, \`nico mav\` by default and overridable
+# by \`STANCE_GUARD_AGENTS\`, which is precisely the runtime self-filter that clause forbids: a
+# module asking WHO IS RUNNING rather than being placed where only the right launch reaches it.
+#
+# It had already drifted, in the direction such a list always drifts. Every agent in the corpus
+# composes \`handoff\`, so \`Binding.agents\` DERIVES all six as bound, and six persona scopes are
+# deployed to prove it — while the list enforced two. \`architect\` and \`kino\` held principal
+# authority and were never once judged, and nothing surfaced the gap because the two facts were
+# written in different languages in different files.
+#
+# Enrollment is now PRESENCE. Each bound persona's projection lands a manifest in that persona's
+# own scope, and the dispatcher — which lives in that same scope and therefore already knows it
+# — passes it in the envelope. A manifest means enrolled, and carries THIS agent's contract: its
+# rubric, its moments, its handoff laws. No manifest means not enrolled, which is silence rather
+# than an error, so a plain session that never declared itself anything stays untouched exactly
+# as it was. Adding a persona enrolls it; adding a gated dimension edits one persona's manifest;
+# neither is a line in this file.
+stance_scope="$(printf '%s' "$input" | jq -r '.stance_scope // empty' 2>/dev/null || true)"
+[ -n "$stance_scope" ] || allow_stop
+manifest="$stance_scope/stance/manifest.json"
+[ -f "$manifest" ] || allow_stop
+
+# The persona's own contract, each field falling back to the shipped default. A manifest that
+# names nothing still enrolls: presence is the assertion, the fields are the refinement.
+agent_type="$(jq -r '.agent // empty' "$manifest" 2>/dev/null || true)"
+manifest_rubric="$(jq -r '.rubric // empty' "$manifest" 2>/dev/null || true)"
+# An OVERRIDE that does not resolve is a defect and goes DARK — a persona that asked to be judged
+# against its own contract and is silently judged against someone else's has been mis-scored, not
+# spared. The DEFAULT is not checked here: a judge backend need not read the file at all (the
+# fixture judge does not), and refusing to run because a path the manifest never named is absent
+# would fail closed on a case the manifest made no claim about.
+case "$manifest_rubric" in
+	'') ;;
+	/*) RUBRIC="$manifest_rubric" ;;
+	*) RUBRIC="$stance_scope/stance/$manifest_rubric" ;;
+esac
+[ -z "$manifest_rubric" ] || [ -f "$RUBRIC" ] || \\
+	dark "the rubric named by $manifest is not readable at '\$RUBRIC'"
 
 # --- extract the last assistant turn from the transcript ------------------------------------
 transcript="$(printf '%s' "$input" | jq -r '.transcript_path // empty' 2>/dev/null || true)"
@@ -500,7 +540,24 @@ if [ -n "$evidence" ] && [ "\${#evidence}" -ge 12 ]; then
 # 3/5 on identical payloads — i.e. the record of WHY a turn was blocked was reconstructible only
 # by a non-deterministic process. Appended, never rotated by this hook; the state dir is tmp.
 printf '%s\\t%s\\t%s\\n' "$decision" "$evidence" "$reason" >> "$verdict_log" 2>/dev/null || true
-	if ! printf '%s' "$asst_close" | tr '\\n' ' ' | grep -qF "$evidence"; then
+	# NORMALIZED ON BOTH SIDES, and with \`--\`, because this check had two ways to
+	# throw away a correct block — and both of them fired on the SAME shape, which is
+	# the one shape this guard most exists to catch.
+	#
+	# 1. \`grep -qF "$evidence"\` with no \`--\`: an evidence span opening with a markdown
+	#    bullet is read as an OPTION. \`grep: invalid option -- ' '\`, non-zero, block
+	#    discarded. A tail-enumeration collapse IS a bullet list, so its evidence always
+	#    begins \`- \`, and the rule could never convict the shape it was written for.
+	# 2. A judge quoting several bullets joins them with spaces and drops the markers,
+	#    so a verbatim-substring test fails on punctuation while every word is present.
+	#
+	# The proposition worth authenticating is that the judge quoted THIS TURN'S WORDS,
+	# not that it reproduced its list syntax. So both sides are flattened the same way:
+	# newlines to spaces, runs of whitespace to one, list markers dropped. Symmetric, so
+	# nothing is accepted on one side that would be rejected on the other.
+	ev_norm="$(printf '%s' "$evidence" | tr '\\n' ' ' | sed -e 's/[[:space:]][[:space:]]*/ /g' -e 's/^[-*][[:space:]]//' -e 's/ [-*] / /g')"
+	close_norm="$(printf '%s' "$asst_close" | tr '\\n' ' ' | sed -e 's/[[:space:]][[:space:]]*/ /g' -e 's/^[-*][[:space:]]//' -e 's/ [-*] / /g')"
+	if ! printf '%s' "$close_norm" | grep -qF -- "$ev_norm"; then
 		printf 'stance-guardrail: DISCARDING block — judge quoted a span that is not in the turn'"'"'s CLOSE (mid-turn preamble, or confabulated): %s\\n' "$evidence" >&2
 		allow_stop
 	fi

package/dist/hooks/stance-guardrail.js.map

@@ -1 +1 @@
-{"version":3,"file":"stance-guardrail.js","sourceRoot":"","sources":["../../src/hooks/stance-guardrail.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,mCAAmC,CAAC;AAG5D,wEAAwE;AACxE,8EAA8E;AAC9E,2EAA2E;AAC3E,2EAA2E;AAC3E,8EAA8E;AAC9E,gFAAgF;AAEhF,MAAM,CAAC,MAAM,eAAe,GAAa;IACvC,EAAE,EAAE,kBAAkB;IACtB,OAAO,EACL,8UAA8U;IAChV,SAAS,EAAE,SAAS;IACpB,KAAK,EAAE,CAAC;IACR,MAAM,EAAE,CAAC,UAAU,EAAE,cAAc,CAAC;IACpC,KAAK,EAAE,qBAAqB;IAC5B,OAAO,EAAE,EAAE;IACX,IAAI,EAAE,EAAE;IACR,OAAO,EAAE;QACP;YACE,QAAQ,EAAE,qBAAqB;YAC/B,UAAU,EAAE,sDAAsD;YAClE,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+jBd;SACI;QACD;YACE,QAAQ,EAAE,iBAAiB;YAC3B,UAAU,EAAE,kDAAkD;YAC9D,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmFd;SACI;QACD;YACE,QAAQ,EAAE,wBAAwB;YAClC,UAAU,EAAE,yDAAyD;YACrE,UAAU,EAAE,KAAK;YACjB,yEAAyE;YACzE,sEAAsE;YACtE,0EAA0E;YAC1E,2EAA2E;YAC3E,yEAAyE;YACzE,yEAAyE;YACzE,MAAM,EAAE,IAAI;YACZ,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAsNX,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyLV;SACI;KACF;CACF,CAAC"}
+{"version":3,"file":"stance-guardrail.js","sourceRoot":"","sources":["../../src/hooks/stance-guardrail.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,mCAAmC,CAAC;AAG5D,wEAAwE;AACxE,8EAA8E;AAC9E,2EAA2E;AAC3E,2EAA2E;AAC3E,8EAA8E;AAC9E,gFAAgF;AAEhF,MAAM,CAAC,MAAM,eAAe,GAAa;IACvC,EAAE,EAAE,kBAAkB;IACtB,OAAO,EACL,8UAA8U;IAChV,SAAS,EAAE,SAAS;IACpB,KAAK,EAAE,CAAC;IACR,MAAM,EAAE,CAAC,UAAU,EAAE,cAAc,CAAC;IACpC,KAAK,EAAE,qBAAqB;IAC5B,OAAO,EAAE,EAAE;IACX,IAAI,EAAE,EAAE;IACR,OAAO,EAAE;QACP;YACE,QAAQ,EAAE,qBAAqB;YAC/B,UAAU,EAAE,sDAAsD;YAClE,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwnBd;SACI;QACD;YACE,QAAQ,EAAE,iBAAiB;YAC3B,UAAU,EAAE,kDAAkD;YAC9D,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmFd;SACI;QACD;YACE,QAAQ,EAAE,wBAAwB;YAClC,UAAU,EAAE,yDAAyD;YACrE,UAAU,EAAE,KAAK;YACjB,yEAAyE;YACzE,sEAAsE;YACtE,0EAA0E;YAC1E,2EAA2E;YAC3E,yEAAyE;YACzE,yEAAyE;YACzE,MAAM,EAAE,IAAI;YACZ,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAsNX,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyLV;SACI;KACF;CACF,CAAC"}

package/dist/plan-states.d.ts

@@ -1,14 +1,14 @@
 /** The plan-layout state folders, in task-file lifecycle order. */
 export declare const PLAN_STATES: readonly ["pending", "ready", "active", "completed"];
 /** `frontier(P)` — the states a shard sits in when the plan is workable AT it
- *  (praxis: `{ t | state(t) ∈ { ready, active } }`, where the plan IS, not merely
+ *  (`{ t | state(t) ∈ { ready, active } }`, where the plan IS, not merely
  *  what is dispatchable). A subset of {@link PLAN_STATES} and not derivable from
  *  their ORDER: `pending` is open too, and is not frontier. */
 export declare const PLAN_FRONTIER: readonly ["ready", "active"];
 /**
  * The plan-tier dotfile MARKERS whose only home is here.
  *
- * A relation with no on-disk carrier is not readable — the reading `praxis.sh`
+ * A relation with no on-disk carrier is not readable — the reading `plan-set.sh`
  * states in its own words when it explains why `.landed` exists ("exactly parallel
  * to `.superseded-by`"). These are the two markers a reader of the plan set needs
  * that have no other TypeScript home: `.superseded-by` already has one
@@ -16,7 +16,7 @@ export declare const PLAN_FRONTIER: readonly ["ready", "active"];
  *
  * `.ruling-owed` is the third carrier this corpus has minted on that reading, and
  * it carries the concept the corpus ALREADY signifies as a ruling owed — "a
- * decision nobody has taken", which the `praxis` cell distinguishes from a
+ * decision nobody has taken", which the retired praxis cell distinguished from a
  * dependency ("a dep waits itself out, a ruling needs a human"). At the SHARD tier
  * that concept is `ruling-owed(t)`, and it gates `ready`; at the
  * PLAN tier it had no carrier at all, so a fork the principal cannot resolve —

package/dist/plan-states.js

@@ -12,7 +12,7 @@
 /** The plan-layout state folders, in task-file lifecycle order. */
 export const PLAN_STATES = ['pending', 'ready', 'active', 'completed'];
 /** `frontier(P)` — the states a shard sits in when the plan is workable AT it
- *  (praxis: `{ t | state(t) ∈ { ready, active } }`, where the plan IS, not merely
+ *  (`{ t | state(t) ∈ { ready, active } }`, where the plan IS, not merely
  *  what is dispatchable). A subset of {@link PLAN_STATES} and not derivable from
  *  their ORDER: `pending` is open too, and is not frontier. */
 export const PLAN_FRONTIER = [
@@ -22,7 +22,7 @@ export const PLAN_FRONTIER = [
 /**
  * The plan-tier dotfile MARKERS whose only home is here.
  *
- * A relation with no on-disk carrier is not readable — the reading `praxis.sh`
+ * A relation with no on-disk carrier is not readable — the reading `plan-set.sh`
  * states in its own words when it explains why `.landed` exists ("exactly parallel
  * to `.superseded-by`"). These are the two markers a reader of the plan set needs
  * that have no other TypeScript home: `.superseded-by` already has one
@@ -30,7 +30,7 @@ export const PLAN_FRONTIER = [
  *
  * `.ruling-owed` is the third carrier this corpus has minted on that reading, and
  * it carries the concept the corpus ALREADY signifies as a ruling owed — "a
- * decision nobody has taken", which the `praxis` cell distinguishes from a
+ * decision nobody has taken", which the retired praxis cell distinguished from a
  * dependency ("a dep waits itself out, a ruling needs a human"). At the SHARD tier
  * that concept is `ruling-owed(t)`, and it gates `ready`; at the
  * PLAN tier it had no carrier at all, so a fork the principal cannot resolve —

package/dist/skills/carry-on/skill.js

@@ -8,8 +8,8 @@
 // plan. "Carry on with what we just discussed" is the same utterance doing the same
 // work over a discussion, and a cell bound to `praxis` cannot serve it.
 //
-// The COMPOSITION is the operator's, at the utterance: "carry on with the praxis
-// execution" is carry-on ∘ praxis, and the pairing lives in what was said, not in
+// The COMPOSITION is the operator's, at the utterance: "carry on with the plan
+// execution" is carry-on ∘ plan, and the pairing lives in what was said, not in
 // this module's import list. A cell that names one context forecloses the rest.
 //
 // THE MECHANISM WENT WITH THE COUPLING, and that is a real loss recorded rather than

package/dist/skills/carry-on/skill.js.map

@@ -1 +1 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/carry-on/skill.ts"],"names":[],"mappings":"AAEA,mEAAmE;AACnE,EAAE;AACF,6EAA6E;AAC7E,oFAAoF;AACpF,kFAAkF;AAClF,qFAAqF;AACrF,mFAAmF;AACnF,oFAAoF;AACpF,wEAAwE;AACxE,EAAE;AACF,iFAAiF;AACjF,kFAAkF;AAClF,gFAAgF;AAChF,EAAE;AACF,qFAAqF;AACrF,qFAAqF;AACrF,kFAAkF;AAClF,sFAAsF;AACtF,kFAAkF;AAClF,oFAAoF;AACpF,mFAAmF;AACnF,2CAA2C;AAE3C,MAAM,eAAe,GACnB;;;;;;;;;;;;;;;;;;;;;CAqBkB,CAAC;AAErB,MAAM,CAAC,MAAM,OAAO,GAAU;IAC5B,IAAI,EAAE,UAAU;IAChB,WAAW,EAAE,woBAAwoB;IACrpB,WAAW,EAAE,eAAe;IAC5B,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;CACtB,CAAC"}
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/carry-on/skill.ts"],"names":[],"mappings":"AAEA,mEAAmE;AACnE,EAAE;AACF,6EAA6E;AAC7E,oFAAoF;AACpF,kFAAkF;AAClF,qFAAqF;AACrF,mFAAmF;AACnF,oFAAoF;AACpF,wEAAwE;AACxE,EAAE;AACF,+EAA+E;AAC/E,gFAAgF;AAChF,gFAAgF;AAChF,EAAE;AACF,qFAAqF;AACrF,qFAAqF;AACrF,kFAAkF;AAClF,sFAAsF;AACtF,kFAAkF;AAClF,oFAAoF;AACpF,mFAAmF;AACnF,2CAA2C;AAE3C,MAAM,eAAe,GACnB;;;;;;;;;;;;;;;;;;;;;CAqBkB,CAAC;AAErB,MAAM,CAAC,MAAM,OAAO,GAAU;IAC5B,IAAI,EAAE,UAAU;IAChB,WAAW,EAAE,woBAAwoB;IACrpB,WAAW,EAAE,eAAe;IAC5B,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;CACtB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cratylus/canon",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "The canonical corpus of discovered optimal-signifiers — agents, skills, dimensions and rules as typed TS source. Markdown is a projection of these modules.",
   "license": "MIT",
   "engines": {
@@ -21,7 +21,7 @@
     "@cratylus/schema": "0.2.0"
   },
   "devDependencies": {
-    "@cratylus/forge": "0.5.0",
+    "@cratylus/forge": "0.6.0",
     "@cratylus/runtime": "0.2.0",
     "@cratylus/tooling": "0.0.0",
     "@types/node": "^22.0.0",
@@ -55,13 +55,10 @@
   "scripts": {
     "build": "pnpm run clean && tsc -p tsconfig.build.json",
     "clean": "rm -rf dist",
-    "continuity": "sh targets/continuity/continuity-hook.sh",
     "dev": "tsc -p tsconfig.build.json --watch --preserveWatchOutput",
-    "oracle": "sh tooling/render-oracle/render-oracle.sh check",
-    "oracle:update": "sh tooling/render-oracle/render-oracle.sh update",
     "pack:smoke": "tsx tooling/pack-smoke/pack-smoke-cli.ts",
     "plan-set": "tsx tooling/plan-set-cli.ts",
-    "praxis": "sh tooling/praxis/praxis.sh",
+    "plan": "sh tooling/plan-set/plan-set.sh",
     "project:targets": "tsx tooling/project-targets-cli.ts",
     "scaffold": "tsx tooling/scaffold-cli.ts",
     "stance-guard:test": "sh test/support/guardrail/test-stance-guardrail.sh",

package/dist/hooks/praxis-continuity.d.ts

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

package/dist/hooks/praxis-continuity.js

@@ -1,132 +0,0 @@
-// praxis-continuity — the repo-level post-commit reminder. A scope-activated source
-// cell on the GIT substrate: `vcs.commit.post` is an ordinary member of this
-// corpus's `CANONICAL_EVENTS` carrying `substrate: 'git'`, so it is routed rather
-// than refused — the `.husky/post-commit` dispatcher runs the committed worker
-// directly and nothing reaches `settings.json`. Its `workers[].content` are the
-// byte-anchors the committed `targets/continuity/` workers regenerate from
-// (byte-locked).
-//
-// THE REVIEW THIS CELL WAS FLAGGED FOR IS CLOSED. The note read "not in FORGE's
-// `CanonicalEvent` taxonomy" — stale by one package before it was stale by two, and
-// it asked for either an addition to the taxonomy or a named exception. Neither was
-// owed: the event was never exceptional, only unliterable, because the taxonomy was
-// a closed union in `schema` that a git moment had no member to be. The vocabulary
-// now lives where signification lives, `EventName` is open, and this cell names its
-// moment exactly as a harness cell names its own.
-export const praxisContinuity = {
-    id: 'praxis-continuity',
-    residue: 'post-commit detector ⟨task-file crosses state-folder ⇒ plan-mirror stale⟩ · nudge re-mirror · ¬edit · opt-in ↾ clone · exit-0 ⟨reminder ¬fail-commit⟩',
-    substrate: 'git',
-    events: ['vcs.commit.post'],
-    // git substrate: the entry is still named, never spelled as a path. Which
-    // directory git invokes it from is git's projection to make, not this cell's.
-    entry: 'praxis-advance-nudge.sh',
-    refs: [],
-    workers: [
-        {
-            filename: 'continuity-hook.sh',
-            targetPath: 'packages/canon/targets/continuity/continuity-hook.sh',
-            executable: true,
-            content: `#!/usr/bin/env sh
-# continuity-hook — opt this repo in/out of the post-commit continuity ritual.
-#
-# The opt-in flag is a per-repo git config (agentfactory.continuity) living in .git/config,
-# which is NOT checked in — so opting in is local to your clone and a fresh clone is
-# opted out by default. The .husky/post-commit dispatcher reads this flag.
-#
-#   pnpm run continuity:install     → set agentfactory.continuity true
-#   pnpm run continuity:uninstall   → unset (back to default off)
-#   pnpm run continuity:status      → show current state
-#
-# Usage:  continuity-hook.sh {install|uninstall|status}
-
-set -e
-
-cmd="\${1:-status}"
-
-case "$cmd" in
-install | on | true)
-	git config --bool agentfactory.continuity true
-	printf 'continuity: ENABLED for this repo (agentfactory.continuity=true).\\n'
-	printf '  Commits touching plans/**/{pending,ready,active,completed}/ now print a /praxis re-mirror reminder.\\n'
-	;;
-uninstall | off | false)
-	git config --unset agentfactory.continuity 2>/dev/null || true
-	printf 'continuity: DISABLED for this repo (agentfactory.continuity unset → default off).\\n'
-	;;
-status)
-	state=$(git config --bool agentfactory.continuity 2>/dev/null || echo "false")
-	printf 'continuity: %s (agentfactory.continuity=%s)\\n' \\
-		"$([ "$state" = "true" ] && echo ENABLED || echo "disabled (default)")" "$state"
-	;;
-*)
-	printf 'usage: continuity-hook.sh {install|uninstall|status}\\n' >&2
-	exit 2
-	;;
-esac
-`,
-        },
-        {
-            filename: 'praxis-advance-nudge.sh',
-            targetPath: 'packages/canon/targets/continuity/praxis-advance-nudge.sh',
-            executable: true,
-            content: `#!/usr/bin/env sh
-# praxis-advance-nudge — the repo-level continuity ritual, as a post-commit reminder.
-#
-# WHAT IT DOES (and deliberately does NOT do):
-#   When a commit moves plan task-files between their state folders
-#   (plans/**/{pending,ready,active,completed}/), PLAN.md — the hand-authored
-#   mirror of that folder-state — may now be stale. This script DETECTS that and
-#   PRINTS A REMINDER to re-mirror via /praxis. It never edits PLAN.md: the mirror
-#   is hand-authored prose; auto-rewriting it is out of scope (a future "mechanized
-#   PLAN.md generation" task). Detect → remind, never edit. (doc-mirrors-runtime-truth:
-#   the folders are the truth; this only flags that the mirror lagged.)
-#
-# SCOPE: praxis-advance is the ONE repo-level continuity ritual. Per-agent memory
-#   operations (the \`memory\` runtime capability's sidecar state under
-#   ~/.claude/agents/<name>/*) are not repo state — a git hook can't meaningfully
-#   fire them — so they are out of this hook's scope.
-#
-# OPT-IN: this runs only when \`git config --bool agentfactory.continuity\` is true. A fresh
-#   clone is opted out, so default commit behavior is unchanged. See continuity-hook.sh.
-#
-# POSIX sh; no deps beyond git. Exits 0 always — a reminder must never fail a commit.
-
-set -e
-
-# The commit just made (post-commit runs after HEAD has advanced).
-git rev-parse HEAD >/dev/null 2>&1 || exit 0
-
-# Files changed by HEAD. For a root commit (no parent) diff against the root.
-if git rev-parse --verify --quiet HEAD^ >/dev/null 2>&1; then
-	changed=$(git diff-tree --no-commit-id --name-only -r HEAD 2>/dev/null) || exit 0
-else
-	changed=$(git diff-tree --no-commit-id --name-only -r --root HEAD 2>/dev/null) || exit 0
-fi
-
-# Did this commit touch any plan state-folder? Match the four canonical states under
-# any plans/ subtree (works whether or not a tasks/ or {concern} wrapper is present).
-touched=$(printf '%s\\n' "$changed" \\
-	| grep -E '^plans/.*/(pending|ready|active|completed)/' || true)
-
-[ -z "$touched" ] && exit 0
-
-# Which plan dirs were touched (dedup to the plan root: plans/<plan>/).
-plans=$(printf '%s\\n' "$touched" \\
-	| sed -E 's#^(plans/[^/]+)/.*#\\1#' | sort -u)
-
-printf '\\n'
-printf 'continuity · praxis-advance — plan state changed in this commit:\\n'
-printf '%s\\n' "$plans" | sed 's/^/    /'
-printf '\\n'
-printf '  PLAN.md mirrors the task-folder state; it may now be stale.\\n'
-printf '  Re-mirror with /praxis (advance the task, re-sync PLAN.md), then amend or follow-up commit.\\n'
-printf '  (This is a reminder only — nothing was edited. Disable: pnpm run continuity:uninstall)\\n'
-printf '\\n'
-
-exit 0
-`,
-        },
-    ],
-};
-//# sourceMappingURL=praxis-continuity.js.map

package/dist/hooks/praxis-continuity.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"praxis-continuity.js","sourceRoot":"","sources":["../../src/hooks/praxis-continuity.ts"],"names":[],"mappings":"AAEA,oFAAoF;AACpF,6EAA6E;AAC7E,kFAAkF;AAClF,+EAA+E;AAC/E,gFAAgF;AAChF,2EAA2E;AAC3E,iBAAiB;AACjB,EAAE;AACF,gFAAgF;AAChF,oFAAoF;AACpF,oFAAoF;AACpF,oFAAoF;AACpF,mFAAmF;AACnF,oFAAoF;AACpF,kDAAkD;AAElD,MAAM,CAAC,MAAM,gBAAgB,GAAa;IACxC,EAAE,EAAE,mBAAmB;IACvB,OAAO,EACL,uJAAuJ;IACzJ,SAAS,EAAE,KAAK;IAChB,MAAM,EAAE,CAAC,iBAAiB,CAAC;IAC3B,0EAA0E;IAC1E,8EAA8E;IAC9E,KAAK,EAAE,yBAAyB;IAChC,IAAI,EAAE,EAAE;IACR,OAAO,EAAE;QACP;YACE,QAAQ,EAAE,oBAAoB;YAC9B,UAAU,EAAE,sDAAsD;YAClE,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCd;SACI;QACD;YACE,QAAQ,EAAE,yBAAyB;YACnC,UAAU,EAAE,2DAA2D;YACvE,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuDd;SACI;KACF;CACF,CAAC"}