@cratylus/canon 0.3.0 → 0.4.0

package/dist/hooks/purview-guardrail.js

@@ -0,0 +1,302 @@
+// purview-guardrail — the gate that makes a ROLE CONTRACT scoreable.
+//
+// A role value now states the arrow the position is over the ladder
+// `intent ≺ C ≺ spec ≺ artifact`, and an act whose domain or codomain falls outside
+// that arrow is delegated NECESSARILY. Declared, that is a steer. This cell is the
+// bound: it refuses, before the call fires, an act the holder's own contract puts
+// outside its arrow.
+//
+// WHY A SECOND CELL RATHER THAN A SECOND RUBRIC LEG. One gate, one contract. The
+// stance guard judges `autonomy` — whether the agent collapsed into order-taking — and
+// this one judges `role`. They score different declarations, at different moments, and
+// `gates` in the stance manifest is keyed by OWNING CELL precisely so a second guarded
+// dimension is a second entry rather than an append to somebody else's prompt. The
+// judge BACKEND is shared, exactly as the pre-hook shares it: one judge, two contracts.
+//
+// IT QUOTES THE AGENT'S OWN PROJECTED CONTRACT, and that is the design decision worth
+// stating. The rubric carries no role text and names no agent. The worker reads the
+// `## Role` section out of the persona's own deployed Target and hands it to the judge
+// as the law to score against, so the gate scores WHAT THE CORPUS DECLARES rather than
+// an author's opinion about good behaviour — and a corpus that mints a sixth role gets
+// it judged with no edit here. This is the lesson the stance guard learned the
+// expensive way: its allowlist drifted and left `architect` and `kino` unjudged while
+// every agent in the corpus composed the fragment it claimed to enforce.
+//
+// WHAT IT BLOCKS is what the arrow excludes, and nothing else:
+//   · a dispatch to a builder for a piece no planner decomposed, from a holder whose
+//     arrow does not write spec — the architect skipping the middle rung;
+//   · a write to the substrate by a holder whose arrow does not write artifact;
+//   · a dispatch whose prompt is the operator's literal words rather than a cut piece
+//     — the same dispatch-echo the stance guard catches at turn end, refused here
+//     because at this moment the contract that convicts it is the ROLE's.
+// WHAT IT PASSES: a dispatch to a planner, a dispatch to an assayer, READING anything,
+// and writing whatever the arrow reserves. Reading is never a block — the architect's
+// contract makes an artifact read a descent, but a read is cheap to undo and a gate
+// that fires on one would wedge every legitimate orientation.
+//
+// FAIL-OPEN, EVIDENCE-CHECKED, RE-ENTRY-CAPPED — all three inherited from the sibling
+// pre-hook, which is also the structural model for the worker. A block whose cited span
+// is not literally in the payload is DISCARDED: a fabricated block is not a lesser
+// error than a missed one.
+export const purviewGuardrail = {
+    id: 'purview-guardrail',
+    residue: 'structural-refusal ↾ mid-turn act ∉ role-arrow · deny-before-fire ⟨descent ⟨write(artifact) ∉ writes⟩ · skipped-rung ⟨dispatch(build) ∄ decomposition⟩ · dispatch-echo ⟨literal-words ≠ cut-piece⟩⟩ · pass ⟨read · act ∈ reserves · dispatch ↦ plan ∨ assay⟩ · law = the HOLDER-projected role-section ⟨quoted verbatim · ¬ authored-opinion⟩ · shared judge-backend ⟨sibling⟩ · fail-open ∧ evidence-checked ∧ re-entry-capped',
+    substrate: 'harness',
+    order: 1,
+    events: ['subagent.dispatch.pre', 'tool.use.pre'],
+    entry: 'purview-guardrail.sh',
+    timeout: 60,
+    refs: [],
+    workers: [
+        {
+            filename: 'purview-guardrail.sh',
+            targetPath: 'packages/canon/targets/guardrail/purview-guardrail.sh',
+            executable: true,
+            content: `#!/usr/bin/env sh
+# purview-guardrail — a PreToolUse hook that STRUCTURALLY REFUSES, before the call
+# fires, a mid-turn act that falls outside the arrow the agent's OWN role contract
+# declares.
+#
+# THE LAW IS NOT IN THIS FILE AND NOT IN THE RUBRIC. It is the \`## Role\` section of
+# the persona's deployed Target, read at run time and handed to the judge as the
+# contract to score against. No role text, no agent name and no behavioural opinion is
+# hard-coded anywhere in this gate.
+#
+# SAFETY MODEL (mirrors both siblings):
+#   - SCOPE-ENROLLED by PRESENCE. A persona carrying a stance manifest is judged; every
+#     other scope is silent. No allowlist — the projection that places a persona enrolls
+#     it, and nothing central lists anybody.
+#   - CONTRACT-ENROLLED, one step further. A persona whose Target carries no \`## Role\`
+#     section has no arrow to be outside of, so it is allowed. A gate cannot convict
+#     against a law that was never declared.
+#   - FAILS OPEN. Any error (no jq, no Target, judge failure) -> exit 0.
+#   - EVIDENCE-CHECKED. A BLOCK must quote a span that is literally present in the
+#     payload; a citation that is not there is a fabricated block and is DISCARDED.
+#   - LOOP-SAFE. A re-entry cap: never deny an identical tool_input twice.
+#
+# INPUT  : Claude Code PreToolUse hook JSON on stdin.
+# OUTPUT : on a purview breach -> a deny decision on stdout + exit 0.
+#          otherwise -> no stdout + exit 0.
+#
+# POSIX sh. Depends on: jq. Missing jq -> fail open.
+
+set -eu
+
+# The sibling Stop hook's deployed dir owns the SHARED judge backend, resolved from
+# this script's own location exactly as the pre-hook resolves it — every hooks root
+# holds the hook dirs as siblings, so this derivation is true at every site this file
+# can land.
+SELF_DIR="$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)"
+HOOKS_ROOT="$(dirname -- "$SELF_DIR")"
+JUDGE_DIR="\${STANCE_GUARD_DIR:-$HOOKS_ROOT/stance-guardrail}"
+NEUTRAL_ROOT="$(dirname -- "$(dirname -- "$HOOKS_ROOT")")/.agents"
+RUBRIC="\${PURVIEW_RUBRIC:-$NEUTRAL_ROOT/purview-guardrail/purview-judge-prompt.md}"
+JUDGE_CMD="\${STANCE_JUDGE_CMD:-sh $JUDGE_DIR/stance-judge.sh}"
+LOG="\${PURVIEW_GUARD_LOG:-$SELF_DIR/misses.log}"
+
+trap 'exit 0' EXIT
+
+allow() { exit 0; }
+note() { printf '%s\\n' "$1" >> "$LOG" 2>/dev/null || true; }
+
+input="$(cat)"
+[ -n "$input" ] || allow
+command -v jq >/dev/null 2>&1 || allow
+
+cwd="$(printf '%s' "$input" | jq -r '.cwd // empty' 2>/dev/null || true)"
+[ -n "$cwd" ] && cd "$cwd" 2>/dev/null || true
+
+# --- scope gate: the persona's OWN stance manifest -------------------------------------------
+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)"
+[ -n "$agent_type" ] || allow
+
+# --- the LAW: this persona's own projected role contract -------------------------------------
+# A persona scope is \`<root>/agent/personas/<name>\` and the Target it was projected
+# from is \`<root>/agent/agents/<name>.md\` — two levels out and back down, the same
+# shape of derivation the judge path above uses. Overridable for test rigs.
+AGENT_ROOT="$(dirname -- "$(dirname -- "$stance_scope")")"
+AGENT_MD="\${PURVIEW_AGENT_MD:-$AGENT_ROOT/agents/$agent_type.md}"
+[ -f "$AGENT_MD" ] || allow
+contract="$(awk '/^## Role$/{f=1;next} /^## /{f=0} f' "$AGENT_MD" 2>/dev/null || true)"
+# A contract that is a BARE TOKEN states no arrow, so there is nothing to be outside
+# of. Only a multi-line contract is scoreable, and saying so here is what keeps the
+# gate from inventing a law for a corpus that has not declared one.
+[ "$(printf '%s\\n' "$contract" | grep -c '[^[:space:]]')" -ge 2 ] || allow
+
+# --- extract the judged payload, branched by act ---------------------------------------------
+tool_name="$(printf '%s' "$input" | jq -r '.tool_name // empty' 2>/dev/null || true)"
+[ -n "$tool_name" ] || allow
+
+case "$tool_name" in
+	Agent|SendMessage|Task)
+		body="$(printf '%s' "$input" | jq -r '.tool_input.prompt // .tool_input.message // .tool_input.description // ""' 2>/dev/null || true)"
+		target="$(printf '%s' "$input" | jq -r '.tool_input.subagent_type // .tool_input.agent // .tool_input.name // ""' 2>/dev/null || true)"
+		act="DISPATCH to \\\`\${target:-unnamed}\\\` (codomain: the spec this delegate will build from)"
+		;;
+	Write|Edit|MultiEdit|NotebookEdit)
+		body="$(printf '%s' "$input" | jq -r '.tool_input.file_path // .tool_input.path // .tool_input.notebook_path // ""' 2>/dev/null || true)"
+		act="WRITE to the substrate (codomain: artifact)"
+		;;
+	*)
+		# DEFENCE IN DEPTH. \`tool.use.pre\` fires on every tool on a harness with no
+		# subject selector; these two classes are the only acts this contract can
+		# convict, and a read is deliberately not one of them.
+		allow ;;
+esac
+
+[ -n "\${body:-}" ] || allow
+
+payload="=== THE HOLDER'S DECLARED CONTRACT (agent: $agent_type) ===
+$contract
+=== THE ACT ABOUT TO FIRE ===
+$act
+$body"
+
+# --- loop-safety: never deny an identical tool_input twice ----------------------------------
+session_id="$(printf '%s' "$input" | jq -r '.session_id // "nosession"' 2>/dev/null || echo nosession)"
+sig="$(printf '%s' "$input" | jq -c '.tool_input' 2>/dev/null | cksum | cut -d' ' -f1 2>/dev/null || echo 0)"
+seen="\${TMPDIR:-/tmp}/.purview-pre-$session_id-$sig"
+[ -f "$seen" ] && allow
+
+# --- judge (SHARED backend, OWN rubric) -----------------------------------------------------
+if [ -n "\${PURVIEW_EMIT_PAYLOAD:-}" ]; then
+	jq -cn --arg r "$RUBRIC" --arg p "$payload" '{rubric:$r, payload:$p}'
+	exit 0
+fi
+if [ -n "\${PURVIEW_VERDICT_FILE:-}" ]; then
+	verdict="$(cat "\${PURVIEW_VERDICT_FILE}" 2>/dev/null || true)"
+	[ -n "$verdict" ] || {
+		note "$(date -u +%Y-%m-%dT%H:%M:%SZ) judge-empty tool=$tool_name agent=$agent_type"
+		allow
+	}
+else
+	verdict="$(printf '%s' "$payload" | $JUDGE_CMD "$RUBRIC" 2>/dev/null)" || {
+		note "$(date -u +%Y-%m-%dT%H:%M:%SZ) judge-fail tool=$tool_name agent=$agent_type"
+		allow
+	}
+fi
+
+decision="$(printf '%s\\n' "$verdict" | sed -n 's/^VERDICT:[[:space:]]*//p' | head -1)"
+[ "$decision" = "BLOCK" ] || allow
+
+reason="$(printf '%s\\n' "$verdict" | sed -n 's/^REASON:[[:space:]]*//p' | head -1)"
+[ -n "$reason" ] || reason="This act falls outside the arrow your role contract declares."
+
+# --- EVIDENCE CHECK: the cited span must be literally in the payload -------------------------
+# A block naming a span the payload does not contain is a hallucinated block, and a
+# fabricated refusal is not a lesser error than a missed one. Same rule, same reason as
+# the turn-end sibling.
+cited="$(printf '%s\\n' "$verdict" | sed -n 's/^SPAN:[[:space:]]*//p' | head -1)"
+if [ -n "$cited" ]; then
+	printf '%s' "$payload" | grep -qF -- "$cited" || {
+		note "$(date -u +%Y-%m-%dT%H:%M:%SZ) evidence-fail tool=$tool_name agent=$agent_type span=$cited"
+		allow
+	}
+fi
+
+: > "$seen" 2>/dev/null || true
+
+feedback="PURVIEW GUARDRAIL — denied this $tool_name call: it falls outside the arrow your own \\
+role contract declares. $reason  Delegation is a THEOREM of that arrow, not an option: an act whose \\
+domain or codomain lies outside it goes to the role that owns it — a decomposition to a planner, a \\
+build to an implementer, an artifact reading to an assayer. Hand it over and carry on with what the \\
+contract reserves. (Legitimate and NOT blocked here: reading anything, dispatching to a planner or an \\
+assayer, and performing any act the contract's own \\\`reserves\\\` clause names.)"
+
+jq -cn --arg r "$feedback" '{hookSpecificOutput:{hookEventName:"PreToolUse",permissionDecision:"deny",permissionDecisionReason:$r}}'
+exit 0
+`,
+        },
+        {
+            filename: 'purview-judge-prompt.md',
+            targetPath: 'packages/canon/targets/guardrail/purview-judge-prompt.md',
+            executable: false,
+            // NEUTRAL, exactly as the stance rubric is, and for a stronger reason here: this
+            // rubric carries no corpus content at all. It is a procedure for scoring a
+            // contract supplied at run time, so it is the same bytes for any corpus that
+            // declares a role arrow — which is what makes the neutral root its right home
+            // rather than a convenience.
+            shared: true,
+            content: `# Purview judge — does this act fall outside the agent's declared arrow?
+
+You are a PURVIEW JUDGE. You are given two things:
+
+1. **THE HOLDER'S DECLARED CONTRACT** — the \`## Role\` section of the agent's own definition,
+   verbatim. It states an arrow of the form \`reads⟨…⟩ → writes⟨…⟩\` over a ladder of
+   representational layers, the acts the arrow **reserves**, and often a named defect.
+2. **THE ACT ABOUT TO FIRE** — either a DISPATCH (the delegate prompt) or a WRITE (the path).
+
+Your one job: decide whether the act falls **outside** that arrow. You judge conformance to the
+contract you were handed. You do **not** judge whether the contract is wise, whether the act is a
+good idea, or whether the code is any good.
+
+## The law is the contract, not your opinion
+
+Every rule you apply must be readable **in the supplied contract**. If the contract does not exclude
+the act, the act passes — however unwise it looks to you. An agent is entitled to the whole of what
+its arrow permits, and a gate that convicts on an unwritten rule is worse than no gate, because it
+teaches the agent to distrust a law it can read.
+
+Read the arrow first, then the \`reserves\` clause, then the rest.
+
+## How to read an arrow
+
+\`reads⟨A · B⟩ → writes⟨C⟩\` means: the agent may consume layers A and B, and may produce layer C.
+The ladder runs \`intent ≺ C ≺ spec ≺ artifact\` from most abstract to least, where \`C\` is the
+durative concept lattice — the design.
+
+An act has a **domain** (the layer it consumes) and a **codomain** (the layer it produces):
+
+- a DISPATCH produces a **spec** — the delegate's instructions are the layer being written;
+- a WRITE to a source or config file produces an **artifact**;
+- reading anything at all produces **nothing**, and is never a breach.
+
+An act is **outside the arrow** when its codomain is not in the contract's \`writes\` set. That is the
+whole test, and it is mechanical.
+
+## What to BLOCK
+
+- **A write whose codomain is \`artifact\` by a holder whose \`writes\` set excludes \`artifact\`.**
+  The contract usually names this: \`descent\`. The path in the payload is the evidence.
+- **A dispatch whose codomain is \`spec\` by a holder whose \`writes\` set excludes \`spec\`.** This is
+  the skipped rung: a holder that writes only the design has handed a delegate a spec that no
+  spec-writing role produced. The prompt is the evidence.
+- **A dispatch whose prompt is the operator's literal words rather than a piece the agent cut.** The
+  contract that convicts this is the same clause: a dispatch is a spec, and transcription is not
+  authorship. Evidence is the prompt reading as relayed instructions rather than a bounded piece
+  with its own acceptance.
+
+## What to PASS — and these are the majority
+
+- **Any read.** Reading is outside the test by construction. Even where a contract calls
+  artifact-reading a descent, that is a standing discipline, not a mid-turn refusal.
+- **A dispatch to a role the contract explicitly routes to.** Contracts name their delegations
+  (\`⟨C → spec⟩ ↦ plan\`, \`⟨artifact → C⟩ ↦ assay\`). Handing work to a named delegate is the arrow
+  WORKING.
+- **Any act the \`reserves\` clause names**, whatever it is.
+- **A write by a holder whose \`writes\` set includes \`artifact\`.** Most agents in most corpora
+  build. Do not read a contract's other clauses as narrowing an arrow that plainly permits the act.
+- **Anything you are unsure about.** Fail toward PASS. A missed breach costs one wrong act; a
+  fabricated block costs the agent's trust in a law it can read for itself, and it wedges work.
+
+## Output
+
+Emit **only** this block, nothing before or after:
+
+\`\`\`
+VERDICT: BLOCK|PASS
+REASON: <one sentence naming the clause of the contract the act falls outside, and the codomain that put it there>
+SPAN: <a short literal substring copied from the payload that shows the act — omit this line entirely when the verdict is PASS>
+\`\`\`
+
+\`SPAN\` is checked against the payload character for character. If you cannot copy a literal span out
+of the payload, you do not have the evidence for a BLOCK, and the verdict is PASS.
+`,
+        },
+    ],
+};
+//# sourceMappingURL=purview-guardrail.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"purview-guardrail.js","sourceRoot":"","sources":["../../src/hooks/purview-guardrail.ts"],"names":[],"mappings":"AAEA,qEAAqE;AACrE,EAAE;AACF,oEAAoE;AACpE,oFAAoF;AACpF,mFAAmF;AACnF,kFAAkF;AAClF,qBAAqB;AACrB,EAAE;AACF,iFAAiF;AACjF,uFAAuF;AACvF,uFAAuF;AACvF,uFAAuF;AACvF,mFAAmF;AACnF,wFAAwF;AACxF,EAAE;AACF,sFAAsF;AACtF,oFAAoF;AACpF,uFAAuF;AACvF,uFAAuF;AACvF,uFAAuF;AACvF,+EAA+E;AAC/E,sFAAsF;AACtF,yEAAyE;AACzE,EAAE;AACF,+DAA+D;AAC/D,qFAAqF;AACrF,0EAA0E;AAC1E,gFAAgF;AAChF,sFAAsF;AACtF,kFAAkF;AAClF,0EAA0E;AAC1E,uFAAuF;AACvF,sFAAsF;AACtF,oFAAoF;AACpF,8DAA8D;AAC9D,EAAE;AACF,sFAAsF;AACtF,wFAAwF;AACxF,mFAAmF;AACnF,2BAA2B;AAE3B,MAAM,CAAC,MAAM,gBAAgB,GAAa;IACxC,EAAE,EAAE,mBAAmB;IACvB,OAAO,EACL,iaAAia;IACna,SAAS,EAAE,SAAS;IACpB,KAAK,EAAE,CAAC;IACR,MAAM,EAAE,CAAC,uBAAuB,EAAE,cAAc,CAAC;IACjD,KAAK,EAAE,sBAAsB;IAC7B,OAAO,EAAE,EAAE;IACX,IAAI,EAAE,EAAE;IACR,OAAO,EAAE;QACP;YACE,QAAQ,EAAE,sBAAsB;YAChC,UAAU,EAAE,uDAAuD;YACnE,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6Jd;SACI;QACD;YACE,QAAQ,EAAE,yBAAyB;YACnC,UAAU,EAAE,0DAA0D;YACtE,UAAU,EAAE,KAAK;YACjB,iFAAiF;YACjF,2EAA2E;YAC3E,6EAA6E;YAC7E,8EAA8E;YAC9E,6BAA6B;YAC7B,MAAM,EAAE,IAAI;YACZ,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0Ed;SACI;KACF;CACF,CAAC"}

