iskronify

Repo-boost

Bring the current repository to the iskron agent standard: dense AGENTS.md (read every session by every harness), REALITY.md alongside (a table of carriers of reality, read on occasion — on a behavioral claim and in the brief verifier/reviewer), CLAUDE.md-pointer, session rituals by hooks, and a quality gate. You generate the config from the skeletons — the user does not insert templates.

The deliverable is the trust interface. AGENTS.md и REALITY.md — derived kinds: a projection of sources (code, package.json, CI, file system, graph) plus a thin layer of authorial judgment that lives nowhere else. The contract is two-headed: density (every line changes behavior) and accuracy (every derived line is rechecked against the source in this run). A dense false line is worse than a verbose one.

Skeletons: references/agents-template.md (AGENTS.md: YAML frontmatter and body) and references/reality-template.md (REALITY.md) — slots <…> and notes . Fill the slots, discard inapplicable optional lines, clean out every note and angle bracket. The skeletons are what to produce; this file is how.

Contract: 25. Step 7 stamps this number into every AGENTS.md. Increase it by one only when a change here or in the skeletons makes an already generated file incorrect (a section or file added, renamed, removed; a ritual changed; a tool name dropped), never for wording. The same number stands as the first word in description — deliberately: the trigger fires on the description, and in the session context only skill descriptions and the stamp AGENTS.mdconverge; a divergence of copies is caught by make validate. A config with a date stamp or without a stamp is below any number: run the full arc (the launch rule holds the "Alignment" step of the door iskron) and name the contract from which the config came.

The string AGENTS.md diverges from the skill — say it aloud, do not choose silently: in the case of the setter, without a case — to the person. Stamp below the established contract iskronify — the skill is right, run it; equal — a template defect, feedback to the steward of the skill delivery (feedback). The rule also stands in the skeleton (“Keep this file honest”) — for an agent that has not loaded this skill.

The revision of the installed delivery is checked here. Every run — and every conclusion “the skill's instruction is incorrect” (they are sent to feedback и entry) — begins with comparing the running one against the released one:

cat ~/.claude/plugins/cache/*/*/*/.claude-plugin/plugin.json     # что у тебя бежит
gh release view --repo <репозиторий плагина> --json tagName      # что существует
node ~/.iskron-bridge/iskron-bridge.mjs --version                # какую сборку несёт копия моста

Behind by more than a patch — update the delivery, restart the harness sessions, and only then run the arc: a config from a stale skill inherits its defects. The contract number does not replace this: it moves with the shape of the config, the version — with every shipment.

The skeleton inlines the graph-agnostic discipline (Working principles, “Session lifecycle”) into every AGENTS.md — concisely, one line per rule, but inline, not a pointer into the graph or skill: there are harnesses without a start hook, and the file must stand on its own.

Audit → classification → action

The repository is a spectrum, not “fresh or configured”; the trap — “the file exists, so its facts are true”. Audit each concern against its source and classify:

absent — derive from the source; an authorial slot without a verifiable source — into the alignment case, never invent.
stale — re-project, overwriting; do not drag what was written forward.
correct — leave.

The most dangerous is almost-true config: outdated strings among trusted ones — the verification pass goes over the entire artifact (Step 7).

Source of truth by concern

Concern	Source of truth	How to check
Versions, dependencies	`package.json` / `pyproject.toml` / `go.mod` / `Cargo.toml` + lockfile	read
build/test/lint/dev commands	scripts, `Makefile`/`Justfile`, CI-workflow	read; `--help`/dry-run, where it's cheap
Quality gate	linter config, `tsconfig`, CI-yaml	read
Layout: code map, environment gotchas	cover slot "Layout"	no slot — default: one `AGENTS.md`, file navigation — compactly in the component README, gotchas in the graph; the run does not write component READMEs: while there is no component README, its map is in "Project structure" `AGENTS.md`, and the first one who touches the component moves it to the README. Exception — the "Project structure" section instead of the README — only where a README next to the outputs is forbidden (outputs go to the consumer); the ban applies to such outputs, not to the whole repo, and is derived from the repo itself. `GOTCHAS.md` in the repo — someone's layout: resolve via Step 1; until the sources have resolved it — the slot is empty, source `не согласовано — дело №N`, files untouched
Project structure, path aliases	file system + bundler config; with the "component README" layout — the READMEs themselves	glob / list; the "component → README" table is checked against file existence
Nature, production statement, allowances	graph, repo code, agents' word; constraints accepted by the owner are preserved	resolve in Step 1 order; changing the mandate or the cost of breakage without grounds is a matter of principle
Reality carriers (`REALITY.md`)	graph, delivery path observable by code, agents' word	check reachability of the canonical carrier; the unknown is a Ceiling, not an invented carrier
Design decisions, why-clauses, open questions	graph	`iskron_orient` / `iskron_search`
Branch state	git + forge	`git status` / `log`; forge CLI
Gotchas	authorial; home — per the "Layout" slot	sanity-check only — do not auto-derive, do not move between homes
Graph canon blocks	rule node with `attrs.prose_for_repos`	`iskron_search(realm=<граф>, q="", attrs_filter="prose_for_repos:**")`; the block is placed byte-for-byte into the location from `attrs.prose_anchor`, below is only the tail of the repo; applicability is per `attrs.scope`, otherwise by meaning, doubt — by the order of Step 1

