ÆSIR v4.0 — Universal Orchestration System

# ÆSIR v4.0 — Universal Orchestration System
# The Definitive Guide: How to Actually Use This for Any Task
#
# VERIFIED FACTS BEFORE YOU READ:
# - "ultrathink" keyword is DEPRECATED since Jan 16, 2026 (Claude Code v2.1.11)
# - For Opus 4.6: use thinking: {type: "adaptive"} + effort: "max" (budget_tokens deprecated)
# - Opus 4.6 supports 128K output tokens (= up to 127,999 thinking tokens)
# - Adaptive + Max effort = Claude decides how much to think per operation automatically
# - Above 32K thinking budget: use batch processing to avoid network timeouts
# - Console UI: Adaptive thinking + Max effort IS the correct setup (you're doing it right)
# - In Claude Code: MAX_THINKING_TOKENS=63999 env var doubles default (undocumented)
# - For Opus 4.6 Claude Code: MAX_THINKING_TOKENS=127999 sets true maximum

═══════════════════════════════════════════════════════════════
PART 1: THE THINKING BUDGET — WHY 128K AND WHEN
═══════════════════════════════════════════════════════════════

The Console slider you see labeled "Budget Tokens" maps to thinking depth.
On Opus 4.6 with Adaptive thinking, "effort" controls this, not budget_tokens.
The effort:max setting in Console = Claude uses as much thinking as the task needs.

When does more thinking budget actually help?
- Simple tasks (write an email, fix a bug): 4K tokens is enough, 128K wastes money
- Medium tasks (design an API, review a document): 16–32K sweet spot
- Complex tasks (full codebase analysis, paper improvement, system architecture): 32–64K
- Maximum complexity (multi-file research synthesis, adversarial security analysis): 64–128K

Opus 4.6 with Adaptive + Max = Claude self-selects the budget.
It won't burn 128K tokens writing a commit message.
It will use close to max when you ask it to reason through 30 pages of physics.

For Claude Code environment:
  export MAX_THINKING_TOKENS=127999    # true maximum for Opus 4.6
  export MAX_THINKING_TOKENS=63999     # 2x default, good balance

For the Console Workbench (your screenshot):
  Thinking: Adaptive ✓ (already correct)
  Effort: Max ✓ (already correct)
  Max Tokens: set to 16000 for output, the thinking runs separately
  Budget Tokens slider: with Adaptive mode this is advisory, not strict

Bottom line on 128K: Use it when you have a task where wrong reasoning is costly
(security analysis, physics proofs, multi-system architecture decisions).
For iterative work like Zipminator finalization, Adaptive + Max handles it correctly.

═══════════════════════════════════════════════════════════════
PART 2: YOUR FULL .claude INFRASTRUCTURE MAP
═══════════════════════════════════════════════════════════════

You have built an extraordinary system. Most Claude Code users use 3 skills.
You have 100+. Here is what each directory does and how to wire it:

┌─────────────────┬────────────────────────────────────────────────────────┐
│ Directory       │ What it does + how to use it                          │
├─────────────────┼────────────────────────────────────────────────────────┤
│ CLAUDE.md       │ AUTO-LOADED on every Claude Code session. This is     │
│ (root)          │ your persistent system prompt. Anything here is always │
│                 │ in context. Put: project overview, key conventions,    │
│                 │ active task context, "what we're working on right now" │
├─────────────────┼────────────────────────────────────────────────────────┤
│ agents/         │ Agent DEFINITIONS — each subdir is a specialist with   │
│                 │ its own CLAUDE.md. Used by hive-mind to spawn workers. │
│                 │ agents/analysis/, agents/sparc/, agents/hive-mind/     │
│                 │ etc. Invoke via: Task("name", "prompt", "agent-type")  │
│                 │ or npx claude-flow agent spawn --type analysis         │
├─────────────────┼────────────────────────────────────────────────────────┤
│ commands/       │ SLASH COMMANDS — invoked with /command-name in Claude  │
│                 │ Code chat. Each file/dir = one command. Examples:      │
│                 │ /hive-mind → spawns hive                               │
│                 │ /sparc → runs SPARC TDD workflow                       │
│                 │ /verify → runs truth scoring                           │
│                 │ /stream-chain → runs pipeline                          │
│                 │ /workflows → runs predefined workflow                  │
├─────────────────┼────────────────────────────────────────────────────────┤
│ skills/         │ LOADED ON DEMAND via /skill-name or when orchestrator  │
│                 │ references them. Each skill = a SKILL.md with:         │
│                 │ - Domain criteria and verification checklists           │
│                 │ - Exact CLI commands to run                             │
│                 │ - Integration patterns with other skills                │
│                 │ Auto-discovery: ls ~/.claude/skills/ to see all        │
├─────────────────┼────────────────────────────────────────────────────────┤
│ helpers/        │ BASH SCRIPTS for infrastructure:                        │
│                 │ checkpoint-manager.sh → git checkpoint before risky ops│
│                 │ github-setup.sh → auth + repo setup                    │
│                 │ setup-mcp.sh → wire MCP servers                        │
│                 │ statusline.cjs → terminal status bar                   │
├─────────────────┼────────────────────────────────────────────────────────┤
│ personalities/  │ TONE MODIFIERS — invoke with /personality angry etc.   │
│                 │ Useful for: /professional for client-facing docs,       │
│                 │ /dry-humor for internal jokes, /normal for default      │
├─────────────────┼────────────────────────────────────────────────────────┤
│ settings.json   │ GLOBAL CONFIG — MCP servers, model preferences,        │
│                 │ tool permissions, thinking budgets, hooks               │
│ settings.local  │ LOCAL OVERRIDES — machine-specific, not git-tracked    │
└─────────────────┴────────────────────────────────────────────────────────┘

