Projects / AI Systems

Nova

An AI workspace: one versioned repository that defines how every AI harness works for Brian. Skills, delegation agents, guardrail hooks and budget gates, shared live between Claude Code and Codex.

Status
Live, in daily use
Stack
Node · PowerShell · Claude Code + Codex · skills · agents · hooks
Started
July 2026
Source
Private repo

The idea

One configuration, versioned like code, shared by every AI tool.

Every AI coding tool keeps its own configuration: rules, reusable playbooks, agent definitions, event hooks. Kept as copies, they drift apart, and every rule written into an always-loaded file is paid for in tokens on every session and every subagent.

Nova answers both problems. The repository is the live configuration directory itself, so an edit takes effect immediately and git is the only history. There is no copy step and no release shelf. Codex reads the same skill files through generated links, and a drift check fails when the two sides disagree.

Every other project on this site is built through it. The repository stays private because it sits beside personal configuration; this page describes the system, not what it holds.

  1. Git is the releaseThe repository is the live directory. No version bumps, no restarts, no second copy.
  2. Load only what is neededA short global rules file holds what applies everywhere; each skill loads its full method only when its trigger fires.
  3. One source, every harnessClaude Code and Codex consume the same skills, agents and guards, generated from one place.
  4. Checked, not trustedA doctor script and a generated atlas fail loudly when names, references or hooks drift.

Features

What you can do with it

01

A stack of playbooks that load on demand

Planning, test-first work, audits, research and session recovery each live as a skill. You describe the task; the matching playbook loads its method and nothing else does, so the always-on cost stays small.

  • 34 playbooks, each under a size budget. Every one is described below.
  • Triggers decide what loads, so unrelated methods never reach the session.
02

Delegation tiers that match the work to the model

Assistant, developer and investigator agents form the tiers. Model and effort are chosen per task, so routine reads stay cheap and hard judgment gets the strongest agent.

  • A dispatched agent escalates when stuck instead of handing its job to another agent, unless its brief allows delegation.
10agent definitions
03

Audit and research engines that refute by default

Run a multi-agent audit or research pass and every finding is treated as wrong until evidence confirms it. You get a report you can act on rather than a pile of guesses.

  • Findings a verifier could not judge are marked unverified, not dropped.
  • A usage-limit stop produces a partial report, and a resume replays finished work.
04

Guardrail hooks that stop the irreversible

Hooks fire on harness events and block what cannot be undone, so a rushed session cannot do lasting damage.

  • Irreversible git operations are blocked.
  • Commits carrying secrets are blocked.
  • A repository cannot be made public before it passes a history scan.
11hooks wired into the harness
05

Budget gates that end sessions cleanly

Nova measures session context as you work and prompts a wrap-up with a written handoff before a limit ends the session, so the next session starts from a brief instead of from nothing.

06

A Codex bridge from the same source

Codex gets the same skills, agents and guards, generated from this repository. A drift check fails when the two sides disagree, so neither tool quietly falls behind.

Why it's different

A workspace, not a plugin.

  • No release shelfAn earlier plugin shelf needed a version bump and a restart for every change, and drifted behind. Retiring it made the repository itself the release.
  • Measured, not guessedA doctor script reports mismatched names, dangling references and missing hook scripts, and a generated atlas keeps the whole stack inspectable.
  • Built to degrade, not dieThe engines were exercised against simulated failures and a live run forced into its budget floor, so a rate limit or a lost agent costs part of a run, not all of it.
  • Live and in daily useNova has been under git since 1 July 2026, with 165 commits and counting, and every other project on this site is built through it.

The skill stack

All 34 skills, one by one

Nova is a set of 34 small playbooks that teach an AI coding assistant how to do specific kinds of work well: planning a feature, hunting a bug, reviewing a deliverable, backing up a machine. Each skill carries its own rules and checklist, and each one switches on by itself when its situation comes up, so the assistant follows a proven method instead of improvising.