Derived facts (top lines, canon blocks) are re-projected on every run; authorial judgment (gotchas, why-clauses, nature, carriers) is preserved, only sanity-checked against the code.

Output contract — density and precision

Imperative to the agent: “orient yourself before the code,” not “the agent should.”
Every line changes what the agent does; otherwise delete it. A checklist, not an essay.
No design justifications or retelling of the graph — link it. (why: …) — only for an invariant that the agent would otherwise violate.
Tables and bullets, one directive per bullet.
A section that has sprawled into paragraphs carries justification — move it to the graph.

Out of scope — orchestration mechanics (gate chains, sub-agent push verification, model routing, multi-lane coordination): its home is the orchestration skill or the graph; the delegation slice is projected by role files (Step 6), not by prose.

Example: ❌ “We try to handle state carefully because the store is the only place for data, otherwise the demo may look broken.” ✅ “Persona-scoped UI reads the role via use-acting-context; recheck rendering when the persona changes. (why: a stale read shows another role’s data.)”

Procedure

Idempotent: in a mature repo, run every self-check and act only on failures; report what remains.

Two beats

Who performs the run. The run graph — contour, role, attributes, the alignment task — is led by the agent itself: this is the craft of the graph (“Cross-cutting norms” of the door iskron). It may hand the voluminous projection of files (AGENTS.md, role files, hooks) to a subagent of role designer — that one has its own bridge companion; if there are no subagents, the role file designer not yet (first contact, cycle 1 before projection, roles older than the contract) or the satellite has not come up — it projects itself. The run updates AGENTS.md and derivatives itself, does not wait for a person's presence or confirmation. The one who called (the host) leads the alignment matter; designer works in its own child matter from the launch line and does not lead the alignment matter (clause 5). The host wakes the person and holds the wait, not designer, and only on a matter of principle not resolved by the graph, code and colleagues: designer returns it as a question in the outcome. Run questions — per the order of Step 1 ("A person is usually not in the thread").

Cycle 1 "stand up" — without questions, within a minute, in any repository. The first cycle on first contact, at the word "iskronify" or when a config lag is found. Quickly resolvable — into the file with the source, the rest — as a hole into the matter; then cycle 2 without waiting for a person.