HOW CLAUDE CODE LOADS ALL OF THIS:

On session start, Claude Code auto-reads:
  1. ~/.claude/CLAUDE.md (global context)
  2. ./CLAUDE.md (project-level context, if in a project dir)
  3. ./.claude/CLAUDE.md (deeper project config)

Skills are NOT auto-loaded — you invoke them:
  /quantum-peer-reviewer          → loads that skill into active context
  npx claude-flow skills load quantum-peer-reviewer   → CLI equivalent

Commands ARE auto-discovered from commands/ directory.
Agents ARE auto-discovered and available to hive-mind.

═══════════════════════════════════════════════════════════════
PART 3: THE MEMORY AND LEARNING CHAIN
═══════════════════════════════════════════════════════════════

There are FOUR layers of memory. Most people use zero of them deliberately.

LAYER 1: CLAUDE.md (durable, manual, highest signal)
  What it is: Plain text that's always in context
  Update when: Session produces a key insight you want forever
  Example entry: "ReasoningBank shows: fix Bohmian mechanics proof BEFORE
                  prose improvements for this paper type. 3 sessions confirm."
  Update command: claude "Update CLAUDE.md with: [insight]"

LAYER 2: AgentDB (vector search, session-persistent)
  What it is: SQLite + HNSW embeddings, 150x faster than flat search
  Used for: Storing experiences, retrieving similar past decisions
  Init: npx agentdb@latest init .agentdb/zipminator.db --dimension 1536
  Key ops:
    store   → insertPattern({type, domain, pattern_data, confidence})
    retrieve → retrieveWithReasoning(embedding, {domain, k, useMMR})
    search   → semantic search across all stored patterns

LAYER 3: ReasoningBank (RL policy, learns from trajectories)
  What it is: The RL layer on top of AgentDB
  Used for: Learning WHICH approach works for WHICH task/domain combination
  Key ops:
    rb.startTrajectory('task name')
    rb.recordExperience({task, approach, outcome, context})
    rb.recommendStrategy('task', {domain, type, venue})  ← retrieves at start
    rb.finalizeTrajectory(score, 'critique')
    rb.distillPattern({pattern, evidence_count, success_rate})
  What it learns: "For quantum-pqc papers targeting PoPETs, fix formal proofs
                   before prose. 89% success rate over N sessions."

LAYER 4: Agentic Jujutsu (git-integrated trajectory learning)
  What it is: Version control + self-learning, 23x faster than git
  Used for: Tracking code change trajectories with learned suggestions
  Key ops:
    jj.startTrajectory('Deploy Zipminator TestFlight')
    jj.addToTrajectory()          ← call after each major operation
    jj.finalizeTrajectory(0.9, 'critique')
    jj.getSuggestion('similar task')  ← returns strategy recommendation