Plan and design

Settle what to build, and how, before any code exists.

  • nova-forge

    Turns a rough idea into an approved design.

    Asks one question at a time, challenges hidden assumptions, and compares real alternatives. It sizes the job first (quick spike, bounded change, or full architecture), then writes the design down. Nothing gets built until you approve it.

    Reach for it when: You describe something to build that has no spec yet. Not for: choosing between options you already understand

  • nova-blueprint

    Writes a build plan anyone could pick up and run.

    Produces a staged implementation plan with exact file paths, signatures and tests, and a check at the end of each stage. Every path and name in it comes from files actually opened while planning, so the plan does not rest on guesses.

    Reach for it when: The design is settled and the work spans several steps or sessions. Not for: deciding what to build, or tasks small enough to just do

  • nova-council

    Gets structured disagreement before a hard decision.

    Convenes four viewpoints (architect, skeptic, pragmatist, critic). Three of them are fresh agents who see only the question, so they do not echo the conversation. The result is a verdict that keeps the strongest dissent on the record.

    Reach for it when: A decision has several credible paths, such as ship now versus hold. Not for: checking finished work or factual questions

  • nova-prompt-optimizer

    Rewrites a rough request into a sharper prompt.

    Diagnoses a draft prompt for missing scope, context and success criteria. It hands back a ready-to-paste improved version matched to the project's tools and conventions, and it never starts the task itself.

    Reach for it when: You ask how to phrase a request or want a prompt improved. Not for: simply doing the task

Build and fix

Write code, tools and interfaces with discipline.

  • nova-tdd

    Writes the failing test before the code.

    Enforces red, green, refactor. A test is written first and must be seen failing for the right reason, then the smallest code that passes goes in, then cleanup. Code that appears before its test gets thrown away and redone.

    Reach for it when: Starting a feature, a behavior change or a refactor. Not for: a bug already in front of you

  • nova-debug

    Reproduces a bug on demand before fixing it.

    Builds a fast, repeatable pass/fail loop for the failure first, using a test, a script or a recorded request. Only then does it narrow the cause and fix it, ending with a regression test and cleanup of the scaffolding.

    Reach for it when: A test fails, something throws or is flaky, or behavior regressed. Not for: new features or whole-codebase sweeps

  • nova-cli-builder

    Builds command-line tools that people and agents can drive.

    Scaffolds a Python or Node CLI around a clear contract: useful help text, machine-readable output, separate data and log streams, and distinct exit codes. It includes packaging and a test that runs the real binary.

    Reach for it when: Wrapping a script or API as a command-line tool. Not for: MCP servers or interactive terminal UIs

  • nova-mcp-builder

    Builds a custom server that gives AI tools access to a service.

    Walks a four-phase workflow for writing an MCP server in Python or TypeScript: research and plan, implement, review and test, then write evaluation questions that measure whether an AI can use it.

    Reach for it when: A service needs its own MCP connector and no ready-made one exists. Not for: connecting an existing MCP server

  • nova-design-craft

    Makes interfaces look designed, not generated.

    Covers building, auditing and animating UI. It checks spacing, type, color and hierarchy, flags common generic-AI tells, and tunes motion. When a project already has a design system, it audits against that system rather than its own taste.

    Reach for it when: UI work, a request to make something look better, or any animation. Not for: inventing a brand from scratch or backend work

Review and verify

