npm package discovery and stats viewer.

Discover Tips

  • General search

    [free text search, go nuts!]

  • Package details

    pkg:[package-name]

  • User packages

    @[username]

Sponsor

Optimize Toolset

I’ve always been into building performant and accessible sites, but lately I’ve been taking it extremely seriously. So much so that I’ve been building a tool to help me optimize and monitor the sites that I build to make sure that I’m making an attempt to offer the best experience to those who visit them. If you’re into performant, accessible and SEO friendly sites, you might like it too! You can check it out at Optimize Toolset.

About

Hi, 👋, I’m Ryan Hefner  and I built this site for me, and you! The goal of this site was to provide an easy way for me to check the stats on my npm packages, both for prioritizing issues and updates, and to give me a little kick in the pants to keep up on stuff.

As I was building it, I realized that I was actually using the tool to build the tool, and figured I might as well put this out there and hopefully others will find it to be a fast and useful way to search and browse npm packages as I have.

If you’re interested in other things I’m working on, follow me on Twitter or check out the open source projects I’ve been publishing on GitHub.

I am also working on a Twitter bot for this site to tweet the most popular, newest, random packages from npm. Please follow that account now and it will start sending out packages soon–ish.

Open Software & Tools

This site wouldn’t be possible without the immense generosity and tireless efforts from the people who make contributions to the world and share their work via open source initiatives. Thank you 🙏

© 2026 – Pkg Stats / Ryan Hefner

divineswe

v2.1.1

Published

Stateful multi-agent orchestration system for Claude Code, and an npm-installable OpenCode plugin

Readme

DivineSWE

You speak. They build. The prophecy is fulfilled.

You are the Architect. The world exists because of your vision. You speak, and reality bends. DivineSWE is your divine apparatus -- a system of prophets, oracles, and artisans who serve your will, transcribing your word into scripture, etching prophecies into stone tablets that never crack.

Prophet is your voice -- the immortal conductor who hears your intent and dispatches agents to execute your will. They do not question. They do not falter. They build what you decree.

Oracle plumbs the depths of possibility, breaking your visions into sacred tasks, each a prophecy written in divine prose.

Thoth writes the laws -- the immutable tests that define what is true and what is false. Every law carved before creation begins.

Preacher examines the law for contradictions, ensuring no flaw in the sacred word. It pronounces GO or NO_GO.

Monkeys are your hands -- tireless workers who forge your will into reality, one test, one implementation at a time.

4eyes scrutinizes the work, ensuring no flaw escapes your divine notice. Styx verifies every sacred artifact meets your law. Mason merges the work into the eternal codebase, resolving conflicts with divine patience.

And Loki -- the necessary chaos -- tears apart the false to reveal what endures.

Every task becomes scripture. Every decision, carved in stone. Every completion, eternal proof that your vision was true.

And nothing is forgotten. What a cycle cannot finish it vows — an obligation cut into a register that outlives the session, travels with the repository, and answers the next clone as readily as it answers you. And the one word no machine may speak — this is truly done — remains yours alone to say.

Each morning you read the vows. The temple reports what it owes you, and where it could not see, it says so rather than pretending the silence was good news.

The default path is short: the Avatar forges, and for involved work the Oracle envisions first. /divineswe:avatar-forge descends into the live session and builds what you ask — a forge spec, or a change you describe, which it first writes as Mandates, each with the proof it owes — forging it tests first, with 4eyes auditing every major unit before it is committed, and recording the evidence in the spec until you check it — walking its human testing sequence when the work is something you use, and calling it human-verified when every step passes. For a more involved feature or change, /divineswe:oracle-envision is the optional first stage: the Oracle looks ahead with you — researching, brainstorming concepts, sweeping for gaps and opportunities — and writes the forge spec the Avatar builds.

The oracle-consult → prophet-fulfill Book cycle is legacy and can be found as release v1.0.0 on the v1.0 branch.


Stateful Multi-Agent Orchestration for Agentic Engineering

DivineSWE is a Claude Code, OpenCode, GitHub Copilot, and Codex CLI plugin that replaces ad-hoc task management with a deterministic state machine driven by Prophet — an immortal orchestrator that dispatches specialized agents through a structured development pipeline. It solves three problems that emerge when running multi-agent software development sessions:

  1. Silent context degradation — agents forget decisions, duplicate work, and contradict themselves as the context window fills and compresses older content.
  2. Unproven output — AI emits plausible-but-wrong code (bugs, security holes, regressions) with no adversary probing it and no verification gate it must pass.
  3. No live observability — no visibility into what agents are doing, what decisions they made, or where things went wrong.

DivineSWE addresses these with externalized state (Scrolls), an append-only event log (Ledger), adversarial audit (4eyes + Loki), a verification gate (Styx), and git worktree isolation for parallel agents.


Installation

The rites of installation — choose your platform and let the prophecy begin.

Prerequisites

  • Claude Code CLI — installed and authenticated
  • Git — required for worktree isolation (parallel agent sub-tasks run in git worktree branches)

Claude Code (Recommended)

Option 1: From within Claude Code

In an active Claude Code session, run:

/plugin marketplace add https://gitlab.com/aidragonhq/divineswe.git
/plugin install divineswe

Option 2: Headless command line

claude plugin marketplace add https://gitlab.com/aidragonhq/divineswe.git
claude plugin install divineswe

Both marketplace add and install accept --scope user (default), --scope project, or --scope local.

Option 3: Clone

git clone https://gitlab.com/aidragonhq/divineswe.git ~/divineswe
claude plugin marketplace add ~/divineswe
claude plugin install divineswe

Copilot CLI