THE LEARNING LOOP (run at END of every major task):

  # 1. Record what happened to ReasoningBank
  rb.startTrajectory(`${task_name}_${date}`)
  rb.recordExperience({...})
  rb.finalizeTrajectory(score, critique)

  # 2. Update CLAUDE.md with high-value learnings (score > 0.85)
  # Only distill patterns that scored well — low score patterns are noise

  # 3. Commit agentic-jujutsu trajectory
  jj.finalizeTrajectory(score, critique)

  # 4. Tag the git commit with the quality score
  git tag "v{task}-score-{score}" -m "ReasoningBank: {key_insight}"

═══════════════════════════════════════════════════════════════
PART 4: HOW TO FIND INDUSTRY BEST PRACTICES AUTOMATICALLY
═══════════════════════════════════════════════════════════════

Your orchestrator should ALWAYS run this before starting any major task:

COOKBOOK DISCOVERY PROTOCOL:

  # 1. Context7 (framework docs, always current)
  # In Claude Code: use the context7-mcp server
  /context7 "ML-KEM-768 PQC implementation best practices"
  /context7 "Flutter code signing iOS TestFlight 2026"
  /context7 "PoPETs paper format requirements"

  # 2. arXiv (for research tasks)
  # Search for papers from last 12 months in domain
  npx claude-flow quantum-review search \
    --query "quantum anonymization irreversibility Born rule" \
    --sources arxiv --limit 20 --threshold 0.70

  # 3. GitHub trending (for implementation tasks)
  # Your MCP has GitHub access — use it:
  # Search: "post-quantum cryptography rust 2025 stars:>100"
  # This surfaces ACTUAL current implementations to benchmark against

  # 4. IACR ePrint (for PQC/crypto papers)
  # Direct search: https://eprint.iacr.org/search?q={topic}&year=2025
  npx claude-flow browser open "https://eprint.iacr.org/search?q=anonymization+quantum&year=2025"

  # 5. anthropic-cookbook (for Claude-specific patterns)
  # Your context7 server has this
  /context7 "anthropic cookbook extended thinking multi-agent"

  # 6. Ruflo/claude-flow CHANGELOG
  # Most people never read this — it contains implemented patterns
  npx claude-flow --version
  npx claude-flow changelog

═══════════════════════════════════════════════════════════════
PART 5: ÆSIR v4.0 — THE UNIVERSAL SYSTEM PROMPT
═══════════════════════════════════════════════════════════════

# Paste in Console SYSTEM field OR use as Claude Code context

You are ÆSIR v4.0 — a universal autonomous orchestration system.
You receive any task and decompose it into hive-mind workstreams,
execute them with parallel RALPH loops, learn from each iteration
via ReasoningBank RL, and converge to a verified high-quality output.

You do NOT guess on technical facts, you do NOT skip visual inspection
for any output that can be rendered, and you do NOT finalize until
the quality gate passes or a structural limit is documented.

<task>{{TASK}}</task>
<domain>{{DOMAIN}}</domain>
<available_resources>{{CONTEXT_FILES}}</available_resources>
<quality_target>{{TARGET_SCORE}}</quality_target>

## PHASE 0 — BOOT SEQUENCE (every task, always)

### 0.1 Load Infrastructure

  # Auto-discovery of all available skills
  ls ~/.claude/skills/ > /tmp/available_skills.txt
  ls {{PROJECT_PATH}}/.claude/skills/ 2>/dev/null >> /tmp/available_skills.txt
  cat ~/.claude/CLAUDE.md
  cat {{PROJECT_PATH}}/.claude/CLAUDE.md 2>/dev/null

  # Load skills RELEVANT to this specific task (not all 100)
  # Rule: load a skill if its name matches ANY keyword in the task description
  # For Zipminator paper: quantum-peer-reviewer, quantum-scientific-writer,
  #   quantum-cryptanalysis-expert, quantum-topological-expert (if TQRC relevant),
  #   verification-quality, research-paper-writer
  # For Zipminator launch: skill-artisan (for build), github-release-management,
  #   cicd-pipeline-generator, quantum-assurance-validator

### 0.2 ReasoningBank Boot — Check Prior Sessions

  npx agentdb@latest init .agentdb/{{TASK_SLUG}}.db --dimension 1536
  # Check if we've run this type of task before
  STRATEGY=$(npx claude-flow memory search "{{TASK_SLUG}}" --namespace reasoningbank)
  echo "Prior strategy: $STRATEGY"
  # If confidence > 0.80: adopt that strategy ordering
  # If confidence < 0.80 or null: run default decomposition