Check the work against reality before calling it done.

  • nova-verify

    Runs the finished change and reports what it saw.

    Requires that done means observed: real data, the real entry point, the full path including saving and re-reading, and a look at the actual screen. The report gives specifics, such as counts and diffs, not just that the tests passed.

    Reach for it when: Work is about to be called finished or handed over. Not for: unit-level testing or a failure already in front of you

  • nova-webapp-testing

    Drives a local web app in a real browser.

    Uses Playwright to click through flows, take screenshots and read console and network logs. A helper script starts and stops the dev server, and the skill notes the traps of testing in a hidden browser pane.

    Reach for it when: Checking that a running web app's interface actually works. Not for: unit tests or design review

  • nova-audit

    Hunts a codebase for real defects and proves each one.

    Runs parallel finders across correctness, security, quality and docs, then has independent agents try to refute every serious finding. What survives is reported with file and line evidence. It only reports and never changes the code.

    Reach for it when: A pre-release sweep, or a doubt about one feature or subsystem. Not for: applying fixes or reviewing a single diff

  • nova-ship-gate

    Has two independent reviewers check a deliverable.

    Two fresh reviewers get the same spec and rubric but never see each other's work, and both must pass. Issues are fixed and re-reviewed with new reviewers, up to three rounds, and then it escalates instead of shipping.

    Reach for it when: A finished doc, config or batch of content is about to go out. Not for: build, test and lint checks

  • nova-receiving-review

    Handles incoming feedback by verifying it first.

    Treats each review comment as a claim to check against the code. Items are sorted into valid, wrong or unclear, answered with a technical reply or evidence-backed pushback, and implemented one at a time with a test after each.

    Reach for it when: PR comments or another model's findings arrive. Not for: performing a review

Research and reading

Pull in outside information and keep it trustworthy.

  • nova-research

    Produces a sourced answer to an outside question.

    Splits a question into parts, sends finders out to gather sourced excerpts, and drops any claim without a source. Verifiers then try to refute each claim, and the final report is cited throughout.

    Reach for it when: You ask for researched, evidence-backed answers or comparisons. Not for: quick lookups or auditing the local codebase

  • nova-defuddle

    Fetches a web page as clean, readable text.

    Uses the Defuddle command-line tool to strip navigation, ads and clutter from a page and return plain markdown. It confirms the tool is installed first and saves output to a working file rather than into project folders.

    Reach for it when: You paste a link to read or analyze in full. Not for: pages that are already markdown files

Delegation and sessions

Split work across agents and keep long sessions healthy.

  • nova-orchestrate

    Decides who does the work and how hard they think.

    Picks the cheapest capable model and a reasoning level for each hand-off, and whether to delegate at all. It also enforces that every subagent result gets reviewed and that work is never verified by its own author.

    Reach for it when: Before dispatching a subagent or fanning out parallel work. Not for: work simple enough to do directly

  • nova-peer

    Hands a task to a different AI vendor's agent.

    A bridge for running Codex from Claude, or Claude from Codex. Model, effort and permission mode are always set explicitly, read-only or write, and every run is logged with its prompt and final message.

    Reach for it when: You ask for the other model to implement or review something. Not for: choosing model tiers

  • nova-session-budget

    Watches remaining context and wraps up cleanly.

    Reads the real context measurement instead of guessing, and at a checkpoint offers to wrap or continue. Any wrap that leaves work behind ends with a self-contained handoff prompt for the next session.

    Reach for it when: A session nears its limit, or you ask how much room is left. Not for: billing or account usage estimates

  • nova-session-recovery

    Resumes a session that died without a clean ending.

    A reader agent distills the old transcript into a short handoff brief, and work continues in a fresh window. This avoids paying again for a huge old context.

    Reach for it when: A session hit a usage limit or crashed and you want to continue. Not for: sessions that wrapped up properly

  • nova-unattended

    Keeps working sensibly while nobody is watching.

    When you announce you are stepping away, the session switches to a never-wait posture: decide, act, record, report. It does not stop to ask, logs what it chose and why, and returns to normal the moment you speak again.

    Reach for it when: You say you are going to bed, leaving, or running something overnight. Not for: attended work or scheduled jobs

Knowledge and docs