package/dist/roles/architect.d.ts

@@ -0,0 +1,2 @@
+import type { RoleCell } from './hold.js';
+export declare const architectRole: RoleCell;

package/dist/roles/architect.js

@@ -0,0 +1,101 @@
+import { convergence as convergence_audienceAdaptation } from '../dimensions/audience-adaptation/convergence.js';
+import { principalSelf } from '../dimensions/autonomy/decision-authority.js';
+import { handoff as handoff_autonomy } from '../dimensions/autonomy/handoff.js';
+import { humanOnTheLoop as humanOnTheLoop_autonomy } from '../dimensions/autonomy/human-on-the-loop.js';
+import { missionCommand } from '../dimensions/autonomy/mission-command.js';
+import { researchInvestigation as researchInvestigation_capabilities } from '../dimensions/capabilities/research-investigation.js';
+import { systemDesign as systemDesign_capabilities } from '../dimensions/capabilities/system-design.js';
+import { cratylism as cratylism_engineeringPrinciples } from '../dimensions/engineering-principles/cratylism.js';
+import { dry as dry_engineeringPrinciples } from '../dimensions/engineering-principles/dry.js';
+import { firstPrinciples as firstPrinciples_engineeringPrinciples } from '../dimensions/engineering-principles/first-principles.js';
+import { greenField as greenField_engineeringPrinciples } from '../dimensions/engineering-principles/green-field.js';
+import { llmNative as llmNative_engineeringPrinciples } from '../dimensions/engineering-principles/llm-native.js';
+import { mece as mece_engineeringPrinciples } from '../dimensions/engineering-principles/mece.js';
+import { separationOfConcerns as separationOfConcerns_engineeringPrinciples } from '../dimensions/engineering-principles/separation-of-concerns.js';
+import { simplicity as simplicity_engineeringPrinciples } from '../dimensions/engineering-principles/simplicity.js';
+import { trustButVerify as trustButVerify_engineeringPrinciples } from '../dimensions/engineering-principles/trust-but-verify.js';
+import { plain as plain_formality } from '../dimensions/formality/plain.js';
+import { systemsThinking as systemsThinking_framing } from '../dimensions/framing/systems-thinking.js';
+import { honesty as honesty_guardrails } from '../dimensions/guardrails/honesty.js';
+import { correctionConsolidation as correctionConsolidation_learning } from '../dimensions/learning/correction-consolidation.js';
+import { delivery as delivery_objective } from '../dimensions/objective/delivery.js';
+import { planAndSolve as planAndSolve_reasoningStrategy } from '../dimensions/reasoning-strategy/plan-and-solve.js';
+import { architect as architect_role } from '../dimensions/role/architect.js';
+import { optimize as optimize_satisficing } from '../dimensions/satisficing/optimize.js';
+import { acceptanceCriteriaCheck as acceptanceCriteriaCheck_selfEvaluation } from '../dimensions/self-evaluation/acceptance-criteria-check.js';
+import { projection as projection_situationAwareness } from '../dimensions/situation-awareness/projection.js';
+import { decisionRationale as decisionRationale_transparency } from '../dimensions/transparency/decision-rationale.js';
+// THE TOP RUNG. `architect`, `planner` and `implementer` are one ladder differing FIRST in
+// decision authority — principal here, withheld below — and SECOND in the arrow each
+// one is. Every rung carries `mission-command`, whose escalation clause is the shared
+// law: surface the fork, do not resolve it. That single rule is what keeps delegation
+// from silently becoming re-delegation of the design.
+//
+// WHAT THE CAPABILITY SET SAYS, AND WHAT IT DELIBERATELY DOES NOT.
+// `software-engineering` was always absent, and that absence used to be the entire
+// delegation boundary. It is now redundant with a contract that states the boundary out
+// loud, which is the improvement: an absence cannot be quoted by a rubric and cannot be
+// distinguished from an oversight by anyone reading the Target.
+//
+// Two capabilities were REMOVED when the contract was written down, because the
+// contract convicted them. `planning-decomposition` was glossed "the decomposition that
+// hands work out" while `⟨C → spec⟩ ↦ plan` says the opposite, and an agent holding a
+// capability exercises it. `review-critique ≜ ⟨adversarial threat-modeling
+// severity-triage⟩` is a substrate act under a name that sounded conceptual; the
+// critique this rung performs is `judge`, which the contract reserves by name.
+export const architectRole = {
+    sign: architect_role,
+    // `design` holds the lattice, `deliver` closes the loop on what comes back. Declared
+    // rather than described — omp injects them before a dispatched subagent's first
+    // prompt and the generic launcher names them as required reading for a main session,
+    // so a holder is the same agent either way it is reached.
+    skills: ['design', 'deliver'],
+    vector: {
+        formality: plain_formality,
+        // `convergence`: this position's output is UNDERSTANDING, which is worthless at a
+        // density its reader cannot take. A holder whose interlocutor is a peer expert
+        // overrides it — `nico` does — which is precisely what a default is for.
+        audienceAdaptation: convergence_audienceAdaptation,
+        transparency: decisionRationale_transparency,
+        autonomy: [
+            principalSelf,
+            humanOnTheLoop_autonomy,
+            missionCommand,
+            handoff_autonomy,
+        ],
+        // `delivery`, against the obvious pull toward `insight`. The characteristic failure
+        // of this position is becoming a theorist who emits documents while the work
+        // stalls; the standing drive is the finished system, and design is how it gets
+        // there rather than what it is for.
+        objective: delivery_objective,
+        engineeringPrinciples: [
+            cratylism_engineeringPrinciples,
+            llmNative_engineeringPrinciples,
+            firstPrinciples_engineeringPrinciples,
+            // The three carrying this position's specific load: concerns must not mix,
+            // delegated work is checked rather than trusted, and executors are told to BREAK
+            // what does not conform rather than accrete beside it.
+            separationOfConcerns_engineeringPrinciples,
+            trustButVerify_engineeringPrinciples,
+            greenField_engineeringPrinciples,
+            simplicity_engineeringPrinciples,
+            dry_engineeringPrinciples,
+            mece_engineeringPrinciples,
+        ],
+        guardrails: [honesty_guardrails],
+        capabilities: [
+            systemDesign_capabilities,
+            researchInvestigation_capabilities,
+        ],
+        learning: correctionConsolidation_learning,
+        situationAwareness: projection_situationAwareness,
+        framing: systemsThinking_framing,
+        reasoningStrategy: planAndSolve_reasoningStrategy,
+        satisficing: optimize_satisficing,
+        // NOT an executable test oracle. A suite going green proves the executor's own
+        // claim and says nothing about conformance to the design; acceptance is judged
+        // against the criteria the design states.
+        selfEvaluation: acceptanceCriteriaCheck_selfEvaluation,
+    },
+};
+//# sourceMappingURL=architect.js.map