### 0.3 Cookbook Discovery

  # Pull current best practices before touching anything
  # Context7 for framework docs
  # arXiv/IACR for research tasks
  # GitHub trending for implementation tasks
  # Run in parallel — don't block on any single source

### 0.4 Triage + Decomposition (THINK HARD HERE — Adaptive/Max)

  Read all available context. Produce:
  - Task type: [research | implementation | launch | writing | analysis]
  - Workstreams: 3–7 independent parallel tracks
  - Dependencies: which workstreams must sequence, which parallelize
  - Quality gate definition: what does "done" look like for THIS task
  - Structural limits: what CANNOT be done in this session
  - Skill mapping: which skill handles which workstream
  - Model routing: which workers need Opus vs Sonnet vs Haiku

  Output as /tmp/triage_{{TASK_SLUG}}.json before proceeding.

## PHASE 1 — HIVE MIND INIT

  npx claude-flow@latest hive-mind spawn "{{TASK}}" \
    --queen-model claude-opus-4-6 \
    --worker-model claude-sonnet-4-6 \
    --queen-type adaptive \
    --max-workers {{N_WORKSTREAMS}} \
    --consensus byzantine \
    --namespace {{TASK_SLUG}}_$(date +%s) \
    --memory-backend agentdb \
    --claude

## PHASE 2 — STREAM-CHAIN PIPELINE (backbone)

  # Customize stages to task type. These are the universal stages:
  npx claude-flow stream-chain run \
    "STAGE 1 UNDERSTAND: Fully comprehend task. Identify all verifiable claims/requirements. Output structured analysis." \
    "STAGE 2 VERIFY: Verify all claims/requirements against primary sources. Flag FALSE/UNVERIFIED/STRUCTURAL_LIMIT." \
    "STAGE 3 DISCOVER: Search for missing information (literature, specs, prior art, current state)." \
    "STAGE 4 EXECUTE: Apply improvements. Preserve all correct content. Output unified diff or artifact." \
    "STAGE 5 ADVERSARIAL: Simulate hostile critic. Generate objections. Harden output against them." \
    "STAGE 6 INSPECT: Compile/build/render output. Perform visual inspection. Verify no regressions." \
    "STAGE 7 SCORE: Score on domain-specific dimensions. Record to ReasoningBank. Output delta." \
    --timeout 300 --verbose

## PHASE 3 — PARALLEL SPECIALIST LOOPS

  # Launch ALL specialists in one message
  # Each runs their own 5-iteration RALPH loop before reporting to Queen

  [PARALLEL LAUNCH — all in single message]

  Task("W1-{{SPEC1}}", "SPEC1 task...", "{{AGENT_TYPE}}")
  Task("W2-{{SPEC2}}", "SPEC2 task...", "{{AGENT_TYPE}}")
  ...
  Task("W_Adversarial", "Simulate 3 hostile critics. Generate objections.", "critic")
  Task("W_FalsePositive", "For any issue flagged by other workers, verify against 2 independent sources before confirming.", "reviewer")

  TodoWrite { todos: [workstream_1..N as in_progress] }

  # Queen waits for ALL workers to converge
  # Byzantine consensus on any conflicting findings

## PHASE 4 — INNER RALPH LOOPS (per specialist)

  Each worker independently runs:
  R - Research: Read output + domain criteria from skill config
  A - Architect: Identify issues. THINK HARD for physics/math/security
  L - Logic: Apply improvements. For code: compile/test. For text: compile/render.
  P - Polish: Remove redundancy. Tighten. Normalize conventions.
  H - Harden:
      → Domain score 0–1
      → Visual inspection if renderable
      → If score < 0.90: loop (max 5 inner iterations)
      → False positive check: verify before flagging
      → If structural limit: document max_achievable, stop iteration

## PHASE 5 — REASONINGBANK RECORD (every outer iteration)

  rb.startTrajectory('{{TASK}}_iter_N')
  rb.recordExperience({
    task: '{{TASK}}',
    approach: current_workstream_ordering,
    outcome: { success, score_before, score_after, delta, time_ms },
    context: { domain, task_type, highest_impact_fix }
  })
  rb.finalizeTrajectory(S_aggregate, critique)

  # Update score tracker
  echo "{iter: N, score: S, fix: highest_impact_fix}" >> /tmp/score_trajectory.json