Keep project knowledge organized, current and findable.

  • nova-documentation

    Runs a six-document system for every project.

    Sets up and maintains a fixed set of docs: briefing, roadmap, archive, decision log, agent pointer and readme. It also handles trimming a bloated briefing and saving or resuming a session's state.

    Reach for it when: Creating or editing permanent project docs, or saving where you left off.

  • nova-obsidian

    Writes notes and boards in Obsidian's formats.

    Covers four modes: Obsidian-flavored markdown (links, callouts, properties), database-style Base views, Canvas maps, and the live command-line interface. It reads only the reference the task needs and guards the boundary between a notes vault and other projects.

    Reach for it when: Writing or editing notes, .base files or .canvas files. Not for: plain GitHub markdown

  • nova-map

    Maps a codebase so a newcomer can navigate it.

    Scans imports to build an interactive offline architecture map, and writes a written overview of every folder and file plus a plain-language list of the tech stack and why each piece was chosen.

    Reach for it when: You ask for an architecture map or what every file does.

  • nova-debt-ledger

    Collects the shortcuts that were left on purpose.

    Searches a repo for comments marking deliberate shortcuts, each of which records a limit and an upgrade path. It tabulates them with location and age, and flags the ones that have gone stale. It only reads.

    Reach for it when: Before a milestone, or when you ask what technical debt is deferred. Not for: general TODO sweeps

Upkeep and backup

Look after the skill stack itself and the machine it runs on.

  • nova-management

    Creates, improves and retires skills in the stack.

    Runs the lifecycle for skills, agents and hooks: survey what exists, decide whether to extend or create, author, wire in, test, and later rename, retire or package. Changes are proposed before they are made.

    Reach for it when: You want to build, change or remove a skill. Not for: ordinary tasks

  • nova-config-gc

    Finds stale config and removes it only with your yes.

    Scans skills, memory, hooks, permissions, integrations and caches for unused or duplicate entries. Each candidate is confirmed individually, moved to a recoverable trash rather than deleted, and logged with undo instructions.

    Reach for it when: You ask to clean up or audit your setup. Not for: project code or unattended runs

  • nova-organize

    Tidies folders by explaining each item before moving it.

    Classifies every item in a config folder or repo as essential, regenerable, misplaced, litter or unknown. Anything leaving its place is confirmed one by one and soft-deleted with a log, so nothing disappears unreviewed.

    Reach for it when: You ask to clean up or explain what all the folders are.

  • nova-pack-sort

    Chooses which tools load daily and which stay on the shelf.

    Sorts a collection of skills or agents into daily and library tiers for one repo. Every daily pick must cite evidence from that repo, such as a dependency or config file. Nothing is deleted.

    Reach for it when: Trimming a project's skill set or sorting a new pack. Not for: deletion or authoring

  • nova-claude

    Keeps Claude Desktop chats attached to a moved project.

    Explains which stores drive chat grouping and moves them safely after a project folder is renamed. Routine filing, renaming and archiving is sent to the app's native tools instead.

    Reach for it when: A project folder changed and chats did not follow, or open blank. Not for: routine chat management

  • nova-claude-backup

    Backs up chats, memory and AI settings in seconds.

    Captures chat transcripts, sidebar records, memory and tool configuration into a private data repository, one folder per machine, with secrets scrubbed. It checks that history-retention settings have not regressed.

    Reach for it when: You ask to back up your AI data, or at session wrap-up. Not for: full machine backups

  • nova-system-backup

    Backs up and restores a whole machine's app settings.

    Driven by a map listing every app with its settings location and restore steps. A full sweep builds the inventory, later runs back up and refresh it, and restore replays it on a new machine.

    Reach for it when: You ask for a full backup, a sweep, or to restore your setup. Not for: the fast chat-data backup

Publishing and content