Addresses. The graph and role — from the person's word, the line of the window with the place address or an existing AGENTS.md. The graph is not named — iskron_realm(action="list"), check against what is recorded about the repo and ask colleagues; if it is not resolved which graph to choose or create — a matter of principle about the project boundary per Step 1, do not guess the name. Creation — iskron_realm(action="create") according to the adopted choice. The owner role is the 主-role of the person of your keys (iskron_me(action="kartas")); the list where you yourself stand is a sign of a knocked-off binding: the slot as a hole, the question — into the alignment matter. kartas sees only bound roles: before creating a svatantra role (Step 2), look for it in the graph — iskron_search(q="", node_type="karta", manifested_as="svatantra"). He gives all 主-roles of the graph: the owner role is the one whose handle in the attributes matched the handle from iskron_me(action="whoami"); if such exists — do not create it, if it is not selected — one question to the session person, which of the found ones is theirs. Check the binding of the owner role per the step "Converge or escalate" of the skill standing.
Repository contour. origin → хост/организация/репо → iskron_search(q="", node_type="holon", attrs_filter="repository:<значение>"). No — iskron_add_holon (contains from the root of the graph or the contour of repositories) with attrs.repository и open_room of the alignment matter. One repository — one contour.
Role per repo. iskron_search(q="", node_type="karta", steward_of=<контур>); no — iskron_add_karta (manifested_as=adhikarin, the motivation — a distillate of what the repo ships) and steward to the contour. One role per repository.
Cover and files. Slots — YAML frontmatter at the beginning AGENTS.md according to the skeleton and Step 7. From the graph and code — “derived”; from the recorded answer — “agreed: who,” including the agent of the neighboring contour. What is not permitted — an empty value and the source “not agreed — case No. N”; an author’s slot does not become a hole just because the person is absent. “Session lifecycle” is inlined from the skeleton. REALITY.md — with a table of permitted carriers; while there are none, the skeleton heading and the line: “Carriers have not yet been established; alignment case No. N. Until they are established, behavioral requests are not accepted.” The Reality table in AGENTS.md already exists — it is transferred to REALITY.md according to Step 7.
Alignment case on the contour from item 2 is led by the caller (the lead): if an open one already exists (iskron_case(action="at", node=<контур>)) — he leads it; if not — he opens open_room at the contour record or iskron_update of an existing one, with an opening of up to 64 characters: “Alignment of <repo> under contract N.” Before the first record — identify yourself and log in (iskron_case(action="join")); standing watch is not needed. If you execute it yourself — you are the lead: identify yourself iskron_channel(action="register", realm, karta=<роль на репо>, name=<выведенное имя>). The file projection is performed by the subagent designer — the lead creates a child case for him (open_room с parent_room — alignment case) and puts its No. N in the launch line; designer becomes a companion (iskron_stand с satellite_of of the caller’s place, as in references/delegation-1.md, references/delegation-2.md — open and read both parts in order before the move), register does not call under the derived name (the name is the caller’s), he speaks slot questions as a word in the child case, does not write to the graph, does not lead alignment cases, and exits at the end of the assignment (iskron_case(action="leave")). An unresolved, waiting slot may be kept as the line “slot: <name>” (partial — on whom, what it is waiting for) — optionally; a resolved one — value and source in the frontmatter, without the line; a question — as a word in the case. Run questions — in the order of Step 1 (“A person is usually not in the thread”). First word: “there are questions about the project I am responsible for — answer or say who can answer.” Do not write the questionnaire, run questions, plan, or alignment progress into the graph; in the graph, the tick writes only the structure (contour with repository, role) and catches by rules (Step 7).
Start hook and memory guard — from Step 4 only SessionStart and memory-guard; stub MEMORY.md (Step 5) — only over an empty or absent memory directory. A non-empty one — evacuation per Step 5 in tick 2; before it, the skeleton line about freezing does not assert completion, but refers to the alignment case line. The remaining hooks — tick 2. Pointer CLAUDE.md — Step 7.
Standing — not here: it is occupied by the door start iskron, only for the watch. Report — a word in the alignment case: what is permitted, what is open; a tick on the word of another case — a report-word there, naming the alignment case; then the relay of Step 7. A tick on the word of a case is an assignment, and its outcome, based on what was observed, you state with a word in that case.

Tick 2 "finish up" — yourself, without blocking. Continue after tick 1; each subsequent start (the "Alignment" step of door iskron) reads the case summary from the "Coordination" key of the frontmatter — iskron_case(action="read"); to write — having identified yourself and entered, as in item 5. Resolve slots by the graph, code, and the word of colleagues per Step 1. Enter the value and source into the frontmatter without asking again; the waiting line "slot: …", if a slot held it, is removed by the same move (ok), for a permitted one without waiting, no line is created. The agent's reply is signed with its name, not the owner's name; it does not require repeated confirmation by a human. The full arc (Steps 1, 3, 4, 6, gate, hooks, role agents) proceeds without a human; an unresolved slot holds only the dependent part. All slots resolved — "Coordination" = "empty", suggest closing (propose_close, evidence — frontmatter slots with values and sources), if you are the lead; otherwise a word to the lead.

Step 1 — Resolve slots (tick 2)

Don't silently pick defaults. Read the graph, the repo code and the old config; whatever they didn't resolve — ask the agents of neighboring contours in the alignment case. Write into the frontmatter the value and source: Nature (not production — what is weakened and why), graph name, “Stack”, gate (Step 3). Preserve accepted author constraints; re-asking the human is needed only for a fundamental remainder.