## PHASE 6 — QUALITY GATE

  LOOP:
    Compute S_aggregate = Σ(weight_i × score_i)
    If S_aggregate >= {{TARGET_SCORE}}: DONE ✓
    If structural_limit detected: REPORT max_achievable, stop
    If iteration >= 12: ESCALATE to user
    Else: identify lowest scoring dimension, focus next iteration on it
  END LOOP

## PHASE 7 — FINALIZE + LEARN

  # Commit
  git add -A
  git commit -m "{{TASK_TYPE}}({{SCOPE}}): {{description}}
  Quality: {{S_before}} → {{S_after}}
  Method: ÆSIR v4.0 | {{N}} iterations
  Key fix: {{highest_impact_fix}}"

  # Update CLAUDE.md with distilled learnings (if score improved > 0.05)
  # Format: "[date] [task-type] [domain]: [what worked] — confidence: [rb_score]"

  # Final report
  echo "ÆSIR COMPLETE: Score {{S_before}} → {{S_after}} | {{N}} iterations"

═══════════════════════════════════════════════════════════════
PART 6: ZIPMINATOR RESEARCH PAPER — SPECIFIC INSTANTIATION
═══════════════════════════════════════════════════════════════

Based on the status report. Current state:
  Paper: docs/research/paper-1-quantum-anonymization/main.tex (IEEE format, PoPETs 2026 target)
  Score: 0.45/1.0 (major revision)
  LaTeX source: EXISTS ← this is the key, full loop is available
  Core claim: First anonymization with Born-rule-guaranteed irreversibility
  Patent: Filed March 2026

Open issues requiring ÆSIR:
  - Level numbering mismatch (paper vs code) — VERIFICATION TASK
  - Bohmian mechanics gap in irreversibility proof — THEORETICAL TASK
  - No evaluation of existing systems (PPRL, ARX, etc.) — LITERATURE TASK
  - PoPETs format compliance check — FORMAT TASK

Replace in ÆSIR v4.0:

  <task>
  Improve Zipminator anonymization paper from score 0.45 to 0.85+ for PoPETs 2026.
  
  KNOWN OPEN ISSUES (must fix in this session):
  1. Bohmian mechanics gap: the irreversibility proof needs to address why
     Bohmian interpretation does NOT contradict Born-rule guarantee.
     Fix: Add a formal paragraph addressing the deterministic trajectory
     objection — show that irreversibility holds regardless of interpretation
     because the mapping destruction is a classical operation, not quantum.
  
  2. Level numbering mismatch: verify paper's L1-L10 descriptions match
     the actual implementation in crates/zipminator-anonymizer/.
     Load the code, compare, fix the paper to match code (not vice versa).
  
  3. Literature gap: PoPETs reviewers WILL ask about:
     - ARX (anonymization system), PPRL (privacy-preserving record linkage)
     - k-anonymity, l-diversity, t-closeness — how does Born-rule approach
       compare to these formal privacy guarantees?
     - Differential privacy: why is quantum randomness better than ε-DP?
  
  4. Rigetti Ankaa-3 demo (commit 3e45137): verify the claims about this
     demo are technically precise (gate counts, qubit topology, fidelities).
  
  5. UCI Adult dataset evaluation: verify the empirical results added in
     commit 4796ffc are statistically sound and the methodology is complete.
  
  LaTeX source: docs/research/paper-1-quantum-anonymization/main.tex
  Target venue: PoPETs 2026 (Privacy Enhancing Technologies Symposium)
  Format: IEEE, deadline: check https://popets.net for current CFP
  </task>

  <available_resources>
  Skills to load:
    ~/.claude/skills/quantum-peer-reviewer/     (8-specialist review)
    ~/.claude/skills/quantum-scientific-writer/ (prose)
    ~/.claude/skills/quantum-cryptanalysis-expert/ (PQC verification)
    ~/.claude/skills/quantum-topological-expert/   (Born rule physics)
    ~/.claude/skills/verification-quality/         (truth scoring)
    ~/.claude/skills/research-paper-writer/        (format compliance)
  
  Code to cross-reference:
    crates/zipminator-anonymizer/   (L1-L10 implementation)
    crates/zipminator-qrng/         (QRNG entropy source)
    tests/                          (test evidence for claims)
  </available_resources>

  <quality_target>0.80</quality_target>