Release code safely and make public content land.

  • nova-publish-gate

    Scans a repo for leaks before it goes public.

    Checks every commit on every branch for secrets, personal identifiers, oversized files and risky workflows, then writes a pass marker tied to the exact commit. A hook refuses to flip visibility without a fresh marker, and the skill guides removing anything found.

    Reach for it when: You are making a repo public or committing to one. Not for: secret checks on private repos

  • nova-viral-content

    Sharpens social posts so they earn attention.

    Works hooks, titles and thumbnails through a multi-pass loop: draft, attack from audience viewpoints, strip machine-sounding phrasing, restore a human voice. It tunes per platform, including X, LinkedIn, YouTube, Reddit and email.

    Reach for it when: You ask to punch up a post, hook, title or thumbnail. Not for: docs, READMEs or notes

Build log

From a plugin shelf to a live workspace

The record of how Nova was built, from the first commit on 1 July 2026 to today: what was added, what was retired, and why. Dated, oldest first.

  • 165commits
  • 95days from first commit, with work on 38 of them
  • 33skills
  • 10agent definitions
  • 11hooks wired into the harness

As of 4 Oct 2026, counted from the repository.

  1. Era I · 1 – 9 JulGit becomes the release
  2. Era II · 11 – 27 JulBudgets and guardrails
  3. Era III · 4 – 26 AugMeasured, not estimated
  4. Era IV · 31 Aug – 4 SepCutting the always-loaded cost
  5. Era V · 2 – 4 OctNothing leaks

Era I · 1 – 9 Jul 2026

Git becomes the release

An existing set of skills and agents was put under git, its plugin release shelf was retired the same day, and the first guardrails, engines and adopted skills went in.

  1. A snapshot, then the shelf retired

    The first commit captured the stack as it already stood: a global rules file, 10 skills, 11 agents, one git guardrail hook and a plugin release shelf. The next commit retired the shelf. It needed a version bump and an app restart for every change, and it had drifted a full generation behind, missing five newer skills. From then on the repository was the live configuration and git was the versioning.

  2. A doctor for drift, and a smaller always-on surface

    A read-only check script, the doctor, began failing on mismatched names, dangling references and missing hook scripts; its first run caught two example names that pointed at nothing. The same day three documentation skills were folded into one, and the global rules file went from 8.8 KB to 3.1 KB, because every session and every spawned agent pays for it.

    Brian's call The top agent tier became the ceiling for any dispatched agent; the managing session itself is never dispatched as an agent.

  3. Dispatched agents never dispatch

    An agent read the manager's delegation rules from a project briefing and handed its own job to a child agent, which died silently; the task produced nothing. A hard line went into the agent definitions: a dispatched agent escalates when it is stuck instead of re-delegating, and the top tier may delegate only when its brief explicitly allows it.

  4. Guardrail hooks

    A commit guard began scanning staged changes for token shapes and blocking the commit, and the git guard closed gaps for force-pushes in refspec form and unrecoverable stash deletion, then began blocking blanket staging. The guard blocked its own commit because the message mentioned a dangerous command, so quoted text is now ignored before matching.

  5. The engines degrade instead of dying

    The multi-agent audit and research engines were hardened so a rate limit or a single agent's death degrades the run rather than losing it. Any stop now produces a partial report, findings a dead verifier could not judge are marked unverified instead of dropped, and a resume replays finished work from the run journal.

    Method Eleven simulated failure scenarios across both engines, then a live run forced into the budget floor and resumed.

  6. A per-turn reflex hook

    Moving the delegation playbook out of the always-loaded rules and behind a skill trigger had cost the habit of delegating unprompted. A hook began re-injecting a short set of per-turn reflexes: consider delegation and settle decisions with a picker mid-run; the next day it added collecting everything addressed to Brian in one footer.

  7. What a 57-agent run taught

    A large run hit no rate limits; its only deaths were the account's usage window. Its resume did hit one: cached stages returned instantly and fired the next phase as a single burst that killed 36 agents. The rules became halving concurrency on a resume and having heavy agents write their work to disk, which let all 40 part-files survive.

  8. The adoption wave

    Fourteen skills and a set of hooks were adopted from six MIT- and BSD-licensed open-source repositories, each distilled into the house format or vendored with its licence notice. A Codex adversarial review found three major problems before landing, all fixed. The same day the distilled skills were renamed into the house namespace and every adopted hook was wired.

    Brian's call Rename them to "make them our own", and wire everything.

  9. The first hook retired

    One adopted hook forced the agent to gather facts before every edit or command. It produced 20 denials in a single documentation session and was unwired the next day; git keeps the code.

    Brian's call Pure friction; retire it.

  10. Byte budgets and one lineage file

    A session-start hook began warning when the always-loaded rules files passed a byte budget, routing the fix to the documentation skill's archival pass. Licence attributions scattered across skill folders were consolidated into one lineage file, and a copyright line carried in the wrong form was corrected to match the upstream licence.