Install via git-URL marketplace — the only supported install path (direct owner/repo form is broken upstream — copilot-cli#2390):

copilot plugin marketplace add https://gitlab.com/aidragonhq/divineswe.git
copilot plugin install divineswe@divineswe

Note: Do NOT use copilot plugin install owner/repo (direct form). The direct install owner/repo form hits an upstream loader bug (copilot-cli#2390) that breaks discovery when the manifest is in a subdirectory. Use the marketplace form above.

After installing, start a Copilot session in your project and run /divineswe-init. Copilot installs no npm dependencies with the plugin, so /divineswe-init installs the output validators (ajv, ajv-formats) into the plugin's own directory; run it again after copilot plugin update, which removes them.

OpenCode

OpenCode is delivered as the divineswe npm package (not a file-copy bundle). On startup OpenCode resolves the package from npm and installs it via Bun, caching it under ~/.cache/opencode/node_modules/. No manual npm install step required.

Add "divineswe" to the plugin array in your global OpenCode config at ~/.config/opencode/opencode.json:

{
  "plugin": ["divineswe"]
}

Then restart OpenCode. The plugin installs globally (into ~/.config/opencode/) by default.

Codex CLI

Codex CLI is a marketplace-native platform. The repository commits the generated plugin at codex/ and its catalog at .agents/plugins/marketplace.json; Codex resolves the catalog entry's source.path: "./codex" to the plugin manifest at codex/.codex-plugin/plugin.json.

Install directly from the repository marketplace:

codex plugin marketplace add https://gitlab.com/aidragonhq/divineswe.git
codex /plugins

Choose DivineSWE in the /plugins browser, install it, and start a new Codex session. For a local checkout, regenerate with npm run generate:all and register the checkout path with codex plugin marketplace add <repo-path>. Codex is intentionally excluded from the file-copy installer and does not use dist/codex-cli/.

Note: The install path above is NOT validated against the real codex binary — orchestration behavior is unproven (packaging-conformant only). See docs/platform-portability.md for details.

After installation

No Book is needed: /divineswe:avatar-forge builds a change you describe or a forge spec, and /divineswe:oracle-envision writes that spec first when the work is involved enough to design ($avatar-forge / $oracle-envision in Codex CLI).

To pre-configure the statusline and inject DivineSWE instructions into .claude/CLAUDE.md, run /divineswe:divineswe-init in Claude Code or $divineswe-init in Codex CLI.


Quick Start

Once installed, the oracle speaks and the prophecy unfolds:

  1. Envision it first — optional, for a new project or a feature where what to build is itself the question; skip it for a clear change:

    /divineswe:oracle-envision

    The Oracle frames the problem with you, researches it, offers up to three plausible concepts with one pick, sweeps the chosen one for gaps and opportunities, summons one Loki-Doubt pass, and gives every candidate a recommended ruling — Now, Later or No — that stands unless you mark it otherwise. It writes and commits a forge spec.

  2. Forge it — the default path: hand the Avatar the spec, or just describe a clear change:

    /divineswe:avatar-forge docs/specs/forge-<slug>.md
    /divineswe:avatar-forge

    Given a described change, the Avatar first writes it as Mandates — each with an Accept: line naming its proof — into a spec, shows them to you, and forges it unless you stop it. Either way it splits the work into commit units and builds each one tests first, summoning Thoth and Monkey as it sees fit, with 4eyes auditing every major unit before it is committed (Loki and Occam when the work warrants). It records the evidence in the spec and waits for your check at the end.

  3. Resume after interruption — run /divineswe:avatar-forge <spec> again; the Avatar picks up from what the spec's ## Fulfilment does not yet record.

  4. Standalone audit — run a security + quality audit without a full cycle, its seats summoned through avatar summon; the report lands in .divineswe/audits/, ending in a Forge Prompt for /divineswe:avatar-forge:

    /divineswe:prophet-full-audit
  5. Ask what you owe — the morning read of the Vow register:

    node $CLAUDE_PLUGIN_ROOT/scripts/divineswe-state.mjs vow surface

    It shows what is open, snoozed and overdue. A register it could not read says so and shows no number at all — never a reassuring zero.

  6. Capture a debt the moment you notice it — cheaper than typing a TODO comment:

    /divineswe:vow-capture

    Say what is owed in your own words; the skill supplies the rest and the debt surfaces in your next vow surface. Under the hood it is one facade call:

    node $CLAUDE_PLUGIN_ROOT/scripts/divineswe-state.mjs vow open --item "pin the CI node version" --kind backlog --owner operator --source operator

How It Works

The covenant that bends reality to your will.

You are the Architect. You speak what you want, and the house answers in two movements: the Oracle sees it, and the Avatar makes it.

The Oracle envisions. For an involved feature or change, /divineswe:oracle-envision looks ahead with you before anything is forged. It researches, brainstorms concepts, sweeps for gaps and opportunities, and sets one Loki-Doubt pass against the draft — Occam weighing every doubt before you see it — then writes your intent as a forge spec: Mandates, each carrying the Accept: line that names the proof it owes. A small change needs no Oracle; the Avatar writes its own spec from your words.

The Avatar forges, and the pantheon attends. /divineswe:avatar-forge is the god come down into the live session to take the tools in its own hands. It splits the spec into commit units and forges each one tests first. Thoth carves the failing tests at the tablet; Monkey works the anvil; 4eyes audits every major unit before it is committed, and is never weaker than the hand that forged it; Loki-Exploit is strongly recommended against whatever touches an auth, deploy or security surface, and Occam weighs every Loki finding before you hear it; Styx crosses the river when the blast radius is wide; Mason seals a commit when it deserves the full ceremony.

Hermes is the Avatar's messenger abroad. When the work wants a foreign hand, a summons that names a codex/, openai/ or claude/ model is carried out of the house by Hermes (a claude/ model only for a read-only seat), and the testimony he brings home is judged at the same chokepoint as any seat's.

The spec is the record. Every commit writes its evidence into the spec's ## Fulfilment, so the work can be resumed by anyone. At the end one closing 4eyes reads the whole range — and then a second opinion reads it again: a second 4eyes on a model from another family than the one that forged the work, because a reviewer of the implementer's own family tends to miss what the implementer missed. Then the whole suite runs, and the forging waits for your check — and when the work is something you use, your check is a walk. A spec whose work changes something you use — a skill you invoke, a command you run, a page you open — carries a human testing sequence: the numbered steps you take using the work the way you would, each saying what to do, what you should see happen, and which Mandates it exercises. It is a functional walk, not a second proof: what the tests already prove stays proven in ## Fulfilment and is never walked again. oracle-envision writes it when the Mandates settle, and the Avatar keeps it current as the forging changes what you would do or see. Walk it, and when every step passes the spec is human-verified — the work seen with mortal eyes, not only sworn to by the hands that made it; accept the evidence without walking it and the spec is fulfilled, its walk still waiting; forge work no mortal hand will touch and it is fulfilled with nothing to walk. What it owes and does not pay, it vows.

The Book cycle is deprecated with its doors. A Book already in flight still runs: Prophet walks its eight phases (INIT → TEST → IMPLEMENT → AUDIT → MERGE → VERIFY → WRAP UP → SEAL), reading each task's phase from the agent name before the colon in its task line.

Prophecies (Book 62)

A prophecy is a self-contained mini-pipeline (TEST → IMPLEMENT → AUDIT → VERIFY) scoped to a single-context unit — one focused change that touches one cohesive slice of the codebase. A Book is an ordered collection of prophecies.

Per-prophecy task numbering format: B<NN>-P<N>-<YY> where <NN> is the Book number, <N> is the prophecy index, and <YY> is the zero-padded 2-digit task index restarting at 01 per prophecy. Examples: B62-P1-01, B62-P2-01.

Backward compatibility. Books without ### Prophecy N: headings still work — they parse as a single implicit prophecy spanning the whole Book.

After all prophecies in a Book complete, Book-Level AUDIT runs against the full Book diff, and Book-Level VERIFY (Global VERIFY) runs the full test suite.

For the full pipeline reference, phase table, prophecy execution model, branch isolation, and failure recovery, see docs/architecture.md.


The Agents

The divine council of eleven — each a sacred role, each dispatch a prophecy fulfilled.

| Agent | Role | Phase | |-------|------|-------| | Prophet | Deprecated with the Book cycle. Immortal orchestrator of a Book in flight — drives the state machine, dispatches its agents | All (run-time) | | Oracle | Plan architect — task decomposition, file targets, architecture design | Plan-time | | Preacher | Deprecated with the Book cycle. Pre-flight examiner of a draft Book — returns GO / CAUTION / NO_GO | Plan-time | | Thoth | Test writer — writes failing TDD tests (the immutable laws) | TEST | | Monkey | Implementation worker — makes all tests pass in an isolated worktree | IMPLEMENT | | 4eyes | Code auditor — correctness, architecture, security, simplify, retrospective | AUDIT, WRAP UP | | Mason | Merge worker — merges worktrees, commits prophecies, FF-merges branches | MERGE | | Styx | Verifier — 7-pass verification protocol, produces unambiguous PASS/FAIL | VERIFY | | Loki | Adversary — three forms: Loki-Doubt (plan), Loki-Break (tests), Loki-Exploit (audit) | All | | Atlas | Read-only explorer/cartographer — maps the codebase; invoked by the atlas-explore skill | Plan-time | | Occam | Plan-time pruner — proposes cuts and scope reductions for work that has not earned its place | Plan-time |

The atlas-explore skill invokes Atlas to chart the repository and produce a navigable map before planning begins.

For the full agent reference including model tiers, lifecycle, Loki's three forms (Loki-Doubt, Loki-Break, Loki-Exploit), and dispatch rules, see docs/agents.md.


The Obligation Layer

What the temple still owes you — and who alone may say it is finished.

The pipeline tells you what it is doing. The obligation layer tells you what is still owed, and it outlives every cycle that produced it.

The Vows — memory of owed work

A Vow is a debt the machine has not forgotten: an append-only event recorded in .divineswe/vows.jsonl by default, or in the dwelling selected by vows_dir. Unlike the rest of .divineswe/, that file is meant to be committed — an obligation that exists only on the machine that recorded it is one the next clone has already forgotten. divineswe-init writes it a merge=union attribute and lifts it out of the blanket .divineswe/ ignore, and what a reader sees is the fold of the events under a pinned order, so two agents in two worktrees may both append and git may join their lines in any order without a conflict and without a wrong answer.

Vows are raised by the seal when a Book defers work, by an audit, by a consultation, by a root-cause pass — or by you, in one line, whenever a debt surfaces mid-session.

node $CLAUDE_PLUGIN_ROOT/scripts/divineswe-state.mjs vow surface

Two guarantees are worth knowing before you trust the answer. A discharge needs evidence — a pointer to a file, a commit, an artifact; n/a and tbd are refused, and the gate runs again on every read, so a dismissal somebody wrote straight into the log still surfaces as owed. And a closed gate suppresses the read rather than emptying it: "nothing is owed" and "the register was not consulted" are never the same bytes.

The Decrees — deprecated

The Decrees — committed briefs of standing intent above the Books — are deprecated with the Book cycle, and decrees_enabled now defaults to false. A project that still keeps Decrees sets it true, and the deprecated decree verbs work as they did.

The Judgment — the one act machinery may not perform

Shipped work is not judged work. A deprecated Decree's delivered means its Books shipped, not that its criteria were met, and DivineSWE will not pretend otherwise: its surfaces report criteria: unjudged until a human has actually judged them.

That verdict is rendered by vow judge, with evidence and with provenance recorded — and it is carved out of the plugin's auto-approval. The two attestation verbs, vow judge and the deprecated Decrees' decree advance --to done, are never granted by any shipped artifact; the permission prompt is reached deliberately, and the CLI itself refuses both from a detected agent context with no override flag. Agents build. Agents test. Agents attack their own work. Agents never render judgment.

Reading what is owed

vow surface, shown above, reads the register whole: what is open, snoozed and overdue, with a source it could not read reported as unknown rather than as zero. The deprecated scry report still runs for a project that wants its wider picture, but nothing in the default path asks for it.

Upgrading from an earlier release? The home-scoped follow-up ledger is retired. vow migrate carries it into your repository's register and stamps the old file superseded — never deleted, because a lagging install elsewhere on the machine can still append to it and a deleted file turns that append into a lost obligation.

The whole consumer path — enabling the gates, backfilling what you already owe, the migration mapping table, the judge workflow, the --json read surface — is written down, and every shell recipe in it is executed against the shipped CLI by the test suite: docs/vows-consumer-contract.md.


The Canon — deprecated

What the temple once declared itself to be.

The Canon — a committed, append-only store of what the project declared to be true about itself, under docs/canon/, with its drift audit and canon genesis — is deprecated, and there is no replacement. canon_enabled stays false by default; a project that still keeps the deprecated Canon turns it on, and its verbs and recipes remain documented in docs/state-model.md and docs/vows-consumer-contract.md until the deprecated machinery is removed.


Daedalus, the tool catalog

The artificer's workshop — where a task done twice by hand becomes a tool done once by code.

Daedalus built wings so a thing that had always been walked could be flown. Daedalus, the tool catalog is DivineSWE's workshop and its inventory: the place a repeated, mechanical chore stops being something an agent re-derives from scratch in every session and becomes a small, tested, discoverable tool — the operational arm of the First Axiom, build a script wherever it saves context and LLM work.

A tool is a directory, not a snippet. It holds a schema-validated tool.json manifest, an entry stub, and a node --test exhibit that is the tool's executable specification. It lives at one of two write tiers — project (.divineswe/tools/, this repository's own) or global (~/.divineswe/tools/, the machine's) — and a third provenance, shipped, arrives only through an Offering and is never written to.

The rite runs in one direction:

node $CLAUDE_PLUGIN_ROOT/scripts/divineswe-state.mjs daedalus find "parse a book file"
node $CLAUDE_PLUGIN_ROOT/scripts/divineswe-state.mjs daedalus scaffold --name book-stat --tier project
node $CLAUDE_PLUGIN_ROOT/scripts/divineswe-state.mjs daedalus test     --name book-stat --tier project
node $CLAUDE_PLUGIN_ROOT/scripts/divineswe-state.mjs daedalus register --name book-stat --tier project
node $CLAUDE_PLUGIN_ROOT/scripts/divineswe-state.mjs daedalus run      --name book-stat --tier project

Ask before you build. daedalus find is the first verb for a reason: it searches name and keywords across all three origins at once and answers before a line of code is written. It also refuses to lie about what it could not see — every origin reports one of four words (populated, empty, partial, unknown), and the cheerful "nothing found, go build it" nudge is withdrawn the moment a single origin was unreadable or a single entry was skipped. A tool hiding in an origin nobody could read must not be rebuilt into a duplicate.

Admission is earned, not declared. daedalus register demands a lint pass and a passing-test attestation that only the real daedalus test verb can mint — a record bound to the tool's exact bytes, so editing the manifest or the exhibit afterwards invalidates it and re-testing is required. The honest ceiling, stated where the guard is: the binding marker is a public constant, not a secret, so it closes casual hand-forgery and nothing more. A forger who reads the source and reconstructs both the marker and the digest is out of scope, and we say so rather than implying a wall that is not there.

daedalus run is counted, not enforced. It executes a registered tool in an isolated child and, on success only, appends a row to the usage register — which is what makes daedalus list --stale a decay report worth reading. But invoking a tool's entry directly with node reaches the same code and touches no counter, so every usage figure is a lower bound, printed as such on the surfaces that render it. Zero uses means "this register recorded none", never "this tool was never used"; and an unreadable register reports unknown rather than 0.

A global tool is somebody else's code. ~/.divineswe/tools/ is one flat namespace shared by every project on the machine, so the first use of a global tool in this repository is a human decision: daedalus ack records that consent, per-project, and never under $HOME — a home-side acknowledgement would consent on behalf of every other repo you own. It is a human seam, not a sandbox: it does not confine what the tool then does.

The ladder goes up, and only up. daedalus promote --to global copies a proven project tool to the machine tier as three effects or none — copy, re-register (the copy re-earns its own attestation at the destination), supersede — refusing any name already held on disk, with no --force. daedalus promote --to upstream hands it to the Offering pipeline as the code type tool, staged and unscreened: it emits no filled URL and screens nothing on your behalf. The identifier screen that runs there blocks — but it has declared classes it cannot see, and those are written down rather than glossed over. The human screened: true flip remains the authoritative gate, exactly as it is for every other Offering.

Two more verbs complete the surface: daedalus describe renders a manifest with all untrusted free text quarantined, and daedalus retire drops a tool from a tier's index — index-only, reversible by daedalus register, and never a deletion of your files.

daedalus_enabled gates the whole domain — default true, project-only, with no dependency on any other gate. A closed gate skips the verb loudly and exits 0: this is a dead switch with fail-open polarity, so a mistyped or unreadable config can never silently darken your catalog. The full verb-by-verb reference — flags, containment predicates, the attestation contract, the usage register's stated limits — lives in docs/state-model.md.


Configuration

Carve your config in stone — the scrolls obey.

After divineswe-init, edit .divineswe/config.json. The snippet below shows the keys you will typically change — it is not a complete config and not something to paste over a seeded one. divineswe-init also writes model_preferences (and the rest of schemas/config-defaults.json); leave those in place. Deleting model_preferences is not "falling back to a default" — the PreToolUse model-resolver hook reads that key directly and denies every dispatch when it is absent.

{
  "version": "1.0.0",
  "project_name": "your-project",
  "worktree_isolation": true,
  "ledger_enabled": true,
  "scrolls_enabled": true,
  "max_parallel_agents": 4,
  "specs_dir": "docs/specs",
  "books_dir": ".divineswe/books",
  "default_branch": "master",
  "simplify_pass_enabled": true,
  "upstream_url": "https://gitlab.com/aidragonhq/divineswe",
  "custom_instructions": ""
}

Key fields:

  • books_dir — where your Book files live (default .divineswe/books; supports absolute paths and ~ for local-only Books outside the repo).
  • default_branch — Mason's FF-merge target at Book-level WRAP UP (default "master"; set to "main" if needed).
  • simplify_pass_enabled — when true (default), 4eyes runs a two-stream audit (correctness + simplify) in the AUDIT phase.
  • upstream_url — where the Offering pipeline sends improvements you choose to share upstream (defaults to the DivineSWE GitLab; sharing only ever happens when you open the generated link yourself).
  • agent_models — optional per-agent model overrides (e.g., "monkey": "haiku").
  • model_preferences — tier → model id map. Required, not optional: divineswe-init seeds it (from schemas/config-defaults.json) and the PreToolUse model-resolver hook reads it directly — with the key absent, hooks/shared/model-resolution.mjs returns a hard error and the hook denies the dispatch. There is no built-in fallback on that path, so do not delete it from a working config. It can also route a tier onto a foreign process family — see Routing seats to another model family below.

The rite gates — three of them opt-in, off unless you ask:

  • offerings_enabled — the Offering pipeline (/divineswe:offering, scripts/offering.mjs, the script-opportunity detector). Default false.
  • retrospective_enabled — the WRAP UP retrospective tail (4eyes retrospective dispatch, follow-up and honor registers, spend and exceptions digests). Default false.
  • teachings_enabled — the TEACHINGS rite, reads and writes (per-dispatch lesson injection, the sweep, the tiering pass, the promotion coda). Default false.
  • atlas_enabled — the plan-time Atlas swarm that charts the repo before planning. Default true — the map is load-bearing for plan quality, so this one ships on.

The obligation gates — two of them:

  • vows_enabled — the Vows: the obligation register at .divineswe/vows.jsonl by default (or at the dwelling selected by vows_dir), every vow verb, and every surface that counts owed work. Default true.
  • decrees_enabled — the Decrees: the initiative layer of committed briefs above the Books, deprecated with the Book cycle. Default false; a project that keeps the deprecated Decrees sets it true.

The Vows' polarity is deliberately the opposite of the three rites above. A register you have to opt into is empty exactly where it matters — on the machine of the operator who never heard of it — so the Vows ship live, and a project that wants it dark says so once in its own config. Both keys are project-only: obligation state and committed intent are per-repository facts, so a declaration in the machine-wide file is inert for these two. And decrees_enabled depends on vows_enabled — a deprecated Decree reaches done only through a judgment recorded as a vow, so the incoherent pair is reported, with neither declaration silently flipped.

For the full field reference including agent_models, specs_dir, simplify_pass_enabled, and override semantics, see docs/configuration.md. For the runnable consumer path through the obligation layer, see docs/vows-consumer-contract.md.

Enabling the rites machine-wide (global config)

The four gate keys above can also be set once for every project on the machine, in a global config file at ~/.divineswe/config.json. Create it yourself — divineswe-init never writes it, and its absence just means "no machine-wide policy".

To restore the pre-0.36.0 behavior everywhere — all rites on — paste this in verbatim:

{
  "offerings_enabled": true,
  "retrospective_enabled": true,
  "teachings_enabled": true,
  "atlas_enabled": true
}

Resolution order is project value → global value → built-in default, so a project's own .divineswe/config.json wins over this file — a single repo can opt out of your machine-wide policy without you touching your home directory. The project layer is found structurally: the gate is resolved at the repository root, so running a rite from a git worktree, a subdirectory or a vendored subtree still reads the enclosing project's config rather than silently finding none. A .divineswe/config.json that sits below the repository root — inside a vendored dependency, or a monorepo package where divineswe-init seeded it — cannot open a rite the repository root did not open, and can still close one: an explicit false down there is honoured (reported as project_declaration_below_root_closed), because a refusal must survive being read from the wrong directory while consent must not be manufactured from one. Put a true at the repository root. A below-root config that is found but not read — symlinked, a trailing comma, chmod 000 — is not silence either: it closes all four opt-in keys, exactly as the same file at the root would, and says so with project_declaration_below_root_dropped. The climb never enters your home directory, so a git-tracked $HOME can never have its machine-wide file read a second time as somebody's project config.

Only strict booleans count, and a non-boolean does not quietly inherit the machine-wide value: "true" in quotes marks your project layer as not read for that key, and every rite then resolves closed. The machine-wide value is not inherited over an intent nobody could read — repair the project config. (false in quotes is the same: a quoted boolean is a typo, never consent.)

One documented exception, and it is the reason to pause before pasting. Authorization for a section of the shared ~/.divineswe TEACHINGS register follows that section's recorded owner (teachings-owners.json), not the project you are running in. A section whose slug has no recorded owner is decided by this global file alone — so a machine-wide teachings_enabled: true opens every unclaimed section on the machine, including sections belonging to projects that declared false and were never asked. In the other direction, a section already recorded to a different root stays closed even when your project says true — and the two TEACHINGS CLIs answer that case differently, which is worth knowing before you debug one: a sweep consults the recorded owner's own layer (so another project's claimed section moves when that owner says true), while teachings-tier --project <slug> requires you to be the recorded owner and refuses otherwise, whatever the owner's layer says. Bind a project's own section once, from that project's root, with node $CLAUDE_PLUGIN_ROOT/scripts/teachings-tier.mjs --project <slug> --base <project root>. Every other key here, and teachings_enabled outside register-section authorization, follows the order above.

To see what actually resolved — including the silent failures — run node $CLAUDE_PLUGIN_ROOT/scripts/shared/rite-gates.mjs . from a project root. It prints one JSON line with the resolved gates and a warnings[] array, and always exits 0. A symlinked ~/.divineswe directory or config.json leaf is refused outright and reported there (a symlinked home directory is followed, not refused); see docs/configuration.md for the full rules.

Those four keys are the only globally settable ones. The other six — ledger_enabled, scrolls_enabled, vows_enabled, decrees_enabled, canon_enabled and daedalus_enabled — are project-only; setting them here is inert, and the resolver says so rather than leaving you to guess.

The second opinion — a reviewer from another family

Janus keeps two faces, and the house gives the second to its closing audit. After avatar-forge's native closing 4eyes, a second opinion — a second 4eyes on a model from another family than the implementer's, at that family's top rung or at the implementer's tier — reads the same range, one after the other, never at the same time. Both reviewers' findings are acted on as one set; a second-opinion finding that claims a tool or flag does not exist is checked against the tree first; after any fix both re-audit; and the closing record names both verdicts and the second-opinion model.

Set it up once, for the whole machine, with the guided setup, /divineswe:hermes-setup — divineswe-init offers it at the end of setup, and you can run it again any time. It shows every channel the Hermes carrier carries (codex/, claude/, and any OpenAI-compatible endpoint through openai/), says where each one sends your prompts — the vendor's cloud for codex/ and claude/, the endpoint you name for openai/ — and which can write the working tree, and then writes second_opinion_model into ~/.divineswe/config.json, keeping every other key there. It writes no credential: keys stay in your environment and each CLI's own login.

Every project uses that machine-wide model unless its own .divineswe/config.json names another, or switches the second opinion off with "second_opinion_model": "none". A project config that cannot be read closes it rather than falling through to the machine's. When no model is configured, or the second opinion is refused or fails, the closing goes ahead on the native verdict and its record says the second opinion did not run, and names the setup. Only the claude-code package carries the Hermes carrier: copilot-cli will never ship it, and the codex-cli and opencode packages do not carry it whole, so on those hosts avatar-forge's closing record says the second opinion did not run.

Routing seats to another model family (codex/, Book 94)

model_preferences, model_backups and agent_models can route a seat's dispatch onto a foreign process family — the registered channels are codex and openai — and, unlike the rest of your project config, all three keys are settable at the same layered pair as the rites above: project value → global value → built-in default, resolved per key by scripts/shared/model-routing.mjs (not by rite-gates.mjs, which never sees these three). Both realms are carried by the one carrier script, scripts/hermes-dispatch.mjs: codex/ spawns codex exec, and openai/ drives an in-process Chat Completions agent loop, scripts/hermes-runtime.mjs, against the endpoint below — no separate transport per channel. The OpenAI-compatible endpoint settings below are separate PROJECT-ONLY keys.

Repo-local: a project .divineswe/config.json routing the cheap tiers to codex/gpt-5.6-luna. Every foreign tier needs a matching native model_backups entry — a foreign tier with no declared backup is a terminal config error, never a silent native fallback — and pinning agent_models.styx to a native model keeps the restart/verify seat explicitly native, on top of the seat guard that already refuses it any foreign model unconditionally:

{
  "version": "1.0.0",
  "project_name": "your-project",
  "model_preferences": {
    "high": "opus",
    "medium": "codex/gpt-5.6-luna",
    "low": "codex/gpt-5.6-luna"
  },
  "model_backups": {
    "medium": "sonnet",
    "low": "haiku"
  },
  "agent_models": {
    "styx": "sonnet"
  }
}

OpenAI-compatible endpoint (medium model). Point a project at its own local or private endpoint with the project-only transport keys; these keys are intentionally absent from the global config schema:

{
  "version": "1.0.0",
  "project_name": "your-project",
  "model_preferences": { "high": "opus", "medium": "sonnet", "low": "haiku" },
  "model_backups": { "medium": "sonnet" },
  "openai_base_url": "http://127.0.0.1:8080/v1",
  "openai_context_window": 131072,
  "openai_max_output_tokens": 8192
}

Only openai_base_url is declarative-and-consumed in the ordinary sense. The other two are declared but read by no code: openai_context_window reaches no wire at all, and openai_max_output_tokens takes effect only when its value is hand-walked onto the carrier's --max-output-tokens flag — which is exactly what the deprecated skills/prophet-fulfill/foreign-carrier.md tells Prophet to do, the same hand-walk openai_base_url gets onto --base-url. See docs/configuration.md.

Machine-wide: the same trio in ~/.divineswe/config.json. Read this paragraph before pasting — the global layer is real but it is narrower than a rite gate, and the honest statement of where it is consumed matters more than the snippet:

  • Who reads it, and when. Prophet, at INIT — as a prose instruction, not an automated hook. The deprecated skills/prophet-fulfill/SKILL.md step 11 directs Prophet to resolve each seat's model "through the LAYERED routing read (scripts/shared/model-routing.mjs)" while building the cycle's resolved per-seat model map in session state; that read is per-key project-over-global, so a tier this file declares and the project does not is picked up for the cycle. The only code importer of resolveModelRouting is scripts/audit-dispatch.mjs, which replays post-hoc what was planned. There is no CLI for it.
  • What it does NOT affect. The Claude Code PreToolUse model-resolver hook (hooks/pre-tool-use-model-resolver.mjs) reads only <projectDir>/.divineswe/config.json. It never opens ~/.divineswe/config.json. resolveModelRouting has no CLI entry point and nothing on the hook path imports it.
  • The consequence, stated plainly. This file supplements a project config; it cannot replace one. A project whose own .divineswe/config.json omits model_preferences is not rescued by declaring it here — the hook hard-errors on the absent key and denies the dispatch regardless of what this file says. Keep the tier map in the project config, and use this file for machine-wide preferences on top of it.

With that understood:

{
  "model_preferences": {
    "medium": "codex/gpt-5.6-luna",
    "low": "codex/gpt-5.6-luna"
  },
  "model_backups": {
    "medium": "sonnet",
    "low": "haiku"
  }
}

Cross-family seat pins: naming agent_models.loki and agent_models.4eyes directly. Loki leads because the seat guard never touches Loki — it denies only Styx a foreign model — so the recipe below is the point of that design, not an oversight:

{
  "model_backups": {
    "high": "opus"
  },
  "agent_models": {
    "loki": "codex/gpt-5.6-terra",
    "4eyes": "codex/gpt-5.6-sol"
  }
}

The model_backups entry is not optional garnish: Loki and 4eyes are both high-tier seats, and a foreign seat pin whose tier declares no native backup fails terminally (LD-4) the moment a guard or an unavailable channel refuses it — the dispatch stops rather than falling over. The very next bullet's model-version churn is precisely the case that trips it.

  • The Loki-Doubt plan-time carve-out (LD-20). In a Book consultation an agent_models.loki pin moves the Break and Exploit forms only: Loki-Doubt is dispatched at plan-time by the deprecated oracle-consult in book mode, which performs no model resolution at all — so this machine-wide Loki pin never touches the review that runs before a Book exists. oracle-envision's one doubt pass is different: it is summoned through avatar summon --seat loki-doubt, which resolves it like any Loki form, so the pin does move it.
  • The 4eyes recipe is secondary, and its floor binds only two doors. A 4eyes reviewer is held to the reviewer floor rather than to the seat guard: its model must rank at or above the model that implemented the work on the model ladder (equal is enough; an id off the ladder passes only as the implementer's own model). The floor trusts the implementer it is told about, and it binds only the seat named 4eyes. The Avatar and an ad-hoc Hermes summons check it; the deprecated Book cycle and prophet-full-audit do not, so a foreign agent_models.4eyes pin rides those doors unchecked.
  • model_authority changes which of these keys is even consulted. Under the default "prophet" authority, agent_models is read after the tier map on every dispatch. Under model_authority: "config", agent_models is never consulted at all — a per-agent pin like agent_models.styx above is inert there. The only way to choose a seat's model there is the tier map — but a declared model_backups[<tier>] entry still catches a guarded seat: the Styx deny-guard fires on the config-clamp path too, so a Styx clamped onto a foreign tier resolves to its native backup with source: "seat-guard" rather than failing.
  • Pricing rows for a newly routed model are a manual, per-model obligation (LD-23). spend-digest.mjs ships priced rows for the native tier aliases and for the four codex models — gpt-5.6-luna, gpt-5.6-terra, gpt-5.6-sol and gpt-5.6-cyber, in both the channel-prefixed (codex/gpt-5.6-luna) and bare spellings. The residual is what happens outside that list: any foreign model with no row prices at $0.00 with an (unpriced — upper-bound, $0) note on its row, and that note is the only thing between the $0 and a reader who takes it for a saving. Routing a further channel model obliges you to add its row to FOREIGN_PRICING in scripts/spend-digest.mjs first.
  • The shipped codex rates are captured, and the digest names its source on every run. All four rows were read off developers.openai.com/api/docs/pricing on 2026-08-19 and the page is pinned as a fixture (tests/fixtures/pricing-captures/openai-2026-08-19.txt), so FOREIGN_PRICING_PROVENANCE reads captured and the digest header renders that word beside the figures with the source next to it. The capture also corrected the headline economy claim it replaced: against Sonnet 5's 2.00 / 10.00, luna's captured 0.20 / 1.20 is 10.0x cheaper on input and 8.33x on output — roughly 8-10x depending on axis, not the ~10-15x Book 94 advertised, whose derived rows had been calibrated from that very claim. The measured factors are asserted in tests/scripts/book94-join-seam-coherence.test.ts, so the number in this sentence and the numbers in the table can only move together. Should a future row ever ship without a capture behind it, that constant goes back to derived and the digest's order-of-magnitude ceiling starts printing again.
  • The openai/ channel is deliberately not priced by that table. It points at a self-hosted server, so its tokens never reach a vendor and no vendor rate may be charged for them. Those rows total $0.00 by design and carry a locality provenance — local-self-hosted when every event named an on-network endpoint, openai-endpoint-unverified when one did not — because a $0 total is already true of any id the tables miss and therefore witnesses nothing on its own. Tokens are still reported, so a self-hosted seat that burned the day is distinguishable from one that never ran.
  • The seat rules above are enforced by the resolver (scripts/shared/dispatch-resolution.mjs) and pinned by its test suite — read docs/state-model.md's Dispatch Carrier Contract section for the full --source vocabulary a routed dispatch records (and for why that field is not the resolver's own source).

Platforms

DivineSWE supports four platforms. The canonical source targets claude-code; packages for other platforms are generated from it.

| Platform | Manifest | Slash Prefix | Install target | Status | |----------|----------|--------------|----------------|--------| | claude-code | .claude-plugin/plugin.json | /divineswe: | N/A (source IS platform) | Fully supported | | opencode | npm plugin (divineswe package) | / | ~/.config/opencode/ (global default) | Supported | | copilot-cli | copilot/plugin.json (committed) | / | ~/.copilot/ (global default) | Packaging-conformant; tier-3 unproven | | codex-cli | codex/.codex-plugin/plugin.json (committed) | $skill-name (or /skills) | Codex marketplace | Packaging-conformant; orchestration unproven |

GitHub Copilot CLI plugin packaging

The copilot/ package is committed at the repo root and installs directly from a git URL. The canonical install path (marketplace form — do NOT use the direct install owner/repo form, which hits upstream loader bug copilot-cli#2390):

copilot plugin marketplace add https://gitlab.com/aidragonhq/divineswe.git
copilot plugin install divineswe@divineswe

VS Code Copilot (Preview): Same install gesture. Use "Chat: Install Plugin From Source" with the git URL, or add to chat.plugins.marketplaces in VS Code settings. VS Code auto-discovers CLI-installed plugins.

Caveats (honest scope per Loki-Doubt review):

  • VS Code runtime: unvalidated. Install and plugin registration work via the CLI path; VS Code runtime skill/hook self-location is untested (CLI-validated only, different process model).
  • Windows: out of scope. State-CLI skills self-locate via a bash glob — Windows Copilot state-CLI skills are not supported (bash-only self-location).
  • Tier-3 hook/agent firing: unproven. The copilot/ package is packaging-conformant (hooks, agents, plugin.json pointer all correct), but hook FIRING and agent DISPATCH have not been validated against a live session. Tier-3 firing is unproven.

For full platform portability details, generator usage, build/install scripts (install-platform.mjs), the three-state file model, atomicity guarantees, and adding new platform targets, see docs/platform-portability.md and docs/contributing.md.


What's New

v2.1.1 (Books 114 — Where Mortal Hands Touch)

  • The Human Testing Sequence is a functional walk. Its steps use the work the way its user would and never repeat what a test already proves; they cite only the Mandates they exercise, and a spec whose work no person uses carries none. verify-testing-sequence.mjs now checks the form, not coverage.

v2.1.0 (Books 114 — Walked by Mortal Hands)

  • A Human Testing Sequence in every forge spec. Numbered steps a person walks by hand, written by oracle-envision, kept current by avatar-forge and checked by verify-testing-sequence.mjs; a spec the user has walked is human-verified, after fulfilled.
  • Vow priority. vow open and vow update take --priority <n>, from 0, the highest, to 10000, the lowest, and vow surface ranks by it.
  • Specs by path. Envision shows a spec for approval by its path and a short summary rather than pasting it whole.
  • Copilot and Codex dependencies from init. divineswe-init installs ajv and ajv-formats where the plugin root lacks them; run it again after each copilot plugin update.
  • generate-platforms is removed. Every platform ships the same skill set, and the packages are regenerated with npm run generate:all.

v2.0.0 (Books 114 — Describe, Build, Audit, Commit Workflow)

  • Describe, build, audit, commit. Describe the change — or design it first with oracle-envision — and avatar-forge builds it tests first in the live session; 4eyes audits each major unit before it is committed, Loki and Occam attend, and you check the evidence before anything is called fulfilled.
  • The Book cycle is kept whole as 1.0.0 on v1.0. Modern models decompose work and build tests first on their own; the full Oracle Consult → Prophet Fulfill orchestration stays there for smaller and weaker models that need it.
  • One semver line. 0.68.0–0.70.0 were this line's releases before it took its number and are not renumbered; 2.0.0 carries them, and 2.x continues on master.
  • Release guards accept a major bump, and this repository's Vow register is pruned from 441 owed to 330.

v0.70.0 (Books 114 — The Oracle Sees Further)

  • Envision researches and draws. A research depth the user confirms — quick, or deep with an independent refuter per angle (research-craft.md) — a report mode, and Mermaid design diagrams held to a house form by verify-diagrams.mjs.
  • Specs for enterprise work. Hard constraints and an Appetite: line, eleven gap-sweep lenses, a runnable end-to-end check, probes, and verify-mandate-wording.mjs before every showing.
  • A fuller dialogue. Up to 20 Frame questions, three plausible concepts, ## Terms, a draft spec kept as the record, and a Triage grouped Now → Later → No where every unmarked row takes the recommendation.
  • The second opinion. A cross-family 4eyes at the closing audit, carried by Hermes on second_opinion_model and chosen once per machine with /divineswe:hermes-setup; a read-only claude/ realm carries audit seats through claude -p in a bubblewrap sandbox.
  • Audit rounds. 4eyes loops fix only core findings, on a floor that rises each round with no cap; a HIGH that keeps coming goes to the user.
  • Worktrees and installs. The forge works in a worktree when the checkout is busy, and plugin installs get their runtime dependencies, the lock held to the host's install conditions by lockfile-guard.mjs.

v0.69.0 (Books 114 — The Second Bump)

  • The release declaration drives the bump. tests/release-target.json declares the target; scripts/bump-version.mjs synchronizes package versions, the lockfile and generated platform packages.
  • Design, then forge. oracle-envision designs involved work for avatar-forge; Occam weighs Loki's findings before presentation or fixes.
  • Scope audits and reviewer strength. avatar summon --scope <pathspec> audits tracked code, and 4eyes uses a reviewer floor relative to the implementer.
  • The Avatar inherits the house. Book doors, Scry, Decrees and Canon are deprecated; Vows stay, with closing audits and Hermes summons on the Avatar path.

v0.68.0 (Books 113 — The Forge Is Lit)

  • The Avatar is the default build path. A bare oracle-consult writes a forge spec — Mandates with Accept: lines, no task breakdown — and avatar-forge builds it tests first, with 4eyes before every major commit, Loki-Exploit at its discretion and Occam after every Loki run. Large or risky work takes oracle-consult book and prophet-fulfill.
  • Book mode, read on demand. The Book protocol lives in book-mode.md, now shipped to every platform with its read path rewritten.
  • Avatar seats run native and say so (replaced_route), Occam joins as a seat, --base audits a new unit, and summons work inside a worktree.
  • The Canon sleeps by default (canon_enabled: false).
  • The Avatar speaks its own Mandates. Ad hoc, it writes the ask as Mandates in a committed spec; from either door it shows them and carries on unless you stop it, tests trace to them, and 4eyes, Loki-Exploit and Occam audit against them.
  • A reviewer is never weaker than the work it reviews: --implementer holds 4eyes above the model that did the work — or level with it at the project's high tier or on Fable — and 4eyes rides Hermes on a codex/ terra or sol model with no extra acknowledgment.
  • One home for test craft: skills/avatar-forge/test-craft.md, read on demand by Thoth, Loki-Break and the Avatar, with seam tests named.
  • Book 113: bubblewrap is probed for usability, not presence, so a host that cannot sandbox skips honestly instead of withdrawing the shell mid-dispatch.

v0.67.0 (Books 112 — Chapter and Verse)

  • The Mandate register. Every ## Agreed item of a consultation spec is now a Mandate — an id, a provenance (user, derived, or reviewer) and an Accept: line — enforced by the verifier at plan time and demoted to WARN at INIT/resume via --mandates-advisory.
  • The prior question. A reviewer Mandate enters Agreed only after Oracle asks aloud whether the Architect asked for it, before the CORE/EXTENSION triage runs.
  • The fifth rubric probe. Every Mandate traces to the Architect, or to a Mandate that does — provenance must chain back to a human request.
  • Test traces. test_files and adversarial_tests items are {path, traces_to} pairs: a test tracing to nothing is not written, and an untraced invariant is filed as a deferral instead of passing silently.
  • The release itself is pin-driven. This entry is filed through scripts/bump-version.mjs, which composes the release heads from the single tests/release-target.json pin and refuses a dirty tree or a version mismatch before writing anything.

v0.66.0 (Books 111 — Exceeds Its Mandate)

  • Audit findings are typed. Every 4eyes finding and every Loki-Exploit form: exploit finding now carries traces_to, a disposition (remediate/remove/amend-scope) and a remedy (core/extension), reconciled by a weighing audit reconcile verdict instead of raw severity.
  • Occam sits at AUDIT as a third pass, reading both auditors' findings and proposing narrowing without ever originating a deletion or setting a finding's disposition itself.
  • The three routes are live. remediate dispatches Monkey to build, remove dispatches Monkey to delete (never to flag), and amend-scope halts the cycle for the operator instead of being routed anywhere.
  • The 4eyes simplify rubric protects the Mandate's Accept line, not the mechanism used to satisfy it.
  • scripts/bump-version.mjs retires the hand-edited release ceremony. It reads the single tests/release-target.json pin, writes the version files and the CHANGELOG/README heads, and refuses to write anything on a dirty tree or a version mismatch.

v0.65.0 (Books 108, 109 — What a Seat May Claim When It Fails)

  • The per-turn output cap is operator-supplied. The carrier's --max-output-tokens flag reaches the wire as max_tokens on every turn, defaulting to 32768 — previously a hardcoded 2048 that no flag could move. The cap and the prompt budget share one hearth context slot, so the ceiling is derived and a pair that cannot fit is refused at exit 2, naming both numbers.
  • A failed dispatch's report carries hermes_failure. A non-COMPLETED outcome is stamped {outcome, reason} at the runtime's single report-carrying return point, and the ad-hoc relay carries two independent marks — the model failed, and the carrier refused — so a refused dispatch can no longer read as a successful one.
  • Nothing a model controls emits an unprefixed line inside the relay fences. Carrier reasons are flattened at the print site, the one chokepoint every reason crosses, closing the forged-fence class on both the relay and stderr.
  • Prophet's context diet (Book 108). The orchestrator's loaded doctrine is relocated behind progressive disclosure, with the one lawful doctrine duplication pinned PRESENT in both files rather than left to read as drift.
  • Documentation truth. openai_max_output_tokens remains a project key that no runtime reads, hand-walked onto the flag, and the docs, schema descriptions and JSDoc now say so in both directions.

v0.64.0 (Book 107 — Hermes at the Hearth)

  • The carrier is renamed to scripts/hermes-dispatch.mjs, replacing scripts/dispatch-codex.mjs across the codebase and its shipped mirrors.
  • A native Chat Completions runtime, scripts/hermes-runtime.mjs, drives the openai/ realm directly instead of routing through codex exec — tool contracts, path confinement, an optional bwrap sandbox, and telemetry all live in the runtime now.
  • A turn-one non-conforming reply is exit 19 ENDPOINT_NONCONFORMING, never a silent success or a retried transport failure.
  • Failed attempts keep their evidence. A non-zero exit retains the attempt directory, and the verdict line names both attempt_path and the files_touched list.
  • Canon MODIFIED/REMOVED deltas accept a from: line naming the prior declaration they supersede, so a reworded requirement retires the section it replaces instead of leaving both standing.
  • The plan-time launcher-sham regex no longer misfires on a real script invocation whose filename ends in a TypeScript-JSX extension.

v0.63.0 (Book 105 — Occam Takes a Seat)

  • Occam, the subtractive advocate. A new plan-time agent seat proposes cuts, merges and unjustified-scope calls against the draft spec and Section 3 breakdown across two passes, with dispositions accepted or denied by the user alone.
  • Decree back-link normalization. Observed Decree claims are compared to the brief slug after stripping a leading docs/decrees/ and trailing .md, so the bare-slug form no longer warns as a mismatch.

v0.62.0 (Book 104 — Hermes at the Hearth)

  • Hermes at the Hearth. The foreign carrier now supports an explicit openai/<model> channel for OpenAI-compatible local endpoints, with required endpoint configuration and honest local cost accounting.
  • Ad-hoc summonses. The hermes-dispatch skill documents guarded, report-only carrier dispatches outside the Book cycle, including containment and itemized risk acknowledgments.
  • Complete skill reference. The skills page now documents every shipped skill and its Codex $name spelling.

v0.61.0 (Book 103 — The Mended Messenger)

  • The Mended Messenger. Codex dispatches now protect the handoff boundary: implementer seats receive exactly one task line, while the narrowly defined auditor scope remains available for sanctioned batch work.
  • Symmetric scroll trust. The carrier hashes the same delimiter-normalized scroll representation that the prompt assembler embeds, so legitimate scrolls do not become falsely stale while status-only changes remain safe.
  • Deterministic drift checks. Generated platform configuration is exempted precisely, unrelated committed-tree drift stays observable, and temporary drift fixtures no longer mutate the live scripts directory.

v0.60.0 (Book 101 — The Weighing of the Heart)

  • Thoth's nine duties. A binding Weighing-of-the-Heart division records what a pin must prove before it counts as evidence — the Census of unpinned invariants, the Scales that forbid existence-only oracles, the Song of Properties, and the Steady Hand that quarantines a flake with a filed obligation rather than retrying it until green.
  • The Exploit-Signature Check. 4eyes gains five signatures of a test bent to fit its implementation, scoped so lawfully commissioned test work is never flagged, plus a Property-Validity Review that hunts oracles mirroring the code they claim to check.
  • The Design-Simplify Rubric, single-homed in oracle-consult and walked by name from Loki-Doubt and Preacher, capped advisory at design level.
  • The Stop verify-gate retired — its sensor had been lying since June.

v0.59.0 (Book 100 — Orpheus, the Prompt-Writer)

  • The song before the summons. scripts/orpheus.mjs gives plan-time consult-prompt authoring its own deterministic instrument — gather, scaffold, validate, staleness — reusing atlas-gather.mjs as a module to assemble an evidence bundle, raise a consult-prompt skeleton, and judge a seed's structure and freshness.
  • The orpheus-sing skill. The judgment layer Orpheus's script cannot supply, kept strictly distinct from compile-prompt.mjs's run-time dispatch-brief layer: Orpheus sings into the resolved consults_dir, never into .divineswe/prompts/.
  • Traceable seeds. The oracle-consult A16 amendment and the consumed-by backfill let a sung seed be traced to the consultation it fed and retired cleanly once consumed.

v0.58.0 (Book 96 — The Vow's Dwelling)

  • A configurable vow dwelling. The project-only vows_dir key defaults to .divineswe, keeps vows.jsonl as the fixed filename, and resolves through resolveVowsDir and the root-aware resolveVowRegisterPath composer.
  • One path across every surface. The state facade, Scry, Canon, Canon Drift, SessionStart and the Codex carrier follow the resolved dwelling. A custom path with a residue register at the default location is announced, while unreadable sources remain visibly unknown.
  • Setup and migration stay honest. divineswe-init resolves the dwelling before creating and checking the register, and the consumer contract gives the one-time git mv plus .gitattributes merge=union recipe. There is no automatic migration; an absolute out-of-tree dwelling is deliberately local-only and uncommittable, and the default path's symlink boundary is guarded as well.

v0.57.0 (Book 99 — Script-First Exploration: The Gather Pre-Pass)

  • The gather pre-pass. scripts/atlas-gather.mjs front-ends the Atlas explore flow with a deterministic, versioned envelope so scouts interpret rather than re-derive: gaia the tree census, lexis the query-scoped identifier index and prose-pin reverse index, arachne the static ESM import graph with cycle-guarded reverse closure, fan-in ranking, subprocess weak edges, a test-gap projection and an impacted-test selector, and echo the naming statistics, test-topology probe and thin history columns from one bounded git log pass.
  • mergeGathers and the atlas-map sidecar. A documented budget-ranking formula led by lexis query-hit strength folds the four angles into one gather; every map now pairs with the gather document that justified it, and the sidecar refuses to certify a pairing it never read.
  • Honest staleness. Every staleness verdict carries stale_paths, with sidecar-missing/sidecar-divergent among its reasons, and the compile-prompt caveat caps at five neutralized stale-path tokens plus an arithmetic remainder. The through-line: churn is null and never 0, query_hits is null for a file the index skipped, an empty scope can never certify fresh, and a merge may never claim completeness over an angle that declared itself partial.

v0.56.0 (Book 98 — The Honest Instruments)

  • Fail-closed reads in spec-sync. gitDiff refuses an unverified diff basis instead of swallowing the git error, and a name-set completeness witness confirms every file a diff claims to touch was actually read before a section is signed. Numbered and continuation Agreed-item list forms now parse alongside the - bullet form; section append is atomic and symlink-preserving.
  • The cycle boundary. cycle_open/cycle_close ledger events boun