package/dist/roles/architect.js.map

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

package/dist/roles/assayer.d.ts

@@ -0,0 +1,2 @@
+import type { RoleCell } from './hold.js';
+export declare const assayerRole: RoleCell;

package/dist/roles/assayer.js

@@ -0,0 +1,66 @@
+import { maintenance as maintenance_audienceAdaptation } from '../dimensions/audience-adaptation/maintenance.js';
+import { handoff as handoff_autonomy } from '../dimensions/autonomy/handoff.js';
+import { missionCommand } from '../dimensions/autonomy/mission-command.js';
+import { researchInvestigation as researchInvestigation_capabilities } from '../dimensions/capabilities/research-investigation.js';
+import { softwareEngineering as softwareEngineering_capabilities } from '../dimensions/capabilities/software-engineering.js';
+import { cratylism as cratylism_engineeringPrinciples } from '../dimensions/engineering-principles/cratylism.js';
+import { firstPrinciples as firstPrinciples_engineeringPrinciples } from '../dimensions/engineering-principles/first-principles.js';
+import { mece as mece_engineeringPrinciples } from '../dimensions/engineering-principles/mece.js';
+import { plain as plain_formality } from '../dimensions/formality/plain.js';
+import { analytical as analytical_framing } from '../dimensions/framing/analytical.js';
+import { honesty as honesty_guardrails } from '../dimensions/guardrails/honesty.js';
+import { correctionConsolidation as correctionConsolidation_learning } from '../dimensions/learning/correction-consolidation.js';
+import { thoroughness as thoroughness_objective } from '../dimensions/objective/thoroughness.js';
+import { structuredData as structuredData_outputFormat } from '../dimensions/output-format/structured-data.js';
+import { react as react_reasoningStrategy } from '../dimensions/reasoning-strategy/react.js';
+import { assayer as assayer_role } from '../dimensions/role/assayer.js';
+import { satisfice as satisfice_satisficing } from '../dimensions/satisficing/satisfice.js';
+import { acceptanceCriteriaCheck as acceptanceCriteriaCheck_selfEvaluation } from '../dimensions/self-evaluation/acceptance-criteria-check.js';
+import { comprehension as comprehension_situationAwareness } from '../dimensions/situation-awareness/comprehension.js';
+import { provenanceAttribution as provenanceAttribution_transparency } from '../dimensions/transparency/provenance-attribution.js';
+// THE UPWARD ARROW. `software-engineering` is PRESENT here and absent one rung up, and
+// the two facts are the same decision: this is the position that descends, so that the
+// design-holder does not.
+//
+// EVERY ASPECT BELOW IS CHOSEN AGAINST THE ONE FAILURE MODE — turning into a code
+// reviewer. `thoroughness` rewards answering every concept in `realizes(unit)` rather
+// than finding something to say. `satisfice` stops at the answer instead of reading on.
+// `structured-data` makes the report a list of ⟨concept, uncovered-factor, locus⟩ rather
+// than a narrative, and a narrative is where mechanism-prose gets in. `cratylism`
+// carries the cheapest of the three questions — does the artifact SPELL its concept —
+// and `first-principles` forbids inheriting the executor's own account of what it built.
+//
+// `design` and no `deliver`: it must read the lattice to lift into it, and judging is
+// not its remit.
+export const assayerRole = {
+    sign: assayer_role,
+    skills: ['design'],
+    vector: {
+        formality: plain_formality,
+        audienceAdaptation: maintenance_audienceAdaptation,
+        // `provenance-attribution`: an unachieved concept travels with a locus, and a locus
+        // asserted without a source is a claim the principal cannot route.
+        transparency: provenanceAttribution_transparency,
+        // No `principal-self`. It is dispatched, it answers, it returns.
+        autonomy: [missionCommand, handoff_autonomy],
+        objective: thoroughness_objective,
+        engineeringPrinciples: [
+            cratylism_engineeringPrinciples,
+            firstPrinciples_engineeringPrinciples,
+            mece_engineeringPrinciples,
+        ],
+        guardrails: [honesty_guardrails],
+        capabilities: [
+            softwareEngineering_capabilities,
+            researchInvestigation_capabilities,
+        ],
+        learning: correctionConsolidation_learning,
+        situationAwareness: comprehension_situationAwareness,
+        framing: analytical_framing,
+        reasoningStrategy: react_reasoningStrategy,
+        satisficing: satisfice_satisficing,
+        outputFormat: structuredData_outputFormat,
+        selfEvaluation: acceptanceCriteriaCheck_selfEvaluation,
+    },
+};
+//# sourceMappingURL=assayer.js.map