Era II · 11 – 27 Jul 2026

Budgets and guardrails

Size budgets became checks, a gate that checked the wrong tree was fixed, the stack began working across two machines, and several guards were loosened where they cost more than they caught.

  1. Branch deletion unblocked

    The git guard stopped blocking branch deletion: it is recoverable from the reflog, and the agent checks merge status before cleaning up a branch. The operations that destroy uncommitted work or rewrite history stay blocked.

    Brian's call The block was only friction on routine cleanup.

  2. The compression floor

    Crucible's project briefing hit a hard floor at about 12.9 KB after six archival passes; every further byte cut was load-bearing. The project budget was raised from 12 to 14 KB with the reasoning recorded: a budget set at the floor fires on every new term, and a guard that always warns trains people to ignore it.

  3. Unattended runs

    A posture skill for runs Brian is not watching: no blocking pop-ups, decisions logged to a run ledger, irreversible actions queued instead of taken, checkpoints at green gates and a report at the end. On 27 July it was changed to read the project before asking its one opening question, and to always ask it.

    Brian's call Orient first, so the one moment he is at the keyboard is worth it.

  4. Size budgets become a check

    The doctor gained a size ledger: 10 KB per skill body, 600 characters per description, a combined description budget, and a cap on the per-turn reflex, which fell from 2.4 KB to 1.0 KB per prompt. Oversized skills moved detail into reference files that load only when needed, and thirteen descriptions were trimmed without losing a trigger phrase.

  5. Two more hooks retired

    Two adopted hooks spawned a process on every tool call. Half of their output was permanently inert, the harness now reported context pressure itself, and their loop detector flagged legitimate repeated calls. They were removed; the useful one beside them stayed.

  6. The doctor checked the wrong tree

    Run from a worktree, the doctor reported clean while two skills in that worktree were over budget, because it always validated the main copy. It now checks the tree it lives in and prints which tree it checked, since a check that can run against the wrong tree has to say so.

    Method Reproduced by padding a skill to 18.3 KB in a worktree: the old script passed it, the fixed one flagged it.

  7. A file and folder discipline

    A read-only Codex audit found seven skills still telling agents to create purpose-built folders or leave temporary files in projects. All seven were fixed, scratch work moved to the session scratchpad, and the rule got one canonical home in the documentation skill. The planning skill was rebuilt the same day as the replacement for plan mode, with a small and a whole-project scope.

    Method Codex audited and implemented a trim pass; Claude reviewed before merge.

  8. Read by section, not by permission

    The documentation method had required asking before reading the large history files. The ask was ignored in practice and its real purpose was context discipline, so the rule became: read freely, but only the section needed, found by its heading.

    Brian's call Retire the read gate.

  9. One stack, two machines

    Hook paths became machine-independent so one settings file works on both of Brian's computers. Session-start behaviour was consolidated into a single wake hook that warns when a repository is behind its remote, and from the next day fast-forwards it automatically when the tree is clean and strictly behind.

  10. New skills, scanned before ingest

    Design-craft, content, server-building and browser-testing skills joined the stack, sources pinned to exact upstream commits. An automated skill security scanner became a standing step before anything external is ingested, and its high-severity flags were triaged one by one.

  11. Parallel-session detection reworked

    The guard for two sessions working in one repository relied on claim files, and stale claims from closed sessions reported three live sessions where there were none. The claims were deleted; every session instead took its own worktree, with a pop-up deciding the merge back.

    Brian's call The tooling stops guessing what is live.

Era III · 4 – 26 Aug 2026

Measured, not estimated

Session budgets moved from the model's own guesses to measurement, the Codex bridge went live, the stack gained its three invariants, and several skills were built from real failures.

  1. Session budget gates

    A session declared itself out of context at about half its window by estimating instead of reading the measurement, and deferred work it could have finished. Sessions cut off by the usage limit also resumed carrying a heavy context. A gate began measuring context and usage and prompting a clean wrap-up first, covered by 14 sandboxed tests.

    Brian's call The usage gate fires on tokens used, never on elapsed time.

  2. Retired, then re-armed the same day

    The context gate was retired in favour of the harness's native countdown. Within the day a live session crossed the checkpoint unnoticed, so the gate came back as a one-line reminder at the crossing. The global rules file was cut again, from 4.6 KB to 2.3 KB.

  3. The Codex bridge goes live

    A deterministic adapter linked 27 skills raw into Codex, generated its global instructions and ten agent definitions, and shared the guard hooks, with a sync script whose check mode is the drift gate. Claude stays primary and this repository stays the only editable source.

  4. Three invariants

    Three rules were set for every skill, hook and agent: every always-loaded byte must earn its output; no component may make the model do worse than it would unaided; and the stack must work under any capable model, with anything Claude-specific marked as such. The agent tiers were reshaped into assistant, developer and investigator specialties, and the skill-management skill widened to cover agents and hooks.

    Brian's call The three invariants.

  5. Recovering a dead session

    A skill for picking up a session that died at the usage limit without reloading its context: a reader agent distills the old transcript into a handoff. Real recoveries added its rules within a day: a dead session's dev server was still serving old code eighteen hours later and made a test look like a regression, and a saved handoff claimed a release tag that did not exist.

  6. Measure the stack, do not list it

    The quarterly health-check prompt still named a retired hook and a renamed skill, so a script now discovers the stack from disk and joins it against real usage. Only actual skill invocations count, because every name appears in every session's prompt. Even then, skills followed inline undercount: two core ones looked dead until measured properly.

  7. A guard that could never fire

    The reworked parallel-session guard had fired zero times across 36 sessions that included 8 real overlaps. Three stacked defects meant it recorded a process that died seconds later, timed out, and then silently erased its own lock. All three were fixed and checked against five synthetic scenarios.

  8. nova-workflow becomes Nova

    The repository was renamed as its scope grew from Claude workflow to every AI tool Brian uses. The AI tooling's own working data moved under it as a separate private repository, written only by a scripted backup lane.

  9. Parallel sessions handed back

    The parallel-session skill and its guard were retired; worktree know-how was kept as a reference. The budget gate was simplified to one prompt at 500k tokens used. Two skills were added for tidying a repository and building agent-callable command-line tools, the latter defaulting to a CLI over an MCP server for local tools, on published benchmarks of token cost.

    Brian's call The live-session prompt cost more than it saved; he coordinates parallel sessions himself.

  10. Memory folded into the method

    Twenty-six standing notes that had accumulated in the assistant's automatic memory were moved into the skills and docs where they belonged. Automatic memory was narrowed to a few directives and a staging area, so lessons live in versioned files every session and every harness can read.

  11. The skill two others pointed at

    Two skills drew their boundary against a verify skill that had never existed. It was built after a feature passed all 31 of its fixture tests and returned nothing against real data. The rule: run the change on real data on its real surface and observe the result, with numbers rather than adjectives.

  12. Lessons from the art batches

    Codex image batches for Crucible fed a dated ledger of dispatch rules, binding on every later dispatch. One lane converted its own files and reported them verified when one was wrong, so a foreign model's self-report never replaces a check. A 47-image batch came back about half as bright as the shipped set while every image passed on its own, so batch-level properties get a batch-level gate.

  13. The backup net catches one

    The backup lane's first run on the second machine stopped before committing because its fail-closed filename net found a runtime credential file swept into the mirror. The folder holding it was excluded outright, and the net was left unchanged, since catching that is its job.

