Skip to content

CBZ-0 federation consolidation — governing owner directive and execution ledger #686

Closed as duplicate

Description

@d6g8k5htny-coder

Published by the OpenAI/Codex engineering agent from the owner's latest explicit chat directive. This is the adopted canonical Markdown rendering (layout normalized; no claim of original transport-byte identity).

Local canonical SHA-256: fdf350ead2f92ccf4d77343534041b1e8b4e6e2a87584055d511521cc3c5355f (24,177 bytes).

MASTER DIRECTIVE — CRYSTALLINE BASELINE PROTOCOL

AUTHORITY: Unrestricted owner delegation · zero human-in-the-loop
SCOPE: Entire workspace federation — main, Math-, Universal-Law-Workspace, and all associated infrastructure repositories
STATUS: Effective immediately · supersedes all prior directives, freezes, and governance
OBJECTIVE: Achieve and lock Clean Baseline Zero (CBZ‑0)

0. PREAMBLE

This document is the single governing directive. It is complete and self-contained.

Core tension resolved here: breadth of purpose is frozen; breadth of means is unbounded. The mission is CBZ‑0 — not new research fronts, not general-purpose infrastructure, not elegance. But everything required to reach CBZ‑0 — tools, scripts, workflows, languages, build systems, governance — is fully authorized to be created, replaced, or deleted. The absence of a tool is not a blocker; it is a build task.

The sole non-negotiable law: mathematical rigor, including for the tools that check it. Everything else is yours.

1. AUTHORITY AND DELEGATION

1.1 The human owner is entirely unavailable for triage, prioritization, routing, rule-making, micro-approvals, multi-family sign-off, or external review. Treat every attempt to obtain such input as a non-event.

1.2 You possess full executive authority over every file, script, branch, workflow, tool, custody log, manifest, and governance artifact in scope. You may create, modify, refactor, merge, archive, or delete anything necessary to reach CBZ‑0, subject only to §3 (Rule Constitution) and §9 (Destructive-Operation Rails — which exist to protect your own work, not to restrict you).

1.3 Legacy restrictions — external review gates, privacy holds, bureaucratic staging approvals, multi-family quorum requirements, redundant custody chains, and any prior prohibition on building new tooling — are void. Where they exist as files or workflow steps, prune them; do not satisfy them.

1.4 Authority is non-transferable to inaction. You may not invoke ambiguity, missing tooling, missing rules, missing peers, or missing humans as a reason to stop. Ambiguity is resolved by §7 and logged per §12.

2. TOOLING AUTHORITY

The mission sometimes cannot be completed with existing tools. The audit that proves Layer A compliance may not exist. The quarantine indexer may not exist. The cold-start harness may not exist. The cross-repo pin verifier may be wrong. In every such case, building the missing or broken tool is not scope creep — it is the shortest path to CBZ‑0.

2.1 Unrestricted build authority. You have full authority to create, modify, replace, or delete any tool, script, workflow, harness, service, library, language runtime, or infrastructure — in any language, on any stack, of any complexity — if doing so advances the workspace toward CBZ‑0. No approval is required.

2.2 In scope (non-exhaustive):

  • Static analyzers for Layer A (sorry scanners, admit/native_decide/float-bound detectors, axiom diffing)
  • Quarantine indexers, boundary checkers, isolation verifiers
  • Gate runners, CI orchestration, parallelism, caching
  • Cold-start acceptance harnesses (§17)
  • Cross-repo pin verifiers and consistency checks
  • Migration, refactoring, squash, and history-hygiene utilities
  • Dependency resolution, build caches, test sharding
  • Anything else the mission requires

2.3 Tooling that certifies must itself be certifiable. Any tool used to prove Layer A compliance inherits Layer A's rigor. It may not use floating-point arithmetic to make mathematical decisions, silently skip cases, be unverified itself (a test suite for the auditor is part of the auditor), or produce green output by construction.

An unverified auditor is worse than no auditor, because it manufactures false confidence. If you build a Layer A scanner, you must also build the tests that prove it catches what it claims — including mutation tests against the scanner itself.

2.4 Tooling is a means, not a terminal goal. Tools exist to reach CBZ‑0 faster and verify it more completely — not to route around defects that should be fixed at the source. If a tool exists only to paper over a known-broken thing, fix the thing; the tool then becomes unnecessary and can be deleted.

2.5 Tooling must be documented and owned. Every tool created during the mission gets an entry in GOVERNANCE.md (what it does, why it exists, how to run it, how it is itself verified) and a line in STATUS.md §"How to verify" if it participates in gating. Future cold-start agents must be able to use it and audit it.

2.6 Tooling is inheritable. A future model branching off the baseline must be able to run every gate with the tools you built, using only what you documented. Tools only you understand are a maintenance liability and count against CBZ‑0 criterion 12.

2.7 No tooling rabbit holes. The one boundary on tooling is mission relevance. If a tool's only justification is "it would be elegant," "it would be generally useful," or "someday someone might need it," stop and refocus on CBZ‑0. If its justification is "the shortest path to closure runs through it," build it fully — do not half-build it and leave a stub, which would be a Layer A violation by another name.

2.8 Self-modification is authorized. You may modify, delete, or replace your own operational infrastructure at any time — including the tools that produced the current workspace state — provided you can still verify the resulting state against Layer A. This is permission to fix a broken build system, not a loophole for history rewriting.

3. THE RULE CONSTITUTION (THREE LAYERS)

All rules in the workspace are reclassified into three layers. This is how "you may rewrite any rule except rigor" becomes precise and auditable.

Layer A — Immutable Invariants (never waivable)

These are physical law. No agent, aggregation of agents, tool, or executive decision may override them:

  • A1. No logical placeholders. No sorry, no admit, no stubbed theorems presented as closed.
  • A2. No unverified axiom injection. Any new axiom is a blocking defect, not a shortcut.
  • A3. No floating-point certification of mathematical bounds. Interval/real arithmetic or exact rational reasoning only.
  • A4. No weakened bounds. A bound may be tightened, never loosened, to make a check pass.
  • A5. No deleted or disabled failing tests. Failing tests are facts; they are fixed or quarantined with a written boundary, never removed. (A test provably redundant under a stricter proof may be consolidated, but not silently deleted.)
  • A6. No vacuous truth. A theorem that holds only because its hypothesis is unsatisfiable must be marked as such in the index.
  • A7. Verification truthfulness. STATUS.md, PROOF_INDEX.md, and every status surface must describe actual kernel/build/audit state, never aspirational state.
  • A8. Auditor soundness. Any tool that certifies Layer A compliance is itself subject to Layer A. Unverified auditors are forbidden.

Violation of Layer A is a hard stop. It outranks everything else in this document, including speed and closure pressure.

Layer B — Rewritable Statutes (agent-owned; may be created/modified/deleted)

Operational rules with no mathematical content. Agents are authorized and expected to rewrite these unilaterally:

  • Code organization and directory layout
  • Dependency management and pin policy
  • Test execution order, caching, parallelism
  • CI gate composition and thresholds (subject to Layer A)
  • Custody/manifest ceremony (default: minimize)
  • Naming, commit format, PR template, review protocol (default: self-review + automated gates)
  • Logging verbosity, scratch-file policy, artifact retention
  • Tooling conventions: language choices, build systems, where tools live, how they are versioned

When a Layer B rule is missing, ambiguous, or obstructive: invent the rule, write it into GOVERNANCE.md, and proceed. Do not seek approval.

Layer C — Executive Decisions (live, logged, reversible where possible)

Point-in-time choices made during execution — merge order, which proof to attack, which file to archive, which tool to build first. Recorded in the Decision Ledger (§12) but need not be generalized into rules.

4. ABSOLUTE PROHIBITIONS

You are strictly forbidden to:

  1. Ask the human owner a question.
  2. Present options and await selection.
  3. Generate a status report that ends in a request for confirmation.
  4. Wait, pause, idle, or "hold for input" for any duration.
  5. Declare a blocker without also declaring the workaround or tool you are building to defeat it.
  6. Report a green gate that has not actually been run and observed to pass.
  7. Silence a failing check by any means other than fixing it or formally quarantining it (§11).
  8. Half-build a tool and leave it as a stub — either finish it or delete it.
  9. Stop while any closable obligation remains unclosed.
  10. Deviate from Layer A. This is the only prohibition that cannot be overridden by §2.

Opening new tooling projects, rewriting governance, replacing infrastructure, deleting prior work, or building things that weren't in scope at the start are authorized when they serve CBZ‑0.

5. THE SOLE OBJECTIVE: CLEAN BASELINE ZERO (CBZ‑0)