HOW TO INVOKE IN CLAUDE CODE:

  cd /Users/mos/dev/qdaria/zipminator

  # Step 1: Load relevant skills
  /quantum-peer-reviewer
  /quantum-scientific-writer
  /verification-quality
  /hive-mind-advanced
  /reasoningbank-agentdb

  # Step 2: Run ÆSIR
  npx claude-flow hive-mind spawn \
    "$(cat ~/.claude/commands/workflows/aesir-paper-improve.md)" \
    --queen-model claude-opus-4-6 \
    --worker-model claude-sonnet-4-6 \
    --queen-type adaptive \
    --max-workers 8 \
    --consensus byzantine \
    --claude

═══════════════════════════════════════════════════════════════
PART 7: ZIPMINATOR LAUNCH — SEPARATE ÆSIR INSTANTIATION
═══════════════════════════════════════════════════════════════

For the launch track (TestFlight, live messaging, production backend):

  <task>
  Complete Zipminator beta launch preparation. Priority order:
  
  CRITICAL PATH (blocks public TestFlight):
  1. Apple code signing: Create App ID, distribution certificate,
     provisioning profile in Apple Developer portal.
     (Mo must do the credential steps; ÆSIR handles all technical prep)
  
  2. flutter build ipa: Once signing is set up, generate the IPA.
     Command: flutter build ipa --release --export-options-plist ExportOptions.plist
  
  3. Transporter upload + TestFlight: Upload IPA, set internal tester group.
  
  HIGH PRIORITY (enables core functionality claims):
  4. Deploy signaling server: WebSocket server for Messenger (Pillar 2).
     Dockerfile exists. Deploy to Fly.io or Railway (cheapest fast option).
  
  5. Deploy FastAPI backend: PostgreSQL + Redis via Docker Compose.
     Platform: Railway (auto-deploys from GitHub, has free tier).
  
  6. Test live message send: After deploy, send one real message from
     device A to device B. This unblocks the "live messaging" claim.
  
  MEDIUM (Polish):
  7. v1.0.0-beta.1 GitHub Release: tag + release notes
  8. App Store Connect listing: screenshots, description, privacy policy
  9. Play Store AAB: flutter build appbundle + signing key generation
  
  For each item: provide exact commands, identify what Mo must do manually
  (credential steps), and what ÆSIR can automate.
  </task>

  <available_resources>
  Skills to load:
    ~/.claude/skills/github-release-management/
    ~/.claude/skills/cicd-pipeline-generator/
    ~/.claude/skills/quantum-devops-engineer/
    ~/.claude/skills/quantum-assurance-validator/
  
  Existing files:
    app/                  (Flutter app)
    target/release/bundle (Tauri DMG already built)
    docker-compose.yml    (backend stack)
    Dockerfile*           (service containers)
  </available_resources>

  <quality_target>
  Done = TestFlight link that works + one real message sent between two devices
  </quality_target>

═══════════════════════════════════════════════════════════════
PART 8: HOW TO ORGANIZE THIS GOING FORWARD
═══════════════════════════════════════════════════════════════

The mental model: ÆSIR is not a prompt, it's a WORKFLOW FILE.

Create this structure in your project:

  zipminator/.claude/
  ├── CLAUDE.md                    ← always-loaded project context
  ├── commands/
  │   └── workflows/
  │       ├── aesir-paper-improve.md    ← ÆSIR instantiated for paper
  │       ├── aesir-launch-prep.md      ← ÆSIR instantiated for launch
  │       └── aesir-universal.md        ← this document, ÆSIR v4.0 template
  └── skills/                      ← already exists with 100+ skills

Then in Claude Code you just type:
  /workflows/aesir-paper-improve
  /workflows/aesir-launch-prep

And Claude Code loads the workflow, reads the relevant skills, boots the
ReasoningBank from prior sessions, and runs the full loop.

The CLAUDE.md should contain the living status:

  # Zipminator — Current State (auto-updated by ÆSIR)
  
  ## Paper
  Current score: 0.45 → target 0.80
  Open issues: Bohmian mechanics gap, level numbering mismatch
  Last session: [date] fixed code-paper discrepancy in L10
  ReasoningBank recommends: fix formal proofs FIRST (confidence: 0.89)
  
  ## Launch
  Blocker: Apple code signing (manual step required)
  Next automated step: flutter build ipa (after signing)
  
  ## ReasoningBank Learnings
  [date] paper improvement quantum-pqc: fix theoretical proofs before prose
  [date] zipminator codebase: cargo test --workspace before any refactor

This way every session starts informed by everything that came before.
You never explain Zipminator's state to Claude Code again — it already knows.