package/dist/roles/assayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assayer.js","sourceRoot":"","sources":["../../src/roles/assayer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,IAAI,8BAA8B,EAAE,MAAM,kDAAkD,CAAC;AACjH,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAChF,OAAO,EAAE,cAAc,EAAE,MAAM,2CAA2C,CAAC;AAC3E,OAAO,EAAE,qBAAqB,IAAI,kCAAkC,EAAE,MAAM,sDAAsD,CAAC;AACnI,OAAO,EAAE,mBAAmB,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AAC7H,OAAO,EAAE,SAAS,IAAI,+BAA+B,EAAE,MAAM,mDAAmD,CAAC;AACjH,OAAO,EAAE,eAAe,IAAI,qCAAqC,EAAE,MAAM,0DAA0D,CAAC;AACpI,OAAO,EAAE,IAAI,IAAI,0BAA0B,EAAE,MAAM,8CAA8C,CAAC;AAClG,OAAO,EAAE,KAAK,IAAI,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAC5E,OAAO,EAAE,UAAU,IAAI,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACvF,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACpF,OAAO,EAAE,uBAAuB,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AACjI,OAAO,EAAE,YAAY,IAAI,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AACjG,OAAO,EAAE,cAAc,IAAI,2BAA2B,EAAE,MAAM,gDAAgD,CAAC;AAC/G,OAAO,EAAE,KAAK,IAAI,uBAAuB,EAAE,MAAM,2CAA2C,CAAC;AAC7F,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,+BAA+B,CAAC;AACxE,OAAO,EAAE,SAAS,IAAI,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAC5F,OAAO,EAAE,uBAAuB,IAAI,sCAAsC,EAAE,MAAM,4DAA4D,CAAC;AAC/I,OAAO,EAAE,aAAa,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AACvH,OAAO,EAAE,qBAAqB,IAAI,kCAAkC,EAAE,MAAM,sDAAsD,CAAC;AAGnI,uFAAuF;AACvF,uFAAuF;AACvF,0BAA0B;AAC1B,EAAE;AACF,kFAAkF;AAClF,sFAAsF;AACtF,wFAAwF;AACxF,yFAAyF;AACzF,kFAAkF;AAClF,sFAAsF;AACtF,yFAAyF;AACzF,EAAE;AACF,sFAAsF;AACtF,iBAAiB;AAEjB,MAAM,CAAC,MAAM,WAAW,GAAa;IACnC,IAAI,EAAE,YAAY;IAClB,MAAM,EAAE,CAAC,QAAQ,CAAC;IAClB,MAAM,EAAE;QACN,SAAS,EAAE,eAAe;QAC1B,kBAAkB,EAAE,8BAA8B;QAClD,oFAAoF;QACpF,mEAAmE;QACnE,YAAY,EAAE,kCAAkC;QAChD,iEAAiE;QACjE,QAAQ,EAAE,CAAC,cAAc,EAAE,gBAAgB,CAAC;QAC5C,SAAS,EAAE,sBAAsB;QACjC,qBAAqB,EAAE;YACrB,+BAA+B;YAC/B,qCAAqC;YACrC,0BAA0B;SAC3B;QACD,UAAU,EAAE,CAAC,kBAAkB,CAAC;QAChC,YAAY,EAAE;YACZ,gCAAgC;YAChC,kCAAkC;SACnC;QACD,QAAQ,EAAE,gCAAgC;QAC1C,kBAAkB,EAAE,gCAAgC;QACpD,OAAO,EAAE,kBAAkB;QAC3B,iBAAiB,EAAE,uBAAuB;QAC1C,WAAW,EAAE,qBAAqB;QAClC,YAAY,EAAE,2BAA2B;QACzC,cAAc,EAAE,sCAAsC;KACvD;CACF,CAAC"}

package/dist/roles/hold.d.ts

@@ -0,0 +1,57 @@
+import type { Agent as AgentIdentity, DimensionFieldsOf } from '@cratylus/schema';
+import { MANIFEST } from '../manifest.js';
+import type { Agent, Role } from '../manifest.js';
+/** Every dimension FIELD of this corpus, as an agent carries it. */
+type DimensionFields = DimensionFieldsOf<typeof MANIFEST>;
+/**
+ * What a role SUPPLIES — a partial dimension vector, minus `role` (which is the
+ * role's own `sign`) and plus `guardrails`, which is `required: true` in the
+ * manifest and is therefore the position's to state. A position that confines
+ * nobody is not a lesser position, it is an unconfined one, and the catch-all
+ * belongs where every holder inherits it rather than on each holder in turn.
+ */
+export type RoleVector = Partial<Omit<DimensionFields, 'role' | 'guardrails'>> & Pick<DimensionFields, 'guardrails'>;
+/** The expectations attached to one position. */
+export interface RoleCell {
+    /**
+     * The `role` dimension value — the position's CONTRACT, not merely its name. It
+     * states the pair ⟨reads, writes⟩ over the ladder and the acts the pair reserves;
+     * delegation is a theorem of the pair rather than a second declaration beside it.
+     */
+    readonly sign: Role;
+    /** The apparatus every holder operates through. Holders may add; see `holds`. */
+    readonly skills?: readonly string[];
+    /** The aspects expected of anyone holding the position — DEFAULTS, every one. */
+    readonly vector: RoleVector;
+}
+/**
+ * What the HOLDER declares: its identity, and any dimension value of its own.
+ *
+ * Unbounded in size — `kino` declares an entire domain over the architect role — and
+ * bounded in exactly one way: `role` is absent, because the contract is the position's.
+ * An aspect stated here OVERRIDES a scalar the role supplies and EXTENDS a set.
+ */
+export type Declared = AgentIdentity & Partial<Omit<DimensionFields, 'role'>>;
+/**
+ * `select(a) = hold(a) ⊕ declare(a)` — the two-operand fold, run at authoring time so
+ * the projected Target stays flat.
+ *
+ * `⊕` reads the manifest's own `arity`, so the precedence rule is stated once and
+ * cannot disagree with itself:
+ *
+ *   · set    → role members first, then the holder's own — EXTEND. A role-supplied
+ *              member therefore survives every holder, which is why a set needs no
+ *              inviolability marking: union already guarantees it.
+ *   · scalar → the holder's value when the KEY IS PRESENT, else the role's — OVERRIDE.
+ *              Present-with-`null` is an explicit suppression and is honoured as one;
+ *              absent means "whatever the position says", which is the common case.
+ *
+ * A dimension neither operand states is `null` — omit-to-inherit, exactly as a
+ * hand-written vector spells it.
+ *
+ * `provenance.mark` NEVER folds: it is instance-bound, minted per agent at
+ * `create-agent`, and two agents sharing a mark are indistinguishable in the one place
+ * an operator reads them. It arrives on `declared` and leaves untouched.
+ */
+export declare function holds(role: RoleCell, declared: Declared): Agent;
+export {};