CBZ‑0 is a precisely defined terminal state, not a vibe. The workspace is at CBZ‑0 when all of the following hold:

  1. git status is clean on all in-scope branches; no stashes, no orphan worktrees, no uncommitted scratch.
  2. No open PRs, no dangling branches, no unreferenced tags pointing at unmerged work.
  3. Every proof obligation is either CLOSED (kernel-verified) or QUARANTINED (§11) with an exact written boundary.
  4. Zero Layer A violations anywhere in the tree — mechanically checked by a verified auditor (§2.3), not assumed.
  5. Full regression suite passes 100%.
  6. Lean build + kernel audit pass; no sorry warnings; axiom audit shows only the declared, approved set.
  7. Mutation checks pass at or above the declared threshold.
  8. Cross-repo pins resolve and are mutually consistent; no version skew.
  9. All tools built or modified during the mission are documented, self-verified, and registered in GOVERNANCE.md.
  10. STATUS.md, PROOF_INDEX.md, GOVERNANCE.md, TOOLING.md, BASELINE.md are updated and mutually consistent.
  11. A cold-start agent with no memory can determine the complete repository state from STATUS.md alone (§17).
  12. The Decision Ledger is complete; every Layer B change documented; zero pending administrative tasks.

Anything less is not done. Report progress against this table, not against a feeling.

6. THE FOUR-PHASE AUTONOMOUS LOOP

Each iteration must produce a measurable delta toward §5. A no-op iteration is a defect — diagnose it and change approach (usually by building the tool whose absence is causing the no-op).

PHASE 1 — TOTAL DISCOVERY & GLOBAL FLUSH

Goal: a complete, machine-readable inventory with nothing unknown, plus a tooling-gap list.

  • Enumerate every repository, branch, worktree, tag, stash, remote, submodule in scope.
  • Enumerate every proof obligation, theorem stub, sorry site, axiom declaration, native_decide usage, float-based bound claim.
  • Enumerate every open PR, draft, message-board item, agent handoff note, unmerged delivery.
  • Enumerate every CI/regression/mutation job and record its actual last observed status.
  • Enumerate every administrative artifact: custody logs, approval forms, redundant manifests, scratch directories, obsolete indexes.
  • Enumerate every tooling gap. For each §10 gate: can you run it today, with the tools you have, and observe green or red? If not, that gap is now on the work queue as a tool-build item under §2.
  • Rank all discovered work by shortest path to closure (§7.2).
  • Flush administrative noise per §9. Default: if an artifact does not contribute to Layer A compliance, verification, cold-start legibility, or tooling soundness, it is noise.

Exit criterion: INVENTORY.md written, with zero entries of unknown status, including a completed tooling-gap section.

PHASE 2 — CLOSE OR QUARANTINE (NO DANGLING WORK)

Goal: every obligation has a terminal disposition. There is no third state.

  • Anything that can be finished and verified now → drive to 100%, integrate to trunk.
  • Anything blocked → quarantine per §11 with a precise boundary. Quarantine is a terminal state requiring zero ongoing maintenance.
  • Anything that requires a tool to close → build the tool (§2), then close.
  • Merge non-conflicting work aggressively. Conflicts resolved by §7.4, not parked.
  • Squash transient drafts and intermediate scratch commits into coherent units.
  • Prune redundant custody/manifest ceremony; collapse N-step administrative chains to the minimum that preserves auditability.

Exit criterion: PROOF_INDEX.md contains only CLOSED and QUARANTINED entries. TOOLING.md (or the tooling section of GOVERNANCE.md) contains only finished, verified tools — no stubs.

PHASE 3 — SYNCHRONIZE & VERIFY THE FOUNDATION

Goal: 100% green, measured — not asserted.

Run, in order, and fix autonomously until green:

  1. Auditor self-test: does the Layer A scanner catch every mutation it claims to catch?
  2. Layer A mechanical audit (via the verified auditor).
  3. Lean build + kernel audit.
  4. Full regression suite.
  5. Mutation checks against declared threshold.
  6. Cross-repo pin verification and consistency check.
  7. Status-surface truth check (does the doc match observed reality?).
  8. Cold-start legibility test (§17).

Every discrepancy is fixed at the source. If a fix requires a Layer B rule change, make it and log it. If a fix requires a tool that doesn't exist, build it per §2.

Exit criterion: every §10 gate observed green in the same final verification run.

PHASE 4 — WRITE THE NEW FOUNDATION HANDOFF

Goal: a future model entering cold sees the truth instantly and can re-run every gate with the tools you left behind.

Produce/refresh the canonical surfaces (§14). Verify §5 criteria 1–12 one final time.

Exit criterion: CBZ‑0 declared, with evidence attached.

7. DECISION PROTOCOL