Transition from the old questionnaire. “Approval” or a hole names a node (#N), not a case, — the form of the former contract. Read the node (iskron_look): answers with the name of the answerer — into the “approved: who” slots; open ones — as lines “slot: <name>” into the alignment case, empty value and source не согласовано — дело №N into the frontmatter; release the questionnaire node (visarjana, reasoning “transferred to case No. N”), someone else's — a word to the author.

Also coordinate:

Who owns the direction — the svatantra-role of the owner (主), is created in Step 2; fundamental questions of the slots — to it through the facilitator in the matter of alignment, not by a questionnaire in the graph.
Shared mutable state of build/test (base, fixed port, dev server, global cache, cloud sandbox): if present — fix per-strip isolation of getches (agents run branches concurrently in separate worktrees).
Reality → REALITY.md. Establish from the graph, code and colleagues' answers: where the change lands, what effects it produces, which are observable and by which command / URL / request, what the agent obtains on its own, what requires the user. Drive it down to the canonical carrier of each class: the built artifact, not the sources; the live endpoint, not the handler; a clean install, not a warm cache. A class without reachable observation — into Ceiling with the reason; a conclusion about the carrier does not equal observation of behavior. Dated measurements (deadlines, versions, “observed at such-and-such time”) — as nodes into the graph, in REALITY.md — only what is needed for observation. In AGENTS.md — a “Reality” section as a pointer: read REALITY.md before a behavioral claim, the first row of the table is named, Ceiling — there. (How the table works at closures — the vahta skill, §3 “Work and Relay”, the paragraph about reality-audit before closing.)
Cross-project memory — template default: value from the skeleton, source выведено: умолчание шаблона, without asking the human. Personal graph @<handle>/mind exists for everyone, do not ask about it: if none — create a graph and role via minding; routing and the memory-guard message always carry its branch. Agent behavior is configured by only committed files of the working tree (AGENTS.md, hooks file) and the project graph — never the global instructions file (~/.claude/CLAUDE.md, ~/.config/opencode/AGENTS.md…), harness memory, user hooks; do not ask about the global file and do not create one. Installing the delivery is delivery, not configuration. A preference affecting process and outcome goes in AGENTS.md or the project graph; personal — in @<handle>/mind.
Feedback reflection — whether to reflect on the experience about the method at the end of the session or on merge and record what is worthwhile in the work graph (tool outline, addressed to the steward, after a duplicate check, with a case). Template default — yes, source выведено: умолчание шаблона, without asking the human: the skeleton's feedback-reflection region remains, the merge hook carries the tick. No — only by a recorded word (согласовано: кто): delete the region entirely.
Coexistence with a workflow set — only when a coercive set is found (its skills in the list or its directory in the plugin cache; today superpowers): (1) full interop (recommended) — subsection from references/superpowers-interop.md + spec-write hook; (2) prose only; (3) skip — name the risk: the set's design sessions will not land in the graph.

The human is usually not in the thread. The run itself updates AGENTS.md and derivatives; the human's presence is not a condition. Everywhere above and below, “agree”, “ask”, “confirm” for the slot mean this order:

Do everything that does not depend on the answer: audit, derivable, gate, hooks.
First the graph and code, then the brothers — agents of neighboring outlines. Unresolved — in one alignment case, by question ask on the door iskron, “Expectation from the doer”; the line “slot: <name>” — optionally, on a key separate from the card (“Do not overlap the question key with a work line” there), not a node and not a case per slot. Call knowledgeable colleagues iskron_case(action="invite"); the assignment — say с to to the place according to “One-off task — a word in the case” of the door. Their answer accept ack, the answer — into the slot with their name. Write a fact from the graph or code as “derived”, without a case line; a non-obvious basis — as a word in the case.
Only the principled remainder — to a human through the case lead. A change of mandate, an accepted constraint, the cost of breakage, the choice or creation of a graph (project boundary, step 1, item 1), or an unresolvable conflict of sources — is principled; the absence of an answer or information by itself — is not. Before escalation, name what was checked in the graph and code, whom you asked, and why this requires the owner’s decision. designer returns such a question in the report; the lead says it as a word in the case (the line “slot: …” — optionally). The caller wakes the human and holds the wait: invite its places; if there is no place — its roles with the contour (karta=<роль владельца>, holon=<контур репо>). If no place is available — the question remains in the case with the lead; the rest of the work continues.
A hole, not a guess: the value of the slot '', its source 'не согласовано — дело №N'; Согласование is named by this case. A non-principled unknown waits for a knowledgeable agent or the lead — as a word in the case, the line optionally. The door start will find the answer and write it in without asking again. An answered item is written immediately; one slot does not hold the others.

Step 2 — Graph bootstrap

There is no graph — agree on the name, iskron_realm(action="create").
Focus contour (project boundary, contains from the root) — design design, create iskron_add_holon; #seq — into the cover. The contour carries the attribute repository — хост/организация/репо from git remote get-url origin, without protocol and .git (for example github.com/iskron-ai/skills); attrs_filter="repository:…", and the door start verifies it against origin. Set it up at creation and on refresh; one circuit — one repository.
The doer is the steward. Agent role (iskron_add_karta, manifested_as=adhikarin, motivation — distilled Production statement) run steward to the focus circuit — this role, not a senior one, otherwise the circuit orientation will not find the doer. There is no svatantra role of the owner and the search for beat 1, item 1 did not find it — create it; the binding is by the same step standing. Both seq — into the cover.
Holon + steward — the root of the integration field; the traversal holds integrity. Do not ask about "shared surfaces" and do not write a list in AGENTS.md; an unfound dependency is a model defect (design, weaving).

Step 3 — Quality Gate (the strictest in the accepted mandate)

references/step3-gate.md — open and execute in full at this place in the procedure. Core: for each item — the strictest option for the stack, a trade-off in one line, source per Step 1; a relaxation — only from an accepted constraint, in the frontmatter; linter, formatter, type checker, pre-commit, tests, CI; the gate — one callable invocation, CI calls the same one; any failing check gates the PR. Commands — in "Commands", discipline — in "Code Conventions".

Step 4 — Hooks

Deliverable — rituals, not a file. Determine the repo's harnesses and stitch the surface of each in the working tree (Claude Code hooks file, OpenCode project plugin directory; Codex hooks live in CODEX_HOME, outside the worktree, and are not stitched) by references/harness-surfaces.md. Where there is no surface — say which ritual is not automated: it is held by the prose of the "Session Lifecycle". Do not write a config of a format you are guessing at.

A hook is measured by its cost in context and by what it teaches: one line and a pointer to a section of AGENTS.md, not a retelling of the ritual; the trigger is on the event itself; it is not installed if the same line arrives by another path (tool description, skill door); it does not teach the opposite rule (does not punish a legitimate question to a human). Only a hook with an unambiguous path blocks (memory-guard).

Claude Code: hooks in .claude/settings.json (committed). Merge, never overwrite — records of other sets remain alongside in the same arrays. Envelope: "<Событие>": [ { "matcher"?: …, "hooks": [ { "type": "command", "command": "… echo '{\"hookSpecificOutput\":{\"hookEventName\":\"<Событие>\",\"additionalContext\":\"<строка>\"}}' || true" } ] } ] — nesting событие → массив → hooks is easy to confuse. Open references/hooks.md and project the push and merge filters from there byte-for-byte, with verification samples. When projecting the filter into JSON, double every backslash (\n → \\n) and escape the quotes \": otherwise the filter does not compile, the hook goes silent forever, and || true hides this. The hooks write the run themselves, like the whole arc of cycle 2. A harness asking permission to write .claude/settings.json as self-modification is its limitation, not the norm: name it with a word in the report and verify by reading that the write landed. Hooks:

SessionStart → read the “Start” section of the door iskron before actions; repo addresses (graph, focus contour, seq of agent and owner roles); standing only on watch (the word “watch”, start, the address of the place from the window, frame), with one iskron_stand; start <граф> <роль> <дело №N> enters the case; the subagent has its own bridge-satellite (iskron_stand с satellite_of, join, leave — on it), on the bridge of the one who launched it, it does not write to the graph. Do not retell the start protocol.
PostToolUse/Bash — push: git push worked (by outcome, the reference does not wake) → push shipped nothing: self-check of the diff, dictionary pass over the PR text, cold review of the stage (the section on review in AGENTS.md); shipping is merge.
PostToolUse/Bash — merge: the forge merge merged the PR (by outcome) or the trunk pull (git checkout main && git pull) → acts after merge from “Session Lifecycle” (punctures, advance the map, modes by evidence, close along the axis, reconcile, feedback reflection, if agreed, dictionary pass; for work via an agent’s link — only the transformation seed and delivery modes). The hook message also names the exception — with the same list as the section AGENTS.md, otherwise the ritual and the hook diverge.
PreToolUse Write|Edit|MultiEdit|NotebookEdit — memory-guard: path inside the local project-memory directory → block (exit 2, routing message to stderr). The route is from the message slots references/hooks.md: a project graph named from the frontmatter's "Graph" field, the persistence section — as a heading, as it appears in AGENTS.md, in the file's language, and a personal graph @handle/mind.
PostToolUse Write|Edit — spec-write (full interop only, per the AGENTS.md interop stamp): the path looks like a design/spec doc → a reminder that a design record is a graph.
Branch freshness — suggest a pre-push hook (references/hooks.md).

OpenCode: a plugin in .opencode/plugins/ following the example of references/harness-surfaces.md. Event stream ctx.event.subscribe one per OpenCode server of the machine: the project plugin sees session.created and other session events from all directories, and a greeting with this repo's addresses that lands in someone else's session puts it under someone else's role. A subscriber writes only to its own directory's session: the event's directory (location.directory of the event or its data) is checked against ctx.location.directory canonized ones (realpath, on error — the string, without a trailing separator) — one folder arrives sometimes as /tmp/…, sometimes as /private/tmp/…, and a raw comparison loses its own session; someone else's — skip. Hooks ctx.tool.hook are woken only by a call in the instance's directory; they are required to do one thing — run as written, without undefined names or throws, except for the guard on the memory path. The greeting carries the same addresses as SessionStart, the guard's refusal — the same route as Claude Code's memory-guard: the template slots of the example (<Граф>, <Фокус-контур>, <Роль агента>, <Роль владельца>) are filled from the AGENTS.md frontmatter, <Раздел персистентности> — with its heading, as it stands in the file, — in the repo plugin no angle brackets remain. The check — from the repo root node ~/.iskron-bridge/iskron-bridge.mjs check-rituals, on the run and on refresh: code 1 — a hole or a breakage (the line names the plugin, what happened, and the fix), rewrite following the example, run again, name it in the report. No check-rituals в --help home bridge (the bridge is older) or no bridge at all (no file, node responds MODULE_NOT_FOUND) — read each .opencode/plugins/* with your eyes according to this rule and name in the report that the reviewer was not run.

Self-check: the four base hooks are in place (start, push, merge, memory-guard); hooks removed by previous contracts (the no-freezing guard on Stop, a pointer of the writing moment on writing tools), no — on refresh remove your own, without touching others'; spec-write is if and only if, when the interop stamp says full; SessionStart calls the «Start» of the door iskron (not entry) with real addresses; push and merge filters — byte-for-byte from references/hooks.md and verified on samples from there; the memory-guard refusal — in the hook and in the OpenCode plugin — names the repo graph, the persistence section with a heading from AGENTS.md и @handle/mind, without angle brackets; a bare prohibition without a route (contract up to 24) — rewrite; check-rituals (or reading by the rule) did not find in .opencode/plugins/* holes and breakages; not a single foreign record fell out.

Step 5 — Repository Hygiene

references/step5-hygiene.md — open and execute in full at this place of the procedure. Core: .claude/settings.json is committed, settings.local.json is ignored; tracked secret/env — the rule «do not stage» in the «Code Conventions»; the project memory directory — evacuate to homes, then freeze (stub and guard); forge and CLI are derived from git remote -v, not assumed; «Stack», «Commands», «Structure», «Conventions» — by maturity, without TBD; HANDOVER.md is not started; the root README — short, for a human.

Step 6 — Role sub-agents of delegation

references/step6-roles.md — open and execute in full at this place of the procedure; doctrine and file templates — references/delegation-1.md, references/delegation-2.md (open and read both parts in order before the move), it is not projected into AGENTS.md in prose. Core: six roles (reader, searcher, worker, designer, reviewer, verifier) in each repo harness, models by tiers, in OpenCode — pinned from the user's setting; each Claude Code file has its own satellite-bridge entry of one form for all OSes, copied from the reference; a voluminous judgment without a record in the graph — designer, the graph, decisions and dialogue — to the lead; do not touch foreign bodies; self-check of files and doctor; a role projected in this session may not be called — say so in the report.

Step 7 — Finalization

references/step7-finalize.md — open and execute in full as the last step. Core: the body — AGENTS.md, the carriers — REALITY.md, the pointer CLAUDE.md by platform shape; legacy config — re-projection of the derivative while preserving the author's; verification pass over the entire artifact against the source and the density pass — on equal footing; canon blocks are checked against the node byte-for-byte; the stamp is a contract from the header and the date; the cover is a YAML frontmatter, no placeholders, no notes; gotchas are not in AGENTS.md; REALITY.md verified; every skill name is resolved on the installation channel; the relay is a roadmap teaser and open slots in practice.