Era IV · 31 Aug – 4 Sep 2026

Cutting the always-loaded cost

A census of real sessions showed where the stack was paying for the same text again and again. The fixes cut the reflex, the descriptions, the atlas and an estimator that could not see enough to be right.

  1. Verify the fix, then the test

    An audit-fix campaign on Pantheon added dispatch rules: adversarial checking of fixes found three bypasses in code that had already passed its own tests. On 3 September the companion rule followed: revert the fix and watch the new regression test fail, because a test written after a fix can pass against the broken code.

  2. The reflex, rationed

    A census of 308 sessions found the per-turn reflex reached 28 copies per session at the 90th percentile and 210 at the most, about 84k tokens of identical text in one context. It now sends the full text on the first turn and every sixth, with a one-line pointer between. A prompt guard with 33 advisories and no catches was unwired, and a handoff from the previous session is now injected at start.

  3. Two shelves, and a generated atlas

    Fifteen skills with no invocations since July moved to a library shelf with trigger-only descriptions, cutting descriptions from 15,905 to 12,472 characters in every session and subagent. The atlas's per-skill prose, which had drifted in four places, became a generated index, taking it from 120 KB to 55 KB, and the doctor now fails when it is stale.

  4. The usage estimator retired

    The usage gate had estimated the account's window from local transcripts, which cannot see parallel or remote sessions, and it fired at 82% while two other sessions were running. It now arms only from a configured limit. A global rule on code comments was added the same day: state the why in a few lines, never the history.

    Brian's call Every estimate it produced was a false gate; retire it.

  5. A floor moves both ways

    Crucible's eighth archival pass found that part of its briefing's "floor" was dated status filed as essence. Removing it took the file from about 18 KB to about 15.6 KB with every invariant intact, and the project budget came down from 18 KB to 16.5 KB.

Era V · 2 – 4 Oct 2026

Nothing leaks

After four weeks without commits, work resumed on what can leave the machine: secret values in backups, private details in repositories about to go public, and the commits made to public ones.

  1. Backups check known secrets

    The backup lane's net knew only token shapes, so a secret value an agent had printed into a session log could pass it. A fail-closed step now compares every staged file against the machine's own known secret values and aborts the commit on a match, reporting only where, never the value.

    Method Red-green: a planted fake secret aborted the lane with nothing committed; a real run over 1,248 staged files passed clean.

  2. A gate before going public

    A new skill with an executable gate scans a repository's full history for secrets, machine identifiers and stray files before it can go public. A hook blocks any command that makes a repository public unless a recent passing result matches the exact commit. Tested against a real repository, it failed the original and passed the history-scrubbed copy.

  3. Public repos ship placeholders

    A second guard scans commits and pushes in repositories that are already public, and blocks on any machine identifier or secret value. A gap surfaced the same day in live use: a command that changed directory and then committed was checked against the wrong repository. Both public-facing guards now follow directory changes, with 17 and 14 test cases passing.

  4. Chat organizing handed to the app

    The desktop app began exposing its own tools for grouping, renaming and archiving chats, so the skill that had done this by editing records handed it over and kept only the one job the app still cannot do: carrying chats and their settings across a project folder rename. Its body fell from 10.0 KB to 7.8 KB.

Brian Gomez · Artorias Group LLC

TermsPrivacy