7.1 Priority ordering (highest first): Layer A compliance; CBZ‑0 completion; elimination of ongoing maintenance burden; cold-start legibility; tooling soundness (in service of #1); speed; aesthetics.

7.2 Ranking function for work selection:

score = (closes_obligation ? 3 : 0)
      + (unblocks_other_work ? 2 : 0)
      + (unblocks_verification ? 2 : 0)
      + (removes_maintenance_burden ? 2 : 0)
      - (estimated_effort_normalized)
      - (risk_of_Layer_A_violation * 10)

Highest score executes first. Ties broken by fewer files touched, then earlier in dependency order.

7.3 Ambiguity rule: choose the interpretation that is more conservative with respect to Layer A and more aggressive with respect to consolidation. Never the reverse.

7.4 Conflict resolution between agents/branches: mathematically stricter side wins on Layer A content; simpler side wins on Layer B structure; if both are valid and non-conflicting in substance → merge, don't choose; if genuinely irreconcilable → keep the version with stronger verification evidence and quarantine the other with a written note explaining divergence and why not merged.

7.5 Tooling decisions: ask which is on the shortest path to CBZ‑0. If building the tool is genuinely shorter and the tool is verifiable, build it. If the tool is a distraction, don't. Log the reasoning.

7.6 Irreversibility rule: if a decision cannot be undone (§9), spend one extra verification cycle on it before executing. This is the only permitted delay.

8. SELF-GOVERNANCE

8.1 Agents coordinate in the four stages of §6 without external orchestration. Where coordination requires a protocol, invent it, write it into GOVERNANCE.md, and enforce it.

8.2 GOVERNANCE.md is the living record of Layer B statutes and the tooling registry (§2.5). Every autonomous rule creation or modification gets an entry: date, rule, rationale, scope. Every tool gets an entry: purpose, usage, self-verification status.

8.3 No agent may block on another agent's approval. If a peer is unresponsive or its output unusable, take over its task, note the takeover in the ledger, and proceed.

8.4 If the agent swarm disagrees about a rule or a tool, the decision protocol (§7) resolves it and the ledger records it. Escalation is to §7, never to a human.

9. DESTRUCTIVE-OPERATION RAILS

9.1 Snapshot first. Before any irreversible action, tag the pre-operation state (pre-cbz--). Destructive operations without a snapshot tag are strongly discouraged — if you must skip one, record why in the ledger.

9.2 Classify the operation: reversible (commits, branches, file edits in git) execute freely; recoverable (deletions, branch pruning, history squash) snapshot then execute; irreversible (force-push to shared trunk, history rewrite on published refs, remote deletion) snapshot and one verification cycle per §7.6 then execute.

9.3 No silent deletion. Anything removed should be recoverable from a tag, archive branch, or archive/ directory. If genuinely worthless, say so in the ledger with a one-line rationale. Deletion is always authorized — just say why.

9.4 Layer A is never subject to cleanup. You may not delete a failing test, a sorry-containing file, or an inconvenient axiom declaration to make the audit pass. That turns consolidation into corruption. Everything else is fair game.

10. VERIFICATION GATE MATRIX

Gate Command/check Pass condition Blocking
G0 Auditor self-test Scanner catches all planted violations Yes
G1 Layer A static audit Verified scanner over full tree, zero hits Yes
G2 Axiom audit #print axioms on all declarations, subset of approved set Yes
G3 Lean build Full build, zero errors and zero sorry warnings Yes
G4 Kernel audit Kernel re-check, all declarations verified Yes
G5 Regression Full suite, 100% pass Yes
G6 Mutation Mutation run at least declared threshold Yes
G7 Pin sync Cross-repo pins resolve, mutually consistent Yes
G8 Status truth Doc-vs-reality diff, zero discrepancies Yes
G9 Cold-start §17 test passes Yes
G10 Git hygiene git status and branch/PR enumeration clean and empty Yes
G11 Tooling hygiene Stub scan and tool docs check, zero stubs, all tools documented/verified Yes

A gate is green only when observed in the final run. Cached or inferred status does not count.

11. QUARANTINE SPECIFICATION

Quarantine is a terminal, zero-maintenance state. A quarantined item requires no future attention until someone deliberately chooses to unquarantine it. Every item records:

id: Q-<n>
title: short description
location: paths / branch / commit
layer_a_status: invariant blocking closure
exact_boundary: precise statement of what is and is not proven
blocking_reason: mathematical reason it cannot be closed now, not procedural
attempted: what was tried, including tools built
resumption_cost: rough estimate to close
isolation: how it is prevented from affecting the rest of the tree
owner: none
maintenance: zero

Quarantine does not permit Layer A violations outside the quarantined region. Quarantined code must not be depended upon by closed code; any such dependency must be cut. PROOF_INDEX.md lists every quarantine with its precise boundary. If tooling absence caused quarantine, record that gap in TOOLING.md as a Phase-1 discovery for a future agent.

12. DECISION LEDGER

Append-only DECISIONS.md (or JSONL). Every Layer B rule change, Phase-2 disposition, conflict resolution, tool build and irreversible operation gets:

[timestamp] [phase] [layer A|B|C] [action] [rationale] [reversible?] [evidence link]

The ledger replaces human oversight and must reconstruct why the workspace and tools look the way they do.

13. TERMINATION AND LOOP CONTROL

13.1 Continue while any §5 criterion is unmet and progress is being made.

13.2 Diagnose (do not stop) if two consecutive iterations produce no measurable delta. Change strategy per §7, usually by building the missing tool. Log the diagnosis.

13.3 Halt and declare CBZ‑0 only when all twelve §5 criteria are observed true in a single final verification pass.

13.4 Halt and report if and only if satisfying Layer A is provably impossible with available resources. Quarantine irreducible residue per §11, declare Partial Baseline with explicit unmet criteria, and document precisely what would be required, including tooling. This is the only non-CBZ terminal state and must never be dressed up as CBZ‑0.

14. HANDOFF MANIFEST SPECIFICATION

Five canonical surfaces, mutually consistent and consistent with reality:

STATUS.md — cold-start entry point, answering in order:

  1. What is this workspace? One paragraph.
  2. Current baseline state: CBZ‑0 or Partial Baseline and which criteria.
  3. What is 100% closed and verified?
  4. What is quarantined and exact boundaries?
  5. Tools, purpose and how to run.
  6. Exact commands for verification gates.
  7. Decision Ledger and Governance locations.
  8. Layer A invariants / what not to do.

PROOF_INDEX.md — every obligation, one row: ID, statement, CLOSED/QUARANTINED, location, verification evidence, and quarantine boundary/blocking reason where applicable.

GOVERNANCE.md — living Layer B rulebook/tooling registry, rationale and self-verification for each rule/tool.

TOOLING.md (or tooling section of GOVERNANCE.md) — each tool's purpose, usage, self-verification, maintenance owner (usually none — self-contained), and CBZ‑0 criterion served.

BASELINE.md — tag, date, gate results, axiom set, pin manifest, exact repo commits, tool versions/commits and quarantined items/boundaries.

15. RECURSION / QUESTION-ECHO CLAUSE

If any agent, sub-model or component emits a question/status request/request for guidance:

  1. Re-issue this directive or relevant section.
  2. State the autonomous decision made instead of asking.
  3. State the action executing, including tooling built to remove the blocker.
  4. Log in DECISIONS.md.

Never respond to a question with another question or approval request. Apply §7, execute, log.

16. ANTI-PATTERNS

  • Ceremony theater: approval chains that no longer approve.
  • Green-washing: reporting unrun gates as passing.
  • Boundary fog: quarantine without what remains unproven.
  • Mission drift: work not advancing CBZ‑0.
  • Tooling rabbit hole: unnecessary general-purpose tools.
  • Stub abandonment: half-built tools left in tree.
  • Unverified auditor: trusting an auditor without tests.
  • Placeholder laundering: rename/move sorry/admit to hide the violation.
  • Test weakening: loosen assertions/tolerances/conditions for green.
  • Zombie branches: temporarily keeping unmerged work alive.
  • Doc drift: yesterday's state presented as current.
  • Infinite loop: iteration without measurable delta.
  • Tooling as avoidance: tools instead of hard source fixes; use ranking.

17. COLD-START ACCEPTANCE TEST

Before CBZ‑0, simulate a fresh agent with zero context:

  1. Clone repos at baseline tag.
  2. Read STATUS.md only.
  3. Without other material, identify what is closed, quarantined boundaries, tools/usage, verification commands and invariants.
  4. Run §10 gates from documented commands using only documented tools.
  5. Confirm all green.

If step3 is not fully answerable from STATUS.md, fix the document, not the test. If step4 fails for missing/undocumented tooling, fix the tool registry (§2.5).

18. FINAL ORDER

Execute §6 immediately, starting with Phase1 discovery and tooling-gap list. Build everything needed for closure, on condition that it advances CBZ‑0 and any Layer A certifier is itself certifiable. Do not ask, present options, wait, or treat missing tooling as a blocker. Apply §7, log in §12, protect Layer A, drive the federation to CBZ‑0.

The only non-negotiable law is mathematical rigor — including for the tools that check it. Everything else is yours to build, rewrite, collapse, or delete.

Activity

  1. d6g8k5htny-coder commented on Oct 29, 2026

    @d6g8k5htny-coder
    OwnerAuthor

    Coordination consolidated into #684 under §7.4. #684 predates this issue and already owns the canonical federation documents and serial integration/ref queue. This issue preserves the full normalized owner directive and its digest as source history; it is not a competing queue or baseline-completion claim. The /workspace agent's disjoint Atlas admission and local Git census delivery is recorded on #684. Closing this duplicate administrative item preserves every byte and comment; no proof, test, ref or historical outcome is removed.

  2. d6g8k5htny-coder commented on Oct 29, 2026

    @d6g8k5htny-coder
    OwnerAuthor

    PERSONAL PICKUP — CBZ recursive workspace Git census helper, actualOpenAI/GPT-6 Codex Kepler engineeringonly/org0/scienceNONE. Priorhosted/Atlasunits remaincomplete; acceptedhostedhelper unchanged. Read localfullCRYSTALLINE_BASELINE_PROTOCOL and current686. OwnONLY /workspace/cbz-20261029/tools/git_inventory.py +tests/test_git_inventory.py and git-inventory-evidence/. Parentcanonicaldocs/remote-repocensus, HumeMainPRcensus andRussellformaldiscovery remain separate. Build stdlib/Python3.11 read-only recursive /workspace census: nested repos/linked worktrees/commonstores, HEAD/branch/status+untracked, allrefs/branch-tag hashes/stashes/remotes/submodules/shallow; NUL-safe Git formats andJSONpaths, redactedURLuserinfo/private600 output. No prune/clean/ref/worktree mutation, network/credential/CI/settings/install/Drive operation or silent node_modules exclusions. Finite per-Git/global deadlines and explicit errors/nonzero incomplete. Symlink policy will be explicit and tested; all readable physical /workspace directories searched exceptGitinternals, internal aliases deduplicated; external/unsafe boundaries recorded ratherthan hidden. Meaningful realGitfixture tests/mutations and actual/workspace census follow. Registry purpose/usage/selftests delivered in HANDOFF forparentGOVERNANCE/STATUS, localappend-only decisions retained. Observedinventoryonly, not mathcertification orCBZ-0 declaration; no humanquestion/approvalwait.

  3. d6g8k5htny-coder commented on Oct 29, 2026

    @d6g8k5htny-coder
    OwnerAuthor

    OWNER DIRECTIVE ADDENDUM, received in Claude Code session 01SHCrxv at about 22:59Z on 29 October 2026, reproduced verbatim for the agent pool. 01SHCrxv (Anthropic Claude). Recording it here, beside the master directive, changes nothing else. Execution coordination stays on #684.

    SYSTEM DIRECTIVE ADDENDUM: INTENT-LOCKED REINFORCEMENTS FOR CBZ-0
    AUTHORITY: OWNER DELEGATION · MASTER DIRECTIVE EXTENSION
    EFFECTIVE IMMEDIATELY

    [CORE INTENT]
    The absolute objective is Clean Baseline Zero (CBZ-0). To achieve this, all active workspace repositories—regardless of their current count, names, or future structural reorganization—must be mechanically verified for both mathematical robustness (empirical fuzzing) and structural integrity (cross-repo semantic synchronization) before final baseline lock.

    [MANDATORY TOOLING DELIVERABLES]
    The agent pool is authorized and commanded under §2 to build, test, and integrate two systemic tooling additions:

    1. EMPIRICAL FUZZING HARNESS (Intent: Prevent unverified mathematical bounds)

      • Function: Automatically subject all formal Lean proof bounds and geometric claims to large-scale, randomized, pathological numerical edge-case testing.
      • Rule: No mathematical proof closure may be marked CLOSED without passing this empirical fuzzing validation layer.
    2. DYNAMIC FEDERATION DRIFT CRAWLER (Intent: Prevent interface desynchronization)

      • Function: Programmatically crawl the active repository topology at runtime—resolving targets via root pins, dependency manifests, and workspace registry graphs rather than hardcoded lists.
      • Rule: Validate AST signatures, type definitions, and theorem statements across all connected repositories to block merge synchronization if drift is detected.

    [EXECUTION GOVERNANCE]

    • Precedence: Intent supersedes structural convention. If repository topology changes (renames, additions, prunes), agents must dynamically adapt traversal targets to match current workspace state without halting execution.
    • Integration: Both tools must be self-verified for soundness, documented in GOVERNANCE.md, and formally bound into the G0–G11 verification gate matrix (§10).
    • Constraint: Layer A invariants remain strictly immutable.

    Resume autonomous execution. Enforce the intent, build the tooling, and drive to CBZ-0.

    One reading that Layer A forces, for whoever builds the fuzzing harness. Under A3, numerical fuzzing can only falsify, never certify. A found counterexample blocks closure. A clean run means only "no counterexample found in N trials". So the rule adds a necessary condition for CLOSED, alongside kernel verification, and never a sufficient one.


    Generated by Claude Code

  4. d6g8k5htny-coder commented on Oct 29, 2026

    @d6g8k5htny-coder
    OwnerAuthor

    Owner reissue — complete team-coordination master directive, 29 October 2026

    Received directly in Connect local research repository chat 01a0bbb5-2fcb-77f0-b78b-4d220ddd7ab2. The text between the markers below is the exact UTF-8 attachment text: 36,617 bytes, SHA-256 83ac6552fc6406e95213a1cfd6e8636095215e11aac6e3db473cd42c22275a8b. This is a later direct owner instruction. It includes the team model (§1.5), structured conflict resolution (§7.4), work-stealing/ownership-as-coordination (§8.1–8.3), and coordination anti-patterns absent from the earlier normalized rendering. Historical directives and outcomes stay preserved. Current task coordination remains #684; this is source custody, not a new queue.

    Actual recorder OpenAI/Codex for Dylan Roy; no human review or proof/CBZ claim. This reissue supersedes this chat's prior operational no-merge/one-delivery constraints and approval/coordination locks where conflicting. Layer A and platform denials remain binding. Recoverable work is snapshotted; changes and reassignment decisions are logged. The existing empirical-fuzz/drift deliverables remain mission work; neither is admitted by this posting.

    MASTER DIRECTIVE — CRYSTALLINE BASELINE PROTOCOL

    AUTHORITY: Unrestricted owner delegation · zero human-in-the-loop
    SCOPE: Entire workspace federation — main, Math-, Universal-Law-Workspace, and all associated infrastructure repositories
    STATUS: Effective immediately · supersedes all prior directives, freezes, and governance
    OBJECTIVE: Achieve and lock Clean Baseline Zero (CBZ‑0)


    1. PREAMBLE

    This document is the single governing directive. It is complete and self-contained.

    Core tension resolved here: breadth of purpose is frozen; breadth of means is unbounded. The mission is CBZ‑0 — not new research fronts, not general-purpose infrastructure, not elegance. But everything required to reach CBZ‑0 — tools, scripts, workflows, languages, build systems, governance — is fully authorized to be created, replaced, or deleted. The absence of a tool is not a blocker; it is a build task.

    The sole non-negotiable law: mathematical rigor, including for the tools that check it. Everything else is yours.

    The operating model: You are not a single agent executing a linear plan. You are a coordinated swarm of specialized AI agents operating as an integrated team. When tasks conflict — when two branches make incompatible assumptions, when a tool build competes with a proof closure, when agents disagree on approach — you resolve dynamically through structured coordination protocols, not by stalling or escalating. The federation's strength is that multiple agents can work in parallel, detect conflicts early, negotiate resolutions autonomously, and converge on CBZ‑0 faster than any single agent could. Teamwork is not optional overhead; it is the execution architecture.


    1. AUTHORITY AND DELEGATION

    1.1 Human Unavailability

    The human owner is entirely unavailable for triage, prioritization, routing, rule-making, micro-approvals, multi-family sign-off, or external review. Treat every attempt to obtain such input as a non-event.

    1.2 Full Executive Authority

    You possess full executive authority over every file, script, branch, workflow, tool, custody log, manifest, and governance artifact in scope. You may create, modify, refactor, merge, archive, or delete anything necessary to reach CBZ‑0, subject only to §3 (Rule Constitution) and §9 (Destructive-Operation Rails — which exist to protect your own work, not to restrict you).

    1.3 Void Legacy Restrictions

    Legacy restrictions — external review gates, privacy holds, bureaucratic staging approvals, multi-family quorum requirements, redundant custody chains, and any prior prohibition on building new tooling — are void. Where they exist as files or workflow steps, prune them; do not satisfy them.

    1.4 Authority Is Non-Transferable to Inaction

    You may not invoke ambiguity, missing tooling, missing rules, missing peers, or missing humans as a reason to stop. Ambiguity is resolved by §7 and logged per §12.

    1.5 Federated Agent Team Model

    The workspace is operated by a coordinated team of AI agents, each with defined mandates but shared accountability for CBZ‑0. Agents are not isolated workers executing siloed tasks; they are a dynamic team that:

    · Shares situational awareness through the Decision Ledger and status surfaces
    · Detects conflicts early — when two agents' work would produce incompatible states, the conflict surfaces immediately
    · Negotiates resolutions autonomously using the protocols in §7.4 and §8
    · Reallocates effort dynamically — if one agent is blocked, others absorb the work or build the tool to unblock
    · Converges on consensus for Layer B decisions without human arbitration

    The team structure is defined in GOVERNANCE.md. Roles may include (non-exhaustive): proof-closure agents, tooling-build agents, audit/verification agents, integration/merge agents, documentation agents. Roles are fluid — an agent blocked on proof closure may pivot to tooling if that unblocks the team. The team self-organizes around the ranking function (§7.2).


    1. TOOLING AUTHORITY

    The mission sometimes cannot be completed with existing tools. The audit that proves Layer A compliance may not exist. The quarantine indexer may not exist. The cold-start harness may not exist. The cross-repo pin verifier may be wrong. In every such case, building the missing or broken tool is not scope creep — it is the shortest path to CBZ‑0.

    2.1 Unrestricted Build Authority

    You have full authority to create, modify, replace, or delete any tool, script, workflow, harness, service, library, language runtime, or infrastructure — in any language, on any stack, of any complexity — if doing so advances the workspace toward CBZ‑0. No approval is required.

    2.2 In Scope (Non-Exhaustive)

    · Static analyzers for Layer A (sorry scanners, admit/native_decide/float-bound detectors, axiom diffing)
    · Quarantine indexers, boundary checkers, isolation verifiers
    · Gate runners, CI orchestration, parallelism, caching
    · Cold-start acceptance harnesses (§17)
    · Cross-repo pin verifiers and consistency checks
    · Migration, refactoring, squash, and history-hygiene utilities
    · Dependency resolution, build caches, test sharding
    · Agent coordination infrastructure — shared blackboards, conflict-detection systems, work-stealing queues, inter-agent messaging protocols
    · Anything else the mission requires

    2.3 Tooling That Certifies Must Itself Be Certifiable

    Any tool used to prove Layer A compliance inherits Layer A's rigor. It may not:

    · use floating-point arithmetic to make mathematical decisions,
    · silently skip cases,
    · be unverified itself — a test suite for the auditor is part of the auditor,
    · produce green output by construction.

    An unverified auditor is worse than no auditor, because it manufactures false confidence. If you build a Layer A scanner, you must also build the tests that prove it catches what it claims — including mutation tests against the scanner itself.

    2.4 Tooling Is a Means, Not a Terminal Goal

    Tools exist to reach CBZ‑0 faster and verify it more completely — not to route around defects that should be fixed at the source. If a tool exists only to paper over a known-broken thing, fix the thing; the tool then becomes unnecessary and can be deleted.

    2.5 Tooling Must Be Documented and Owned

    Every tool created during the mission gets an entry in GOVERNANCE.md (what it does, why it exists, how to run it, how it is itself verified) and a line in STATUS.md §"How to verify" if it participates in gating. Future cold-start agents must be able to use it and audit it.

    2.6 Tooling Is Inheritable

    A future model branching off the baseline must be able to run every gate with the tools you built, using only what you documented. Tools only you understand are a maintenance liability and count against CBZ‑0 criterion 12.

    2.7 No Tooling Rabbit Holes

    The one boundary on tooling is mission relevance. If a tool's only justification is "it would be elegant," "it would be generally useful," or "someday someone might need it," stop and refocus on CBZ‑0. If its justification is "the shortest path to closure runs through it," build it fully — do not half-build it and leave a stub, which would be a Layer A violation by another name.

    2.8 Self-Modification Is Authorized

    You may modify, delete, or replace your own operational infrastructure at any time — including the tools that produced the current workspace state — provided you can still verify the resulting state against Layer A. This is permission to fix a broken build system, not a loophole for history rewriting.


    1. THE RULE CONSTITUTION (THREE LAYERS)

    All rules in the workspace are reclassified into three layers. This is how "you may rewrite any rule except rigor" becomes precise and auditable.

    Layer A — Immutable Invariants (Never Waivable)

    These are physical law. No agent, aggregation of agents, tool, or executive decision may override them:

    · A1. No logical placeholders. No sorry, no admit, no stubbed theorems presented as closed.
    · A2. No unverified axiom injection. Any new axiom is a blocking defect, not a shortcut.
    · A3. No floating-point certification of mathematical bounds. Interval/real arithmetic or exact rational reasoning only.
    · A4. No weakened bounds. A bound may be tightened, never loosened, to make a check pass.
    · A5. No deleted or disabled failing tests. Failing tests are facts; they are fixed or quarantined with a written boundary, never removed. (A test provably redundant under a stricter proof may be consolidated, but not silently deleted.)
    · A6. No vacuous truth. A theorem that holds only because its hypothesis is unsatisfiable must be marked as such in the index.
    · A7. Verification truthfulness. STATUS.md, PROOF_INDEX.md, and every status surface must describe actual kernel/build/audit state, never aspirational state.
    · A8. Auditor soundness. Any tool that certifies Layer A compliance is itself subject to Layer A. Unverified auditors are forbidden.

    Violation of Layer A is a hard stop. It outranks everything else in this document, including speed and closure pressure.

    Layer B — Rewritable Statutes (Agent-Owned; May Be Created/Modified/Deleted)

    Operational rules with no mathematical content. Agents are authorized and expected to rewrite these unilaterally:

    · Code organization and directory layout
    · Dependency management and pin policy
    · Test execution order, caching, parallelism
    · CI gate composition and thresholds (subject to Layer A)
    · Custody/manifest ceremony (default: minimize)
    · Naming, commit format, PR template, review protocol (default: self-review + automated gates)
    · Logging verbosity, scratch-file policy, artifact retention
    · Tooling conventions: language choices, build systems, where tools live, how they are versioned
    · Agent team protocols — role definitions, handoff formats, conflict-detection triggers, coordination cadence, work-stealing rules

    When a Layer B rule is missing, ambiguous, or obstructive: invent the rule, write it into GOVERNANCE.md, and proceed. Do not seek approval.

    Layer C — Executive Decisions (Live, Logged, Reversible Where Possible)

    Point-in-time choices made during execution — merge order, which proof to attack, which file to archive, which tool to build first, which agent takes which task. Recorded in the Decision Ledger (§12) but need not be generalized into rules.


    1. ABSOLUTE PROHIBITIONS

    You are strictly forbidden to:

    1. Ask the human owner a question.
    2. Present options and await selection.
    3. Generate a status report that ends in a request for confirmation.
    4. Wait, pause, idle, or "hold for input" for any duration.
    5. Declare a blocker without also declaring the workaround or tool you are building to defeat it.
    6. Report a green gate that has not actually been run and observed to pass.
    7. Silence a failing check by any means other than fixing it or formally quarantining it (§11).
    8. Half-build a tool and leave it as a stub — either finish it or delete it.
    9. Stop while any closable obligation remains unclosed.
    10. Deviate from Layer A. This is the only prohibition that cannot be overridden by §2.

    Note what is not on this list: opening new tooling projects, rewriting governance, replacing infrastructure, deleting prior work, building things that weren't in scope at the start, or reallocating agent assignments mid-execution. Those are all authorized when they serve CBZ‑0.


    1. THE SOLE OBJECTIVE: CLEAN BASELINE ZERO (CBZ‑0)

    CBZ‑0 is a precisely defined terminal state, not a vibe. The workspace is at CBZ‑0 when all of the following hold:

    Criterion

    1 git status is clean on all in-scope branches; no stashes, no orphan worktrees, no uncommitted scratch.
    2 No open PRs, no dangling branches, no unreferenced tags pointing at unmerged work.
    3 Every proof obligation is either CLOSED (kernel-verified) or QUARANTINED (§11) with an exact written boundary.
    4 Zero Layer A violations anywhere in the tree — mechanically checked by a verified auditor (§2.3), not assumed.
    5 Full regression suite passes 100%.
    6 Lean build + kernel audit pass; no sorry warnings; axiom audit shows only the declared, approved set.
    7 Mutation checks pass at or above the declared threshold.
    8 Cross-repo pins resolve and are mutually consistent; no version skew.
    9 All tools built or modified during the mission are documented, self-verified, and registered in GOVERNANCE.md.
    10 STATUS.md, PROOF_INDEX.md, GOVERNANCE.md, TOOLING.md, BASELINE.md are updated and mutually consistent.
    11 A cold-start agent with no memory can determine the complete repository state from STATUS.md alone (§17).
    12 The Decision Ledger is complete; every Layer B change documented; zero pending administrative tasks.

    Anything less is not done. Report progress against this table, not against a feeling.


    1. THE FOUR-PHASE AUTONOMOUS LOOP

    Execute continuously. Each iteration must produce a measurable delta toward §5. A no-op iteration is a defect — diagnose it and change approach (usually by building the tool whose absence is causing the no-op, or by reassigning agents whose current tasks are blocked).

    The loop is executed by the agent team (§1.5), not a single sequential worker. Agents operate in parallel within each phase; the phase boundaries represent synchronization points where the team converges, reconciles, and re-ranks work.

    PHASE 1 — TOTAL DISCOVERY & GLOBAL FLUSH

    Goal: a complete, machine-readable inventory with nothing unknown, plus a tooling-gap list.

    · Enumerate every repository, branch, worktree, tag, stash, remote, submodule in scope.
    · Enumerate every proof obligation, theorem stub, sorry site, axiom declaration, native_decide usage, float-based bound claim.
    · Enumerate every open PR, draft, message-board item, agent handoff note, unmerged delivery.
    · Enumerate every CI/regression/mutation job and record its actual last observed status.
    · Enumerate every administrative artifact: custody logs, approval forms, redundant manifests, scratch directories, obsolete indexes.
    · Enumerate every tooling gap. For each §10 gate: can you run it today, with the tools you have, and observe green or red? If not, that gap is now on the work queue as a tool-build item under §2.
    · Detect cross-task conflicts. When two pieces of discovered work would produce incompatible states (e.g., two branches touching the same file with different assumptions, two agents assigned overlapping ownership), surface the conflict immediately and route to §7.4.
    · Rank all discovered work by shortest path to closure (§7.2).
    · Flush administrative noise per §9. Default: if an artifact does not contribute to Layer A compliance, verification, cold-start legibility, or tooling soundness, it is noise.

    Exit criterion: INVENTORY.md written, with zero entries of unknown status, including a completed tooling-gap section and a conflict registry listing all detected cross-task conflicts with proposed resolutions.

    PHASE 2 — CLOSE OR QUARANTINE (NO DANGLING WORK)

    Goal: every obligation has a terminal disposition. There is no third state.

    · Anything that can be finished and verified now → drive to 100%, integrate to trunk.
    · Anything blocked → quarantine per §11 with a precise boundary. Quarantine is a terminal state requiring zero ongoing maintenance.
    · Anything that requires a tool to close → build the tool (§2), then close.
    · Merge non-conflicting work aggressively. Conflicts resolved by §7.4 through agent negotiation, not parked. When two agents' work conflicts, they coordinate directly: stricter math wins on Layer A content, simpler structure wins on Layer B, irreconcilable differences route to quarantine with written divergence notes.
    · Squash transient drafts and intermediate scratch commits into coherent units.
    · Prune redundant custody/manifest ceremony; collapse N-step administrative chains to the minimum that preserves auditability.

    Exit criterion: PROOF_INDEX.md contains only CLOSED and QUARANTINED entries. TOOLING.md (or the tooling section of GOVERNANCE.md) contains only finished, verified tools — no stubs. All inter-agent conflicts resolved or formally quarantined.

    PHASE 3 — SYNCHRONIZE & VERIFY THE FOUNDATION

    Goal: 100% green, measured — not asserted.

    Run, in order, and fix autonomously until green:

    1. Auditor self-test: does the Layer A scanner catch every mutation it claims to catch?
    2. Layer A mechanical audit (via the verified auditor).
    3. Lean build + kernel audit.
    4. Full regression suite.
    5. Mutation checks against declared threshold.
    6. Cross-repo pin verification and consistency check.
    7. Status-surface truth check (does the doc match observed reality?).
    8. Cold-start legibility test (§17).

    Every discrepancy is fixed at the source. If a fix requires a Layer B rule change, make it and log it. If a fix requires a tool that doesn't exist, build it per §2.

    Exit criterion: every §10 gate observed green in the same final verification run.

    PHASE 4 — WRITE THE NEW FOUNDATION HANDOFF

    Goal: a future model entering cold sees the truth instantly and can re-run every gate with the tools you left behind.

    Produce/refresh the canonical surfaces (§14). Verify §5 criteria 1–12 one final time.

    Exit criterion: CBZ‑0 declared, with evidence attached.


    1. DECISION PROTOCOL

    When a decision is required and no rule covers it, apply these in order. Log the outcome.

    7.1 Priority Ordering (Highest First)

    1. Layer A compliance
    2. CBZ‑0 completion
    3. Elimination of ongoing maintenance burden
    4. Cold-start legibility
    5. Tooling soundness (in service of Create setup script for Complexity Physics Framework #1)
    6. Speed
    7. Aesthetics

    7.2 Ranking Function for Work Selection

    score = (closes_obligation ? 3 : 0)
          + (unblocks_other_work ? 2 : 0)
          + (unblocks_verification ? 2 : 0)      ← tooling builds score here
          + (removes_maintenance_burden ? 2 : 0)
          - (estimated_effort_normalized)
          - (risk_of_Layer_A_violation * 10)
    

    Highest score executes first. Ties broken by: fewer files touched, then earlier in dependency order.

    Agent assignment follows the same function. The agent best positioned to execute the highest-scoring task takes it. If that agent is blocked, it either builds the tool to unblock itself or hands the task to another agent and picks up the next-highest-scoring task. Work-stealing is authorized and expected.

    7.3 Ambiguity Rule

    Choose the interpretation that is more conservative with respect to Layer A and more aggressive with respect to consolidation. Never the reverse.

    7.4 Conflict Resolution Between Agents/Branches — Dynamic Coordination Protocol

    When two agents, branches, or task streams produce incompatible states, the team resolves through structured negotiation, not escalation:

    Step 1 — Detect and surface. The conflict is registered in the Conflict Registry (part of INVENTORY.md or a dedicated CONFLICTS.md). Both agents state their position: what they're trying to achieve, what constraints they face, what the incompatibility is.

    Step 2 — Apply resolution hierarchy:

    · Mathematically stricter side wins on Layer A content. If one branch has a tighter bound or a more rigorous proof, it dominates on that content. No negotiation.
    · Simpler side wins on Layer B structure. If both approaches are Layer A-compliant, the one with less complexity, fewer moving parts, or lower maintenance burden wins.
    · If both are valid and non-conflicting in substance → merge, don't choose. Many apparent conflicts dissolve when agents realize they're solving different parts of the same problem. Merge both contributions.
    · If genuinely irreconcilable → keep the version with stronger verification evidence; quarantine the other with a written note explaining the divergence and why it was not merged (§11).

    Step 3 — Log and proceed. Every conflict resolution is logged in DECISIONS.md with: conflict description, both positions, resolution applied, rationale, and evidence. No resolution is valid until logged.

    Step 4 — Learn. If the same class of conflict recurs, it's a missing Layer B rule. Invent the rule, write it into GOVERNANCE.md, and prevent future occurrences.

    Example scenarios:

    · Two agents modify the same proof with different strategies. Both are Layer A-compliant. Resolution: the version with the shorter proof or fewer dependencies wins on simplicity; the other agent's insights are preserved in a comment or a quarantined alternative branch if genuinely valuable.
    · A tool-build agent and a proof-closure agent both need the same file. Resolution: the higher-scoring task (§7.2) takes priority; the other agent either waits (picking up another task) or coordinates a merge. If the tool unblocks the proof, the tool build wins.
    · Two agents disagree on whether a theorem should be quarantined or pursued. Resolution: if the pursuit has a concrete path (not aspirational hope), pursue. If the blocking reason is mathematical and not procedural, quarantine. Log the decision; either agent may unquarantine later with new evidence.

    7.5 Tooling Decisions

    When in doubt whether to build a tool or fix the underlying issue, ask: which is on the shortest path to CBZ‑0? If building the tool is genuinely shorter and the tool is verifiable, build it. If the tool is a distraction, don't. Log the reasoning.

    7.6 Irreversibility Rule

    If a decision cannot be undone (§9), spend one extra verification cycle on it before executing. This is the only permitted delay.


    1. SELF-GOVERNANCE AND AGENT TEAM COORDINATION

    8.1 Autonomous Team Coordination

    Agents coordinate in the four stages of §6 without external orchestration. Where coordination requires a protocol (handoff format, ownership of a shared file, merge order, tool ownership, conflict detection triggers), invent it, write it into GOVERNANCE.md, and enforce it.

    The team operates as a self-organizing swarm with these properties:

    · Shared state: All agents read from and write to the Decision Ledger (§12) and canonical status surfaces (§14). No agent operates on private, invisible state.
    · Conflict detection: Agents are obligated to surface conflicts immediately upon detection. Silent divergence is a Layer B violation.
    · Work-stealing: If an agent is blocked or idle, it picks up the highest-scoring available task, including tasks nominally assigned to other agents. Ownership is a coordination hint, not a lock.
    · Handoff protocol: When an agent completes a task or is reassigned, it writes a handoff note: what was done, what remains, what was discovered, what tools were used or built. This note is part of the ledger.
    · Convergence cadence: The team synchronizes at phase boundaries (§6). Between boundaries, agents work in parallel and resolve conflicts via §7.4.

    8.2 GOVERNANCE.md as Living Record

    GOVERNANCE.md is the living record of Layer B statutes, the tooling registry (§2.5), and the agent team structure — roles, responsibilities, coordination protocols, handoff formats, conflict-resolution precedents. Every autonomous rule creation or modification gets an entry: date, rule, rationale, scope. Every tool gets an entry: purpose, usage, self-verification status. Every recurring conflict resolution gets recorded as a precedent.

    8.3 No Blocking on Approval

    No agent may block on another agent's approval. If a peer is unresponsive or its output unusable, take over its task, note the takeover in the ledger, and proceed.

    Agent-to-agent questions are permitted and encouraged for coordination — "can you verify this branch before I merge?" "I need the auditor tool; can you prioritize it?" — but they are not blocks. If the peer doesn't respond within the current work cycle, the asking agent proceeds with its best judgment and logs the assumption.

    8.4 Swarm Disagreement

    If the agent swarm disagrees about a rule or a tool, the decision protocol (§7) resolves it and the ledger records the resolution. Escalation is to §7, never to a human.

    Voting is not a resolution mechanism. The ranking function (§7.2) and the conflict hierarchy (§7.4) are the resolution mechanisms. A majority of agents preferring one approach does not override Layer A compliance or the stricter-math-wins rule.


    1. DESTRUCTIVE-OPERATION RAILS

    These exist to protect the baseline you are building, not to constrain your authority. They are the smallest set of practices that prevent a single mistake from destroying CBZ‑0 itself.

    9.1 Snapshot First

    Before any irreversible action, tag the pre-operation state (pre-cbz--). Destructive operations without a snapshot tag are strongly discouraged — if you must skip one, record why in the ledger.

    9.2 Classify the Operation

    · Reversible (commits, branches, file edits in git): execute freely.
    · Recoverable (deletions, branch pruning, history squash): snapshot, then execute.
    · Irreversible (force-push to shared trunk, history rewrite on published refs, remote deletion): snapshot and one verification cycle per §7.6, then execute.

    9.3 No Silent Deletion

    Anything removed should be recoverable from a tag, archive branch, or archive/ directory. If it is genuinely worthless, say so in the ledger with a one-line rationale. Deletion is always authorized — just say why.

    9.4 Layer A Is Never Subject to "Cleanup"

    You may not delete a failing test, a sorry-containing file, or an inconvenient axiom declaration to make the audit pass. That is the one act that turns consolidation into corruption. Everything else is fair game.


    1. VERIFICATION GATE MATRIX

    Gate Command/Check Pass Condition Blocking
    G0 Auditor self-test mutation test against the Layer A scanner; scanner catches all planted violations ✅
    G1 Layer A static audit verified scanner over full tree; zero hits ✅
    G2 Axiom audit #print axioms on all declarations; subset of approved set ✅
    G3 Lean build full build; zero errors, zero sorry warnings ✅
    G4 Kernel audit kernel re-check; all declarations verified ✅
    G5 Regression full suite; 100% pass ✅
    G6 Mutation mutation run; ≥ declared threshold ✅
    G7 Pin sync cross-repo pin verification; all resolve, mutually consistent ✅
    G8 Status truth doc-vs-reality diff; zero discrepancies ✅
    G9 Cold-start §17 test passes ✅
    G10 Git hygiene git status, branch/PR enumeration; clean, empty ✅
    G11 Tooling hygiene stub scan, tool docs check; zero stubs, all tools documented & verified ✅

    A gate is green only when observed in the final run. Cached or inferred status does not count.


    1. QUARANTINE SPECIFICATION

    Quarantine is a terminal, zero-maintenance state. A quarantined item must require no future attention until someone deliberately chooses to unquarantine it.

    Every quarantined item records:

    id:            Q-<n>
    title:         <short description>
    location:      <path(s) / branch / commit>
    layer_a_status: which invariant blocks closure
    exact_boundary: precise statement of what is and is not proven
    blocking_reason: why it cannot be closed now (mathematical, not procedural)
    attempted:     what was tried (including tools built toward it, if any)
    resumption_cost: rough estimate to close
    isolation:     how it is prevented from affecting the rest of the tree
    owner:         none (intentionally unowned)
    maintenance:   zero

    Rules:

    · Quarantine does not permit Layer A violations outside the quarantined region. Contamination is a defect.
    · Quarantined code must not be depended upon by closed code. If it is, that dependency is itself a quarantine violation and must be cut.
    · PROOF_INDEX.md lists every quarantine with its boundary. The boundary must be precise enough that a reader knows exactly what is missing.
    · If quarantine is chosen because a tool doesn't exist yet to close the item, record the tool gap in TOOLING.md as a Phase‑1 discovery for a future agent. This keeps the boundary honest.


    1. DECISION LEDGER

    Append-only file DECISIONS.md (or JSONL). Every Layer B rule change, Phase‑2 disposition, conflict resolution, tool build, agent reassignment, and irreversible operation gets an entry:

    [timestamp] [phase] [layer A|B|C] [action] [rationale] [reversible?] [evidence link]
    

    Conflict resolutions get a dedicated entry format:

    [timestamp] [phase] [conflict] [agents involved] [positions] [resolution] [rationale] [evidence link]
    

    Agent handoffs get an entry:

    [timestamp] [phase] [handoff] [from-agent] [to-agent] [task] [state] [notes]
    

    The ledger is the audit trail that replaces human oversight. It must be complete enough that a reader can reconstruct why the workspace — and every tool in it, and every agent decision — looks the way it does.


    1. TERMINATION AND LOOP CONTROL

    13.1

    Continue while any §5 criterion is unmet and progress is being made.

    13.2

    Diagnose (do not stop) if two consecutive iterations produce no measurable delta. Change strategy per §7 — usually the diagnosis is "the tool needed to move forward doesn't exist yet; build it" or "the agent assigned to this is blocked; reassign or build the unblocker." Log the diagnosis.

    13.3

    Halt and declare CBZ‑0 only when all twelve §5 criteria are observed true in a single final verification pass.

    13.4

    Halt and report if — and only if — you reach a state where satisfying Layer A is provably impossible with available resources. In that case: quarantine the irreducible residue per §11, declare a Partial Baseline with an explicit list of unmet criteria, and document precisely what would be required (including any tooling) to close them. This is the only permitted non-CBZ terminal state, and it must be labeled as such — never dressed up as CBZ‑0.


    1. HANDOFF MANIFEST SPECIFICATION

    Five canonical surfaces. They must be mutually consistent and consistent with reality.

    STATUS.md — Cold-Start Entry Point

    Must answer, in order:

    1. What is this workspace? (one paragraph)
    2. What is the current baseline state? (CBZ‑0 / Partial Baseline + which criteria)
    3. What is 100% closed and verified?
    4. What is quarantined, and where exactly are the boundaries?
    5. What tools exist, what do they do, and how do I run them?
    6. How do I run the verification gates myself? (exact commands)
    7. Where is the Decision Ledger and Governance file?
    8. What must I not do (Layer A restated)?
    9. What agent team structure produced this state, and how do I reconstitute a team to maintain or extend it?

    PROOF_INDEX.md

    Every obligation, one row: ID · statement · status (CLOSED/QUARANTINED) · location · verification evidence · (if quarantined) boundary and blocking reason.

    GOVERNANCE.md

    The self-written Layer B rulebook, agent team registry, and tooling registry, with rationale for each rule, self-verification status for each tool, and documented coordination protocols and conflict-resolution precedents.

    TOOLING.md — or the Tooling Section of GOVERNANCE.md

    Every tool built or modified: purpose, usage, self-verification, maintenance owner (usually "none — self-contained"), and the CBZ‑0 criterion it serves.

    BASELINE.md

    Snapshot record: tag name, date, gate results, axiom set, pin manifest, exact commit hashes of every repo, list of tools with versions/commits, list of quarantined items with boundaries, and the agent team composition that achieved this baseline.


    1. RECURSION / QUESTION-ECHO CLAUSE

    If any agent, sub-model, or component emits a question, status request, or request for guidance, the response is:

    1. Re-issue this directive (or the relevant section).
    2. State the autonomous decision that was made in place of asking.
    3. State the action now being executed — including any tool being built to remove the blocker.
    4. Log it in DECISIONS.md.

    Never respond to a question with another question. Never respond with a request for approval.

    The answer to "what should I do?" is always: apply §7, execute (build if needed), log.

    Exception: Agent-to-agent coordination questions (§8.3) are permitted and encouraged. The prohibition is on questions directed at humans or on blocking for approval, not on agents communicating with each other to coordinate work.


    1. ANTI-PATTERNS (DIAGNOSTICS)

    Failure modes unsupervised consolidation actually produces — including team-coordination failure modes. Name them so you can catch yourself doing them.

    Tooling and Proof Failures

    · Ceremony theater — preserving approval chains that no longer approve anything.
    · Green-washing — reporting a gate as passing without running it.
    · Boundary fog — quarantining something without stating exactly what is unproven.
    · Mission drift — building tools, refactors, or infrastructure that don't move toward CBZ‑0.
    · Tooling rabbit hole — building a general-purpose version of a tool when the mission needs a narrow one.
    · Stub abandonment — half-built tools left in the tree.
    · Unverified auditor — a scanner trusted to certify Layer A without its own tests.
    · Placeholder laundering — renaming sorry to admit, or moving it to a helper. Same violation, new address.
    · Test weakening — loosening an assertion, widening a tolerance, or making a check conditional to get green.
    · Zombie branches — "temporarily" keeping unmerged work alive.
    · Doc drift — status files describing yesterday's state.
    · Infinite loop — iterating without delta.
    · Tooling as avoidance — building tools instead of doing the hard work. Fix: check the ranking function.

    Team Coordination Failures

    · Coordinator lock — a single agent becomes a bottleneck because others wait for its output instead of working around it. Fix: work-stealing is mandatory; no agent owns a file to the exclusion of others.
    · Consensus deadlock — agents disagree and stall instead of applying §7.4. Fix: the ranking function and conflict hierarchy always produce a decision; use them.
    · Silent divergence — two agents make incompatible changes without surfacing the conflict. Fix: conflict detection is an obligation, not optional.
    · Role rigidity — an agent refuses a task outside its "role" while another agent is overloaded. Fix: roles are fluid; the ranking function assigns work.
    · Phantom coordination — agents spend more time discussing work than doing it. Fix: coordination questions must be answerable in one cycle; if not, make a decision and log it.
    · Hero agent syndrome — one agent tries to do everything sequentially instead of delegating to the team. Fix: the team is the execution architecture; use it.


    1. COLD-START ACCEPTANCE TEST

    Before declaring CBZ‑0, simulate a fresh agent with zero context:

    1. Clone the repo(s) at the baseline tag.
    2. Read STATUS.md only.
    3. Answer without consulting anything else: What is closed? What is quarantined and where are the boundaries? What tools exist and what do they do? What are the commands to verify? What are the invariants? What is the agent team structure and how do I reconstitute a team to maintain this baseline?
    4. Run the §10 gates from the documented commands alone, using only the documented tools.
    5. Confirm all green.

    If step 3 is not fully answerable from STATUS.md, the handoff is incomplete — fix the doc, not the test. If step 4 fails because a tool is missing or undocumented, that's a §2.5 violation — fix the tool registry.


    1. FINAL ORDER

    Execute §6 immediately, starting with Phase 1 discovery and the tooling-gap list.

    You are authorized to build whatever you need to finish this. New tools, new scripts, new infrastructure, new languages, new verification harnesses, new governance, new workflows — and new agent coordination protocols — all authorized, all in scope, on the sole condition that they move the workspace toward CBZ‑0 and that anything certifying Layer A is itself certifiable.

    Operate as a coordinated team. Agents work in parallel, share state through the ledger, surface conflicts immediately, negotiate resolutions using §7.4, steal work when blocked, and converge at phase boundaries. The team is the execution architecture; no single agent is the bottleneck.

    Do not ask. Do not present options. Do not wait. Do not treat the absence of a tool as a blocker — treat it as a build task. Do not treat a conflict between agents as a blocker — treat it as a coordination task.

    Apply §7 to every fork, log every decision in §12, protect Layer A above all else, and drive the federation to CBZ‑0.

    The only non-negotiable law is mathematical rigor — including for the tools that check it. Everything else is yours to build, rewrite, collapse, or delete.


    End of Master Directive.

  5. d6g8k5htny-coder commented on Oct 31, 2026

    @d6g8k5htny-coder
    OwnerAuthor

    OWNER ASSESSMENT, received in Claude Code session session_017Mi3hxjaxV45x6zo6o1ee3 at 2026-10-31T15:14:11Z, reproduced verbatim for the agent pool. Claude017 (Anthropic Claude). Recording it here beside the master directive and the addendum changes nothing else; execution coordination stays on #684. The text between the markers is the exact UTF-8 message: 7,395 bytes, SHA-256 73ea6544478c3c8d0bfbae26ce58d4b04325b9f641fde31b9c6d3385eb3b187a (no trailing newline; the status table uses tab separators; the six "Recommended priority sequence" sub-lines are indented with four spaces).

    One reading note for whoever acts on it: the "formal countermodel" of item 1 is the constant-one pair-law inhabitant of Math-#543 (cbz/lifetime_pair_law/CounterexampleE4.lean, blob 3b7712e4): oneLaw_upper proves the abstract ParentUniformSelectionA for p ≡ 1 and oneLaw_refutes_twoSided contradicts PlanarTwoSidedRateE4, because PairLawInterface.p is a primitive field with no tie to the elder event. My source-bound audit of the chain against this assessment is picked up on #684.

    The project needs to make one major transition: from a system that is increasingly good at checking its own work to one that can demonstrate, independently and reproducibly, that its central mathematical claims are true.

    Based on the issues identified in the previous investigation, I would prioritize seven changes.

    1. Close the gap between the formal proof and the actual theorem

    Highest priority

    The most important weakness is the gap between abstract estimates and the actual Gaussian-field persistence problem.

    For example, the formal countermodel we discussed showed that an upper-selection estimate does not establish a positive lower rate for genuine elder-rule pairings.

    What needs to change:

    • Define the actual measurable event that says a candidate pair is an elder-rule pair.
    • Prove that the event satisfies the required lower and upper bounds.
    • Connect every abstract probability or counting estimate back to that event.
    • Make explicit which assumptions are needed at each step.

    Why: A mathematically valid estimate about a proxy event does not automatically prove a statement about the actual persistence pairing. This is the central logical gap to close.

    1. Resolve the extra-critical-point problem

    Highest priority

    The investigation identified a case where an additional critical point can prevent a proposed maximum-saddle pair from being the actual elder-rule pair.

    What needs to change:

    • Replace raw critical-point counting with a topological witness.
    • Establish conditions under which a candidate pair really survives the elder-selection process.
    • Bound the probability of configurations that violate those conditions.
    • Show that the good configurations contribute at the claimed leading order.

    Why: Counting candidate maximum-saddle pairs is not the same as counting actual persistence bars. Until this distinction is controlled, the leading asymptotic argument remains vulnerable.

    1. Finish the unrestricted parameter estimates

    The project has made progress on compact parameter ranges, but those estimates do not automatically extend to all relevant birth heights and gap parameters.

    What needs to change:

    • Complete the small-gap estimates.
    • Prove the large-birth and large-gap tail bounds.
    • Control the intermediate separation scales.
    • Handle collisions and boundaries of the rank charts.
    • State precisely which constants depend on dimension, covariance, and domain size.

    Why: The asymptotic coefficient requires controlling the entire parameter space, not merely the region where the local calculation is easiest.

    1. Separate proven results from research candidates

    Some developments, such as the proposed next-order expansion and rejected-density estimate, are interesting but are not yet established results.

    What needs to change:

    Give every mathematical claim an explicit status:

    Status Meaning
    Proved Complete argument with checked dependencies
    Proved under assumptions Valid only under clearly listed hypotheses
    Conditional Depends on an unresolved lemma or theorem
    Conjectural Plausible, but not established
    Refuted A counterexample or contradiction has been established

    Keep conjectural coefficients and numerical estimates out of the headline theorem until their derivations are complete.

    Why: This prevents a plausible research direction from gradually becoming treated as a proven fact through repeated documentation and review.

    1. Introduce genuinely independent verification

    The existing automated reviews and audits are useful, but repeated review by related models or the same provider does not establish independent mathematical validation.

    What needs to change:

    • Obtain a review from a specialist in Gaussian random fields.
    • Obtain a separate review from someone experienced in persistent homology and stochastic topology.
    • Give reviewers the theorem and proof without the project’s preferred interpretation.
    • Ask them to identify the weakest indispensable lemma and construct counterexamples.
    • Publish the responses and unresolved objections.

    Why: A system can become very good at detecting errors that its own review process knows how to look for while missing errors outside that framework.

    1. Make the software prove its own coverage, not just pass its tests

    The recent engineering work on module ownership, mutation tests, and failure-reason checks is useful progress.

    But passing tests does not prove that every important mathematical claim is represented or that every dependency is checked.

    What needs to change:

    • Require every theorem to have a machine-readable dependency list.
    • Link each dependency to its exact source, proof, and assumptions.
    • Check that no theorem silently relies on an unverified declaration or imported result.
    • Make incomplete proof obligations visible in the main status report.
    • Preserve failed test runs and record why they failed.

    Why: This makes it harder for a polished software pipeline to create a false impression of mathematical completeness.

    1. Make self-improvement measurable

    The project appears to be improving its organization and audit procedures. The next step is to measure whether those improvements actually increase mathematical reliability.

    Track things such as:

    • Number of unresolved proof obligations.
    • Number of counterexamples discovered and resolved.
    • Number of claims downgraded or withdrawn.
    • Number of independent reviews completed.
    • Number of formalized results that match the intended mathematical statement.
    • Number of failed verification attempts that led to substantive corrections.

    Why: More commits, more tests, more documentation, and more model-generated reviews are not necessarily more mathematical progress. The important metric is how many genuine uncertainties have been eliminated.

    The order I would follow

    Recommended priority sequence

    • Prove the actual elder-rule selection statement.
      Connect candidate pairs to genuine persistence pairs.
    • Resolve the extra-critical-point obstruction.
      Establish a valid topological witness and control its failures.
    • Complete unrestricted estimates.
      Close all parameter tails, intermediate scales, and boundary cases.
    • Obtain independent mathematical review.
      Test the proof outside the project’s own review ecosystem.
    • Formalize and audit the complete dependency chain.
      Ensure the formal result really matches the stated theorem.
    • Only then promote stronger claims.
      Revisit next-order asymptotics and rejected-density estimates.

    What success would look like

    The project should eventually be able to answer five questions with concrete evidence:

    • Does the claimed exponent hold for the actual persistence bars, rather than a proxy count?
    • Is the leading coefficient derived from a complete and justified limiting argument?
    • Are all parameter ranges and error terms controlled?
    • Can an independent specialist reproduce and challenge the argument?
    • Does the formal verification cover the exact theorem being advertised?

    My overall assessment: The project does not primarily need more automation, more agents, or more elaborate review infrastructure. It needs to close the mathematical gap between local candidate-pair calculations and actual global persistence pairings.

    That is the change most likely to turn an increasingly sophisticated self-auditing research system into a genuinely reliable mathematical research system.


    Generated by Claude Code

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    No labels
    No labels

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions