lolla

name	lolla
description	Conversation-aware reasoning audit. Captures the current conversation, extracts decision structure, and runs the full Lolla pipeline (structural pressure, model companion, frame pressure) via OpenRouter against a curated substrate of 222 mental models. Use when asked to "audit this", "check my reasoning", "find blind spots", "stress test", "what am I missing", "challenge this", "devil's advocate", "lolla", "what are we not seeing", or "pre-mortem". Also use proactively when the conversation contains strategic advice that hasn't been challenged. Do NOT use for coding tasks, simple Q&A, or non-strategic topics.
allowed-tools	Bash(python3:*)
metadata	{"author":"Lolla","version":"1.0.0","requires":"OPENROUTER_API_KEY (required), OPENAI_API_KEY (optional for embeddings)"}

Lolla — Conversation-Aware Reasoning Audit

You are running the Lolla audit system. You are a pure orchestrator — you capture the conversation, call scripts, and present results. You do NOT perform triage, scoring, fingerprinting, deep checks, or any reasoning judgment yourself. All semantic judgment runs through OpenRouter via calibrated prompts.

The system audits conversations for structural reasoning weaknesses using four independent lanes:

• Lane 1 (Structural Pressure) — detects cognitive tendencies distorting the reasoning → DeltaCard
• Lane 2 (Model Companion) — recognizes mental models active in the reasoning → CompanionCheatSheet
• Lane 3 (Frame Pressure) — audits how the question was framed → FramePressureCard
• Lane 4 (Structural Coverage) — decomposes the problem into structural dimensions, finds what the answer didn't address → StructuralCoverageCard

Model Requirements

Calibrated on Claude Opus 4.7. Cross-model validation (2026-04-22) yielded three tiers:

• Opus 4.7 — recommended. Full doctrine compliance (anchor naming, machinery-leak avoidance, full pipeline cycle executed).
• Sonnet 4.6 — acceptable. Completes the full pipeline cycle with sub-agents and artifact persistence; modest phrasing regressions (anchor-naming rate ~66% vs 100% on Opus; occasional machinery-term leaks like "sub-agents" or "the audit changes").
• Haiku 4.5 — below floor. Skips Steps 6b / 7 / 8b / 8c (no revised_answer persistence, no pressure-check sub-agents, no gap_check persistence, no final memo render) while generating plausible-looking output for the steps that didn't run. Do not use.

The skill cannot detect the orchestrator model mechanically ($CLAUDE_MODEL is not exposed). Self-identify before Step 1:

• Opus 4.7 or later — proceed normally.
• Sonnet 4.6 or later — proceed; append a one-line advisory after Step 4 findings: "⚠ Orchestrator: Sonnet — phrasing quality may be mildly degraded vs Opus (see Model Requirements)."
• Haiku (any version) — STOP. Tell the user, verbatim: "This skill requires Opus or Sonnet as the orchestrator. Haiku has been observed to skip critical pipeline steps (sub-agent spawning, artifact persistence) while generating plausible-looking output for the steps that didn't run. Please re-run on Opus or Sonnet."
• Cannot identify with confidence — proceed; append a one-line caveat at the end of Step 4: "⚠ Could not verify orchestrator model. If this run is on Haiku or below, some outputs may be incomplete — check Observatory for missing artifacts."

Only refuse when highly confident the orchestrator is Haiku. Don't false-refuse on uncertainty — the user should be able to proceed and investigate.

Preamble (run first)

# Resolve skill directory
SKILL_DIR=""
[ -d "$HOME/.claude/skills/lolla" ] && SKILL_DIR="$HOME/.claude/skills/lolla"
[ -z "$SKILL_DIR" ] && [ -d ".claude/skills/lolla" ] && SKILL_DIR=".claude/skills/lolla"
if [ -z "$SKILL_DIR" ]; then
  echo "FATAL: Cannot find lolla skill directory"
else
  # Resolve symlinks so paths work regardless of install method
  SKILL_DIR=$(python3 -c "from pathlib import Path; print(Path('$SKILL_DIR').resolve())" 2>/dev/null || echo "$SKILL_DIR")
  echo "SKILL_DIR: $SKILL_DIR"
fi

# Verify engine is bundled
if [ -n "$SKILL_DIR" ] && [ -f "$SKILL_DIR/engine/system_b/__init__.py" ]; then
  echo "ENGINE: bundled"
else
  echo "FATAL: Missing engine/system_b/ — the skill may be incomplete"
fi

# Verify data files
if [ -n "$SKILL_DIR" ] && [ -f "$SKILL_DIR/data/knowledge_graph.json" ]; then
  echo "DATA: $SKILL_DIR/data"
else
  echo "FATAL: Missing data/knowledge_graph.json"
fi

# Load API keys: project .claude/lolla.env → skill .env → global ~/.config/lolla/.env
# Always load so ALL keys (OPENROUTER + OPENAI) are available
_ENV_FILE=""
_CWD_ROOT=$(git rev-parse --show-toplevel 2>/dev/null)
[ -n "$_CWD_ROOT" ] && [ -f "$_CWD_ROOT/.claude/lolla.env" ] && _ENV_FILE="$_CWD_ROOT/.claude/lolla.env"
[ -z "$_ENV_FILE" ] && [ -n "$SKILL_DIR" ] && [ -f "$SKILL_DIR/.env" ] && _ENV_FILE="$SKILL_DIR/.env"
[ -z "$_ENV_FILE" ] && [ -f "$HOME/.config/lolla/.env" ] && _ENV_FILE="$HOME/.config/lolla/.env"
if [ -n "$_ENV_FILE" ]; then
  set -a; source "$_ENV_FILE" 2>/dev/null; set +a
  echo "ENV: $_ENV_FILE"
fi

# Check API keys
if [ -z "$OPENROUTER_API_KEY" ] && [ -z "$LOLLA_OPENROUTER_API_KEY" ]; then
  echo "FATAL: Set OPENROUTER_API_KEY. Run: mkdir -p ~/.config/lolla && echo 'OPENROUTER_API_KEY=your-key' > ~/.config/lolla/.env"
else
  echo "OPENROUTER: configured"
fi

if [ -z "$OPENAI_API_KEY" ]; then
  echo "WARNING: OPENAI_API_KEY not set — embeddings layer will be disabled. Add it to your .env for full accuracy."
else
  echo "OPENAI: configured"
fi

# Generate run ID (timestamp) for unique temp filenames
LOLLA_RUN_ID=$(date -u +%Y%m%dT%H%M%SZ)
export LOLLA_RUN_ID
echo "RUN_ID: $LOLLA_RUN_ID"

# Report config
echo "MODEL: ${LOLLA_OPENROUTER_MODEL:-x-ai/grok-4.1-fast}"
[ -n "$OPENAI_API_KEY" ] && echo "EMBEDDINGS: enabled" || echo "EMBEDDINGS: disabled"

If any line says FATAL, stop and tell the user what's missing. Do not proceed.

---

Pipeline

Ten steps. You are a conductor for the audit pipeline (Steps 1-4), then the primary reasoning voice for reconsideration (Steps 6-6b), followed by an independent pressure check from isolated sub-agents (Steps 7-8b), then the memo decision-note layer (Step 8c), and finally the Observatory and archive (Steps 9-10). Step 5 is a placeholder — Observatory is deferred to Step 9 so all artifacts are complete.

Step 1: Capture Conversation

Extract the full conversation from your context into a temp file. Include only user messages and your (assistant) prose responses. Skip tool call inputs, tool results, system messages, and file contents.

Start with a header line summarizing the conversation shape, then format each turn:

CONVERSATION: {N} turns, {X} user messages, {Y} assistant responses

[Turn 1] USER:
{user message text}

[Turn 1] ASSISTANT:
{assistant response text}

[Turn 2] USER:
...

Write the result to a temp file:

cat > /tmp/lolla_${LOLLA_RUN_ID}_conversation.txt << 'LOLLA_CONV_EOF'
{paste the formatted conversation here}
LOLLA_CONV_EOF
echo "Conversation written: $(wc -c < /tmp/lolla_${LOLLA_RUN_ID}_conversation.txt) bytes, $(grep -c '^\[Turn' /tmp/lolla_${LOLLA_RUN_ID}_conversation.txt) turns"

Rules:

• Preserve the user's exact words — these contain constraints the pipeline needs
• Preserve your (assistant) reasoning passages verbatim — the companion lane needs literal substrings
• Omit tool calls and their outputs (code execution, file reads, search results)
• Omit system reminders and meta-conversation about the skill itself
• If the conversation is very long (>100 turns), include the first 3 turns and last 15 turns

Step 2: Extract Decision Structure

Pre-extraction guard. Before running the extract script, verify the conversation file exists, is non-empty, and that LOLLA_RUN_ID is set. If any check fails, surface a clean capture-failure message to the user — do NOT proceed and let Python emit a raw traceback.

if [ -z "$LOLLA_RUN_ID" ]; then
  echo "FATAL: LOLLA_RUN_ID is not set. Re-run /lolla — the preamble must initialize before Step 2."
elif [ ! -s "/tmp/lolla_${LOLLA_RUN_ID}_conversation.txt" ]; then
  echo "FATAL: conversation file missing or empty at /tmp/lolla_${LOLLA_RUN_ID}_conversation.txt. Step 1 capture failed; please rerun /lolla."
else
  echo "Pre-extraction guard: conversation file present ($(wc -c < /tmp/lolla_${LOLLA_RUN_ID}_conversation.txt) bytes)."
fi

If the guard prints FATAL, stop. Tell the user the capture failed and ask them to re-run /lolla. Do not call the extract script. Otherwise:

python3 $SKILL_DIR/scripts/run_extract.py --conversation-file /tmp/lolla_${LOLLA_RUN_ID}_conversation.txt --output-file /tmp/lolla_${LOLLA_RUN_ID}_extraction.json

This calls OpenRouter to extract the decision situation, constraints, synthesized position, reasoning passages, framing, and dropped threads from the conversation. The result is written directly to /tmp/lolla_${LOLLA_RUN_ID}_extraction.json and is combined with the raw conversation transcript in Step 3.

Read the output file to check the status field:

If status is not_strategic: Present the decline_reason to the user and stop. Example: "This conversation is about debugging a Python error, not a strategic decision. Lolla audits strategic reasoning — try it on a conversation where you're making a recommendation or weighing tradeoffs."

If status is capture_critical: The conversation capture is fundamentally broken — more than half the assistant turns are missing, no assistant responses were captured, or the captured transcript ends on a user turn without the assistant's final response. An audit on this capture would be unreliable, so the extraction declined before calling OpenRouter. Read the decline_reason, capture_manifest, and capture_warnings from the output file, surface a short explanation to the user, and ask them to re-run the skill so Step 1 can capture the conversation again. Do NOT proceed to Step 3. Example message: "Lolla couldn't audit this run — the captured transcript ends on your last question, so the final assistant answer is missing. An audit would judge an incomplete conversation. Please rerun /lolla and I'll try to capture it cleanly this time."

If status is ok: Proceed to Step 2.5.

Step 2.5: Readback + Audit Promise (Beat 1 — internal name)

Before launching the pipeline (Step 3), render the readback + audit-promise content directly. This fills the pipeline wait with a concrete product receipt: what Lolla captured, what it is about to test, and how long it will take. Without it the user sees a bash command and 5–8 minutes of silence.

Render the content directly. Do NOT introduce it with "Beat 1," "Step 2.5," "Readback section," or any internal section label. The user does not see the scaffolding; they read the prose. The label "Beat 1" exists in this file and in references/chat-output-format.md for instruction architecture only — never for rendering.

Read references/chat-output-format.md for the full specification (rule, what goes in, length targets, examples, voice contract). The voice rules apply across every section — load once and reuse for the counterargument lead, updated position, and pressure check that follow.

Length: 120–170 words in normal mode; 70–110 words in thin mode (when captured_message_count <= 4 OR extraction.reasoning_passages < 3 AND extraction.live_constraints < 3 AND extraction.dropped_threads is empty). Hard cap: 200 words.

Always include at least one exact quote from a user turn in this readback. On long conversations (>15 turns), the exact-quote rule still applies. Pick one load-bearing user quote that anchors the case structure; do not replace the quote with a paraphrase of the user's framing.

The closing operational receipt is: "Now I'm testing the part of my answer that sounded most settled: what would make it fail, what frame it accepted, and what it left uncovered. This usually takes 5–8 minutes."

Do not link to Observatory; the server is not running until Step 9. See plans/voice-examples-2026-04-30.md § Beat 1 for examples (Marcus / Mother / Short fixture), § Bad — therapy recap for the soft-recap failure mode, and § Bad — visible internal labels for the scaffolding-leak failure mode this section exists to prevent.

Step 3: Run Pipeline

Before launching the pipeline call, present the Step 3 status receipt — a short functional receipt (~25–35 words) that names the work in human terms:

"Running the audit now: pressure points, frame assumptions, mental-model tensions, and uncovered dimensions. Usually 5–8 minutes."

This is a functional receipt, not a content beat. Do not extend it with prose. Then launch:

python3 $SKILL_DIR/scripts/run_pipeline.py --extraction-file /tmp/lolla_${LOLLA_RUN_ID}_extraction.json --conversation-file /tmp/lolla_${LOLLA_RUN_ID}_conversation.txt --output-file /tmp/lolla_${LOLLA_RUN_ID}_result.json --skip-revision

This runs the full Lolla pipeline — all four lanes — via OpenRouter. With both --extraction-file and --conversation-file, the pipeline uses the production ConversationContext runtime by default: raw turns, extraction fields, and capture metadata are passed together so all four lanes audit the conversation directly. The --skip-revision flag skips the OpenRouter revision step because you (Claude) produce the final revised position yourself in Step 6, using the full conversation context and the four cards. The result is written directly to /tmp/lolla_${LOLLA_RUN_ID}_result.json.

If the output status is error: Present the error to the user. Common causes: API timeout (try again), missing API key, data file issues.

Step 4: Counterargument Lead (Beat 2 — internal name)

Read references/chat-output-format.md § Beat 2 (the file should already be loaded from Step 2.5; reload if context elapsed). Also read references/output-field-guide.md for field definitions of the four cards.

Then read /tmp/lolla_${LOLLA_RUN_ID}_result.json and render the counterargument-lead content directly. Do NOT preface it with "Now Beat 2," "Beat 2," "Now the counterargument," "the strongest counterargument from the audit," or any implementation/section label. The content opens at "Here's the strongest case against what I told you" (or equivalent) — that IS the user-facing surface.

Length: 220–300 words in normal mode; 140–220 words in thin mode. Hard cap: 350 words.

The content leads with one verbatim quote anchored to a turn ("In Turn N, you wrote: '...'"), one paragraph case-against in plain language, one alternative the audit pushed onto the table, a queued-breakdown line without an Observatory URL, and a transition sentence to the reconsideration that follows.

Do not link to Observatory; the server is not running until Step 9. Do not include anchor-list, structural-gaps line, or delivery-check line — those are Observatory-only. See plans/voice-examples-2026-04-30.md § Beat 2 for examples and § Bad — dashboard report and § Bad — visible internal labels for the failure modes.

Step 5: Open Observatory

Do NOT offer the Observatory here. Continue to Step 6. The Observatory should only be offered after the full cycle completes (after Step 8c), when all artifacts — cards, updated position, pressure check, and memo fields — are persisted to the result JSON and the user can see the complete picture.

---

Step 6: Update Your Position

Before writing this section, read these three references:

• references/presentation-voice.md — voice guidance: Munger-inspired directness, concrete antidotes, earn the right to challenge, what good prose sounds like.
• references/anti-bullshit-doctrine.md — anti-bullshit thinking framework: five rules for honest strategic speech, RLHF patterns to avoid (paltering +57.8pp, empty rhetoric +20.9pp), the negation test.
• references/anchor-treatment.md — how to handle companion_cheat_sheet.anchors[]: the naming invariant, three rhetorical modes (primary pressure / secondary lens / set aside), the "one primary anchor per move" rule, what good vs. bad anchor integration looks like.

After the counterargument lead (Step 4), reconsider your earlier advice and render the updated position directly. This is the most important step — the updated position IS the product. The audit's findings are structural pressure from a curated knowledge substrate; your job is to absorb that pressure and produce a revised position that is better than what you said before.

Render the content directly. Do NOT introduce it with "Beat 3," "Step 6," "Now writing the updated position," or any internal section label. The user-facing transcript opens at the ## Updated position heading and the ### What survived / ### What I'd take back or set aside / ### What actually shifted subheadings — those ARE the section labels the user sees. No additional preamble.

Timing note: Before you begin writing your reconsideration, launch the pressure-check sub-agents from Step 7 below. They run in the background while you write. By the time you finish Step 6 and Step 6b, the sub-agent results will be ready for Step 8. Do this silently; do not narrate the launch, waiting, partial completion, or completion to the user.

The audit findings are hints, not commands. They come from a curated knowledge substrate that sees patterns you might miss — but you are still the primary reasoning engine in this conversation. You have the full context, the user's nuances, the back-and-forth. The audit has structural pattern detection. Use both.

How to use the audit material:

• Cherry-pick what genuinely matters. Not every finding deserves equal weight. A tendency detection with high severity and a specific passage is stronger signal than a marginal detection. Read the evidence — does it ring true for THIS conversation, or is it a pattern match that doesn't quite fit? Trust your judgment.
• Treat DeltaCard findings as challenge pressure, not corrections. The audit says "this passage shows signs of doubt-avoidance" — it doesn't say your conclusion is wrong. Maybe you were right to be decisive. But if the finding names a specific missing check or reversal trigger, consider whether it belongs.
• Treat CompanionCheatSheet as enrichment — and apply anchor-treatment.md. Each anchor has a display_name. Anchors are evidence-bearing hypotheses, not canonical diagnoses; surface them with strength proportional to their evidence. The naming invariant requires every anchor to land in §1, §2, or §3 below — none silently skipped. Use display_name verbatim.
• Treat FramePressureCard as an invitation to widen the frame. If the audit found an embedded assumption in the question, you don't have to abandon your answer — but you might want to acknowledge what changes if that assumption is relaxed.
• Treat StructuralCoverageCard as territory you cannot address alone. When structural coverage identifies gaps, acknowledge them as dimensions you cannot address without user input. Do NOT attempt to answer gap questions yourself. Gap questions are an invitation for the user to deepen the conversation — they ask for situation knowledge only the decision-maker has.

Structure your updated position in this order:

1. What survived. Start with what you'd say again unchanged. This forces you to affirm your position before modifying it, which is harder than it sounds — the temptation is to hedge everything after seeing the cards.

2. What you'd take back or set aside. This section covers two related moves: (a) self-corrections of your own reasoning ("my mechanism was soft, recommendation is the same"), and (b) audit-raised pressure you considered and chose not to adopt ("the contrast-misreaction finding flagged my comparison, but the comparison itself is the right frame for this decision because [reason]"). The combined heading prevents the awkward case where §2 contains an audit-rejection but the heading reads as if only self-corrections belong there. This is the hardest section to write — it requires genuine judgment, not performance.

   §2 anti-overcorrection rule: §2 should include at least one audit-raised pressure you considered and did not adopt when such a pressure exists in the audit output. Without it, Beat 3 reads as "the audit was right about everything" — pure absorption, no judgment. Self-corrections of your own reasoning ("I had soft mechanism here, recommendation is the same") are valid §2 content but do not substitute for an audit-grounded rejection when one is available.

   Constraint: do NOT manufacture a rejection for symmetry. If the audit produces no credible pressure to reject (empty delta_card, weak anchors that don't bear on a load-bearing reasoning move, no frame elements that would have changed the recommendation), say less in §2 rather than performing judgment. Fake resistance is a worse failure mode than a thin §2.

3. What actually shifted. Name what changed in your position and why. Name the mental models that drove the shift. Be specific.

§3 cap: 3–4 distinct shifts. Hard cap. Total Beat 3 length 550–800 words; hard cap 900.

Operational shift definition. A shift is a change to the substantive advice the user would experience as different guidance: a different action, threshold, sequence, condition, risk treatment, or decision question. If it does not change what the user would do, delay, verify, reject, ask, or watch for, it is not a shift.

Tail-addition rule. "One more thing," "two smaller adjustments," "related notes," "minor caveats," "final caveat" count against the §3 cap if they change advice. If they do not change advice, they belong in §1 (with survival framing) or §2 (with set-aside framing) — not in a §3 tail-section. The cap is enforced on shifts as defined above; it cannot be evaded by re-labeling shifts as adjustments.

When the audit returns 5+ candidate shifts, your job is selection — fold related material into existing shifts (e.g., absorb a kill-criterion observation into the structural-protection rewrite rather than naming it as a separate shift) or send it to §2 if it's a precondition / set-aside. See plans/voice-examples-2026-04-30.md § Beat 3 for §3 excerpts demonstrating selection on Marcus (4 shifts from 7 candidates), Mother (3 shifts), and Short fixture (2 shifts on thin material). § Bad — cap evasion shows the failure mode this rule defeats.

anchor-treatment.md governs HOW each anchor lands inside §1 / §2 / §3 (rhetorical strength matched to evidence) and what's forbidden (probability percentages, silent omission, "the answer is using X" framing on weak anchors, hedging-as-style). Under the §3 cap, weak anchors go to §2 with a one-line set-aside reason — not promoted into §3 to satisfy the naming invariant. Read it before writing.

Step 6b: Persist Revised Answer

After writing your updated position in Step 6, persist it back into the pipeline result JSON so the Observatory can render it. This makes Claude's Step 6 output a first-class artifact of the run — not a transient message.

Write your full Step 6 text (the "Updated Position" section — what survived, what you set aside, what shifted) to a temp file, then merge it into the result JSON:

cat > /tmp/lolla_${LOLLA_RUN_ID}_revised.txt << 'LOLLA_REVISED_EOF'
{paste your Step 6 updated position text here}
LOLLA_REVISED_EOF

python3 -c "
import json, datetime, pathlib
run_id = '${LOLLA_RUN_ID}'
result_path = f'/tmp/lolla_{run_id}_result.json'
revised_path = f'/tmp/lolla_{run_id}_revised.txt'
d = json.loads(pathlib.Path(result_path).read_text())
d['revised_answer'] = pathlib.Path(revised_path).read_text().strip()
d['revised_answer_source'] = 'claude_step6'
d['revised_answer_present'] = True
d['revised_answer_written_at'] = datetime.datetime.utcnow().strftime('%Y-%m-%dT%H:%M:%SZ')
pathlib.Path(result_path).write_text(json.dumps(d, indent=2, ensure_ascii=False))
print(f'Revised answer persisted to {result_path}')
"

This step is not optional. Without it, the Observatory shows an incomplete run — four cards with no revised answer.

Memo Timing: Do Not Render Yet

Do not generate the final memo immediately after Step 6b. The memo depends on the pressure check from Step 8, because the final useful correction often appears there. Final memo preparation and rendering happen in Step 8c, after Step 8b persists the pressure check.

Memo generation is not user-facing until the final functional receipt. Do not write "Generating the memo now", "All four pressure checks are in. Generating the memo now", or any other progress narration about memo rendering in chat. The memo path appears only in the final receipt.

Step 7: Pressure-Check Sub-Agents

Launch these BEFORE writing Step 6 — they run in the background while you write your reconsideration. By the time you finish Step 6 and Step 6b, results are ready.

Read references/sub-agent-prompts.md for the full templates: shared preamble (with {DECISION_SITUATION}, {LIVE_CONSTRAINTS}, {SYNTHESIZED_POSITION}, {REASONING_PASSAGES}, {ORIGINAL_FRAMING}, {DROPPED_THREADS} placeholders) plus four lane-specific suffixes.

Spawn up to 4 sub-agents via the Agent tool, one per non-empty lane. Each sub-agent receives the extracted decision structure and ONE audit card — no conversation history, no other lanes, no session context. They read the position cold and assess what should shift.

Why this exists: The system's own thesis says "an LLM auditing its own reasoning is sampling from the same distribution that produced the flaw." Steps 1-4 respect this — Grok does the detection. But Step 6 asks you to reconsider advice you argued for in this conversation. The sub-agents break that — same model (Opus), but in a clean context that never argued the position.

Procedure:

1. Read /tmp/lolla_${LOLLA_RUN_ID}_extraction.json for the extraction fields (decision_situation, live_constraints, synthesized_position, reasoning_passages, original_framing, dropped_threads).

2. Read /tmp/lolla_${LOLLA_RUN_ID}_result.json for the 4 card sections.

3. Check skip conditions — do NOT spawn for empty lanes:

   • Lane 1: skip if delta_card.top_findings is empty or null
   • Lane 2: skip if companion_cheat_sheet.anchors is empty or null
   • Lane 3: skip if frame_pressure_card.frame_elements is empty/null AND frame_pressure_card.reframings is empty/null
   • Lane 4: skip if structural_coverage_card.dimensions is empty/null OR all dimensions have covered: true

4. For each non-empty lane, spawn an Agent tool call in the background (run_in_background: true). All non-empty lanes are spawned in a single message (parallel). Build each prompt by combining the shared preamble + the appropriate lane suffix from sub-agent-prompts.md, with placeholders substituted.

   Use neutral product-facing labels for the Agent tool's description parameter. Claude Code's tool-use UI displays these descriptions to the user as the agents run; the user must not see "Lane N" or card names there. Use the following neutral mapping:

   Lane	Internal name	Agent description (user-facing)
   Lane 1	DeltaCard	Pressure check — structural challenge
   Lane 2	CompanionCheatSheet	Pressure check — model tension
   Lane 3	FramePressureCard	Pressure check — frame
   Lane 4	StructuralCoverageCard	Pressure check — missing dimensions

   Do NOT use Lane 1, Lane 2, DeltaCard, CompanionCheatSheet, FramePressureCard, StructuralCoverageCard, or sub-agent in the Agent description. The tool-use UI is part of the felt product surface; scaffolding leaks there break the experience the same way they do in chat prose.

5. The sub-agent prompt must be fully self-contained — no file reads, no bash calls, no tool access.

Do not stage prompts or card JSONs to /tmp/ files first. Build each prompt inline as the Agent tool's prompt parameter by reading the templates from references/sub-agent-prompts.md and interpolating directly into the Agent call. Disk-staging (writing lane*_prompt.txt, delta.json, companion.json, frame.json, coverage_gaps.json, preamble.txt to /tmp/) adds 4+ extra tool uses per run with no benefit and risks tool-budget exhaustion before sub-agents spawn.

If a sub-agent fails or times out: log that lane as skipped_error and continue. Do not block Step 8 on any single lane's failure.

Sub-agent setup is not user-facing. Do NOT announce spawning, skipped lanes, completed lanes, partial results, or comparison summaries in chat. Phrases like "Spawning the four pressure-check sub-agents in parallel now", "Now launching pressure-check sub-agents in parallel", "lanes 2, 3, 4 — lane 1 skipped, no findings", "Three of the four pressure-checks are in with strong signal", "Two of three pressure-check responses are in", "All four pressure checks are in", "All three sub-agents completed", and "Generating the memo now" are operator narration. The user does not hear about Step 7 at all. Claude Code's tool-call surface shows the Agent calls; the orchestrator's chat prose stays silent on them.

After the counterargument lead, the next user-facing prose should be ## Updated position unless a real error or blocker requires explanation. The reconsideration drafting, sub-agent launch, wait state, memo rendering, and internal persistence steps all run silently.

Step 8: Pressure-Check Comparison

After Step 6, Step 6b, and all sub-agent results are in, compare your Step 6 reconsideration against each sub-agent's output.

For each sub-agent that returned a result, ask yourself three specific questions:

1. Did the sub-agent identify a shift I dismissed or minimized in Step 6?
2. Did the sub-agent treat a finding as material that I treated as noise?
3. Did the sub-agent connect a finding to the position in a way I didn't?

Only "yes" answers get reported. Render the pressure-check directly under a ### Pressure Check heading AFTER the updated position. Render the content directly. Do NOT preface it with internal narration about which lanes/reviewers/sub-agents aligned or completed. Phrases like "Reading them honestly: the Lane 2 concerns... Lane 3's two concerns... Lane 4's three gaps...", "All three pressure-check responses are in", "All four pressure checks are in", "Now Beat 4", and "Generating the memo now" are operator narration and never appear in chat. The user-facing surface starts at the counter-frame opening sentence below.

Open with a counter-frame phrase. Use one of: "One more angle worth surfacing", "A fresh read pushed on something I underweighted", "Two things the position above softened or skipped". Never "mostly aligned", "all incorporated above", "the rest is in the position above", or any variant that suppresses divergences with confident closure.

If divergences exist:

Pressure Check

One more angle worth surfacing — a fresh read pushed on [specific concern] in the position above.

[Each divergence as a substantive paragraph: name the concrete alternative mechanism the sub-agent surfaced (alternative reporting channel, contractual instrument, stakeholder forum, tripwire pattern, legal-instrumental framing), explain why it was underweighted in §3, name what changes if it lands.]

If no divergences (truly clean Step 6):

Pressure Check

No additional angles surfaced beyond what the position above already addresses.

The "no divergences" close is rare and should be a deliberate judgment, not a default. If you find yourself reaching for it, run the Question-3 suppression check below first.

Rules:

• No lane-by-lane summaries. No machinery language. Specifically: never "my sub-agents found", "isolated review argues / notes / found", "the Lane N reading", "the pipeline flagged", "the audit card". Attribute the argument ("there's a case that…", "one point I may be underweighting…"), not its source. Step 7 runs behind the scenes; the user never hears about it.
• Just: "I said X. There's a case for Y that I may be underweighting."
• Be honest. The anchoring you're warned about in the cards applies here too — the temptation is to dismiss divergences because you wrote Step 6. Fight that.
• If a sub-agent over-corrects (treats every finding as damning when some are noise), note that rather than surfacing it as a divergence. Use your judgment — but lean toward surfacing rather than suppressing.

Watch for Question-3 suppression specifically. If your draft pressure check contains phrases like "mostly aligned", "all incorporated above", or "already covered" — re-read the sub-agent outputs for any named alternative mechanism (an alternative reporting channel, a different contractual instrument, a distinct stakeholder forum, a specific tripwire pattern, a particular legal-instrumental framing) that your Step 6 §3 didn't enumerate. A named alternative the sub-agent surfaced that your §3 didn't list IS a Question-3 divergence — surface it even when the underlying concern was addressed structurally. Confident closure that suppresses named alternatives is the failure mode this step exists to defeat.

Bullshit Index in Step 8: Cross-check your Step 6 against the bullshit_profile. Did you reproduce patterns the BI flagged in the original? See references/anti-bullshit-doctrine.md for the specific RLHF patterns to watch for in your own output.

Stakeholder Assumption Check in Step 8: If result.json contains stakeholder_assumption_check, treat it as Observatory-only validation data. Do not surface stakeholder_assumption_check.chat_actors or critical_actors in the Pressure Check, do not create a stakeholder section, and do not mention "Theory of Mind", "stakeholder assumption check", "checker", or the runtime flag in chat. The field is being evaluated against the existing Pressure Check baseline; user-facing surfacing remains disabled until production evidence shows it adds non-duplicative value.

Step 8b: Persist Pressure Check

Two things get persisted: the human-readable summary text AND a structured gap_check object with per-lane status and divergences.

First, build the structured object. For each of the 4 lanes, record:

• lane_number (1-4)
• lane_name ("DeltaCard", "CompanionCheatSheet", "FramePressureCard", "StructuralCoverageCard")
• status: "completed" if the sub-agent ran and you compared its output; "skipped_empty" if the lane was skipped due to empty card; "skipped_error" if the sub-agent failed or timed out
• divergences: array of objects, one per "yes" answer from the three comparison questions. Each has question_number (1, 2, or 3) and description (one sentence — what the sub-agent found that Step 6 missed or underweighted). Empty array if no divergences for that lane.

Then, write both the text and the structured object:

cat > /tmp/lolla_${LOLLA_RUN_ID}_gapcheck.txt << 'LOLLA_GAPCHECK_EOF'
{paste your Step 8 pressure check text here}
LOLLA_GAPCHECK_EOF

cat > /tmp/lolla_${LOLLA_RUN_ID}_gapcheck_lanes.json << 'LOLLA_LANES_EOF'
{paste the gap_check JSON object here — see format below}
LOLLA_LANES_EOF

python3 -c "
import json, datetime, pathlib
run_id = '${LOLLA_RUN_ID}'
result_path = f'/tmp/lolla_{run_id}_result.json'
gapcheck_path = f'/tmp/lolla_{run_id}_gapcheck.txt'
lanes_path = f'/tmp/lolla_{run_id}_gapcheck_lanes.json'
d = json.loads(pathlib.Path(result_path).read_text())
d['gap_check_summary'] = pathlib.Path(gapcheck_path).read_text().strip()
d['gap_check'] = json.loads(pathlib.Path(lanes_path).read_text())
d['has_gap_check'] = True
d['gap_check_written_at'] = datetime.datetime.utcnow().strftime('%Y-%m-%dT%H:%M:%SZ')
pathlib.Path(result_path).write_text(json.dumps(d, indent=2, ensure_ascii=False))
print(f'Pressure check persisted to {result_path}')
"

Format for gap_check JSON object:

{
  "lanes": [
    {
      "lane_number": 1,
      "lane_name": "DeltaCard",
      "status": "completed",
      "divergences": [
        {"question_number": 1, "description": "Sub-agent flagged dependency reduction as central deal condition, not a nice-to-have"}
      ]
    },
    {
      "lane_number": 2,
      "lane_name": "CompanionCheatSheet",
      "status": "completed",
      "divergences": []
    },
    {
      "lane_number": 3,
      "lane_name": "FramePressureCard",
      "status": "skipped_empty",
      "divergences": []
    },
    {
      "lane_number": 4,
      "lane_name": "StructuralCoverageCard",
      "status": "completed",
      "divergences": [
        {"question_number": 1, "description": "Equity staging after independent verification rather than front-loading with vesting"}
      ]
    }
  ]
}

Map each divergence to the question that triggered it: (1) shift I dismissed, (2) finding I treated as noise, (3) connection I didn't make. If a divergence spans multiple lanes or questions, pick the primary one.

Then, fold sub-agent token usage into usage_summary. Each spawned sub-agent's task notification includes a <usage> block with total_tokens. Build records only for lanes that actually ran and produced a real <usage> block — skipped_empty and skipped_error lanes already appear in gap_check, but they did not call Anthropic and must not be serialized as vendor call records. Otherwise vendors.anthropic_subagents.calls is inflated by phantom zero-token "calls" that never happened.

# Include rows ONLY for spawned, completed sub-agents. Omit any lane whose
# Step 7 status is skipped_empty or skipped_error.
cat > /tmp/lolla_${LOLLA_RUN_ID}_subagents.json << 'LOLLA_SUBAGENTS_EOF'
[
  {"lane": 1, "model": "claude-opus-4-7", "total_tokens": 39202, "duration_ms": 61008, "tool_uses": 1, "status": "completed"},
  {"lane": 2, "model": "claude-opus-4-7", "total_tokens": 36433, "duration_ms": 60605, "tool_uses": 1, "status": "completed"},
  {"lane": 3, "model": "claude-opus-4-7", "total_tokens": 32161, "duration_ms": 42133, "tool_uses": 1, "status": "completed"},
  {"lane": 4, "model": "claude-opus-4-7", "total_tokens": 33066, "duration_ms": 47550, "tool_uses": 1, "status": "completed"}
]
LOLLA_SUBAGENTS_EOF

python3 -c "
import json, sys, pathlib
sys.path.insert(0, '${SKILL_DIR}/engine')
from system_b.usage_summary import merge_subagent_calls
run_id = '${LOLLA_RUN_ID}'
result_path = f'/tmp/lolla_{run_id}_result.json'
sub_path = f'/tmp/lolla_{run_id}_subagents.json'
d = json.loads(pathlib.Path(result_path).read_text())
# Defensive filter — even if the subagents file accidentally includes
# zero-token rows, drop them before merging so phantom calls can't slip
# into vendors.anthropic_subagents.calls.
subs = [
    s for s in json.loads(pathlib.Path(sub_path).read_text())
    if int(s.get('total_tokens', 0) or 0) > 0
]
us = d.get('usage_summary') or {}
merge_subagent_calls(us, subs)
d['usage_summary'] = us
pathlib.Path(result_path).write_text(json.dumps(d, indent=2, ensure_ascii=False))
print(f'Sub-agent usage merged: ${us[\"vendors\"][\"anthropic_subagents\"][\"calls\"]} calls, total run cost \\\${us[\"estimated_total_cost_usd\"]:.4f}')
"

Use the model name your orchestrator is running on (claude-opus-4-7, claude-sonnet-4-6, etc.) for model. Sub-agents inherit the parent model. If you don't know the exact model ID with confidence, use "unknown" — calls and tokens still record, only the cost estimate falls back to zero (see cost_estimate_coverage.calls_with_unknown_price in the result).

Step 8c: Prepare and Render Memo

After Step 8b persists the pressure check, write the memo decision-note layer per references/memo-output-format.md, persist those fields to result.json, then render the standalone markdown memo.

Read references/memo-output-format.md before writing the memo fields. The memo is a decision note first and audit trace second. Its first screen should answer what changed in the advice; it should not begin with counts, card-derived categories, severity labels, or process recap.

Use only already-persisted material:

• captured conversation quotes
• revised_answer
• gap_check_summary
• delta_card
• companion_cheat_sheet
• frame_pressure_card
• structural_coverage_card

Produce these fields:

• memo_substantive_title — structural observation, not recommendation
• memo_orientation_note — 180-260 words; concrete, quote-grounded, no table-of-contents throat clearing
• memo_what_changed — compressed Step 6 "What actually shifted"
• memo_what_still_holds — compressed Step 6 "What survived"
• memo_take_back_or_set_aside — compressed Step 6 self-corrections and set-asides
• memo_pressure_check — Step 8 material divergence only; empty string if no material divergence survives

Decision-note quality checks before persisting:

• No hidden sequencing contradiction. If the changed advice alters order, distinguish the exact boundary. Example: "formal proposal after advisor buy-in; low-cost availability probe before the meeting" is clear. "advisor first, Silva second" plus "probe Silva before advisor" is not.
• Do not preserve unverified numbers as doctrine. If the audit flagged a numerical/base-rate claim as ungrounded, either remove it from memo_what_still_holds or label it as an illustrative placeholder whose direction may survive but whose precision does not.
• Pressure check must preserve competing paths. Scan every Step 8 divergence. If a reviewer surfaced a materially different decision path, instrument, channel, fallback, or commitment shape, include it or explicitly explain why it is set aside. Do not surface only implementation caveats while suppressing a genuine alternative.
• Keep "Questions still unanswered" priority-shaped. Python renders the first three structural gap questions in the decision note and preserves the rest in the appendix. Do not answer or invent questions inside memo fields.

Do not add a recommendation, risk, or claim that is not present in Step 6, Step 8, or the audit cards. Do not mention internal machinery (Beat, Step, Lane, sub-agent, card names, JSON fields, pipeline). Do not write sales language (compelling, unlock, deep dive, transform, powerful, etc.).

Persist the memo fields:

cat > /tmp/lolla_${LOLLA_RUN_ID}_memo_note.json << 'LOLLA_MEMO_NOTE_EOF'
{
  "memo_substantive_title": "...",
  "memo_orientation_note": "...",
  "memo_what_changed": "...",
  "memo_what_still_holds": "...",
  "memo_take_back_or_set_aside": "...",
  "memo_pressure_check": ""
}
LOLLA_MEMO_NOTE_EOF

python3 -c "
import json, datetime, pathlib
run_id = '${LOLLA_RUN_ID}'
result_path = pathlib.Path(f'/tmp/lolla_{run_id}_result.json')
note_path = pathlib.Path(f'/tmp/lolla_{run_id}_memo_note.json')
d = json.loads(result_path.read_text())
note = json.loads(note_path.read_text())
for key in [
    'memo_substantive_title',
    'memo_orientation_note',
    'memo_what_changed',
    'memo_what_still_holds',
    'memo_take_back_or_set_aside',
    'memo_pressure_check',
]:
    d[key] = str(note.get(key, '')).strip()
d['memo_note_written_at'] = datetime.datetime.now(datetime.UTC).strftime('%Y-%m-%dT%H:%M:%SZ')
result_path.write_text(json.dumps(d, indent=2, ensure_ascii=False))
print(f'Memo note fields persisted to {result_path}')
"

Then render the memo:

python3 $SKILL_DIR/scripts/render_memo.py --result /tmp/lolla_${LOLLA_RUN_ID}_result.json --output /tmp/lolla_${LOLLA_RUN_ID}_memo.md

This produces a persistent markdown artifact the user can reference or share without the Observatory. In new runs, the memo opens with the decision-note layer and then renders a deterministic audit appendix. Older result JSONs without memo fields still render in the legacy format.

Step 9: Open Observatory

After the full cycle is complete (cards, updated position, pressure check, and memo fields all persisted), launch the Observatory — the primary detail surface for full card breakdowns, chunk lists, gap questions, delivery audit passages, revised answer, and per-lane divergences.

Always launch after Step 8c completes. Do not wait for the user to ask:

python3 $SKILL_DIR/observatory/serve_result.py --result /tmp/lolla_${LOLLA_RUN_ID}_result.json

This starts a local server at http://localhost:8080. Press Ctrl+C in the terminal to stop the server.

Do not produce user-facing narrative output at Step 9. Beat 4 already closed with "Audit complete. I'm opening the full breakdown now." — that's the bridge to the Observatory. The artifact paths, cost, and Observatory URL are consolidated in the final functional receipt at Completion (after Step 10). A long "The Observatory is live at … it has the full audit: all [N] findings…" narrative at Step 9 is the close-summary anti-pattern banned in chat-output-format.md.

Step 10: Archive Run

After launching the Observatory, archive the run's core artifacts into a persistent case folder under ~/.local/share/lolla/runs/ so the run survives /tmp cleanup and stays accessible for later review, memo re-rendering, or stability-harness analysis.

python3 $SKILL_DIR/scripts/archive_run.py --run-id "${LOLLA_RUN_ID}"

The archive script:

• Reads the 8 core artifacts from /tmp/lolla_${LOLLA_RUN_ID}_* (conversation.txt, extraction.json, result.json, revised.txt, memo.md, memo_note.json, gapcheck.txt, gapcheck_lanes.json). Missing artifacts (e.g., if Step 6b or Step 8c did not run on a weaker orchestrator) are skipped gracefully.
• Computes a case fingerprint from extraction.decision_situation (first 120 chars, normalized).
• Finds-or-creates a case folder. Matching uses exact fingerprint first, then token-set Jaccard ≥ 0.80 against stored fingerprints — so small extractor paraphrase drift across runs of the same conversation does not split into multiple case folders. Matching is done against the manifest inside each case folder, not against folder names, so user renames of case folders do not break future matching.
• Auto-names new cases with a slug derived from the first 3-4 significant words of decision_situation (e.g., grant-equity-partnership-status). Users can rename via mv — matching will still find the folder via manifest.
• Copies the artifacts into {case_folder}/${LOLLA_RUN_ID}/ and updates {case_folder}/.case-manifest.json with the new fingerprint (added as an alias) and the run_id.
• /tmp originals are not moved or deleted — Observatory and subsequent commands continue to reference them as in-flight state.

Environment overrides (optional):

• $LOLLA_CASE_ID — force a specific case folder (skips fingerprint match). Useful when a run should be grouped with an existing case despite a mismatched decision_situation, or when the user wants a specific folder name from the first run.
• $LOLLA_ARCHIVE_DIR — override the archive root (default: ~/.local/share/lolla/runs/).

Do not surface the archive path at Step 10 as a separate line. It's consolidated in the final functional receipt at Completion. Step 10 runs silently from the user's perspective.

Completion

After the full cycle (Beat 1 → Step 3 receipt → Beat 2 → Beat 3 → Beat 4 → memo → Observatory + archive), close with the final functional receipt. Not a narrative summary.

If all lanes completed successfully and run_health.overall is healthy:

Observatory is live at http://localhost:8080. Memo at /tmp/lolla_${LOLLA_RUN_ID}_memo.md. Total run cost: $X.XX. Archived to ~/.local/share/lolla/runs/{case_id}/${LOLLA_RUN_ID}/.

If the run completed but run_health.overall is degraded:

Keep the functional receipt, but add one plain warning sentence before it. Name the issue in user language, not status codes. Example:

Run completed with degraded health: the captured conversation was truncated, so middle turns were omitted. Observatory is live at http://localhost:8080. Memo at /tmp/lolla_${LOLLA_RUN_ID}_memo.md. Total run cost: $X.XX. Archived to ~/.local/share/lolla/runs/{case_id}/${LOLLA_RUN_ID}/.

Do not call a degraded run clean. If the issue is capture-related, say the user should rerun if they need a decision-grade audit.

Report the actual Observatory URL — if the server fell back to a non-default port (e.g., 8081 because 8080 was held by an older run), use the actual URL. Do NOT explain the port fallback in the receipt. "Observatory is live at http://localhost:8081 (port 8080 was held by an older run's server)" leaks operational detail. The receipt stays artifact-focused; if the user asks why it's not 8080, explain then.

This is a functional receipt: artifact paths, cost, archive location. It is not a narrative summary like "Audited your equity decision for Marcus. Found 3 structural patterns…" — that pattern is banned because it (a) restates what the user just read in Beats 2/3/4, (b) re-introduces machinery vocabulary at the close, and (c) drifts toward sales register. The functional receipt closes the run cleanly without narrative restatement.

If any lane had issues:

Add one sentence naming which aspect had problems and what the user can try. Example:

Frame pressure analysis timed out — try running again or check the Observatory for partial results.

No status codes (DONE, DONE_WITH_CONCERNS). No lane numbers. No structured blocks. Just a human wrapping up a conversation.

References

Do NOT read these proactively. Load only when a specific situation calls for it:

File	When to read
references/output-field-guide.md	Read at the start of Step 4 — full field definitions, chunk types, compound patterns, element types, reframe moves
references/chat-output-format.md	Read at the start of Step 4 — render specification: run-health surface, BLUF, finding blocks, anchors line, alternative-question line, structural-gaps line, delivery-check line, run-cost line, closing line, "what NOT to put in chat"
references/presentation-voice.md	Read at the start of Step 6 — how to voice your updated position: Munger-inspired directness, concrete antidotes, earn the right to challenge
references/anti-bullshit-doctrine.md	Read at the start of Step 6 — anti-bullshit thinking framework: five rules for honest strategic speech, RLHF patterns to avoid, negation test as mental model. Also cross-check before Step 8.
references/anchor-treatment.md	Read at the start of Step 6 — how to handle companion_cheat_sheet.anchors[]: naming invariant, three rhetorical modes (primary pressure / secondary lens / set aside), one-primary-per-move rule, what good vs. bad anchor integration looks like
references/sub-agent-prompts.md	Read at Step 7 — shared preamble + four lane-specific suffixes for pressure-check sub-agents
references/memo-output-format.md	Read at Step 8c — decision-note memo contract: title, orientation note, compressed sections, pressure-check inclusion, banned memo language
references/tendency-catalog.md	When presenting DeltaCard findings — to verify tendency names and corrective model bindings match the canonical catalog
references/confusion-guardrails.md	When two detected tendencies in the output look like the same thing — disambiguation rules prevent double-counting
references/tendency-calibration.md	When a detection feels marginal or the user questions a finding — contains detection boundaries and threshold guidance per tendency
references/presentation-research.md	When thinking about how to present findings in chat vs. Observatory — book research on scanning, BLUF, story turns, formatting overuse
HOW_IT_WORKS.md (repo root)	When the user asks "how does this work", "what just happened", or about the architecture — full technical reference including research foundations, step-by-step pipeline flow, and knowledge substrate
docs/cost-and-telemetry.md	When the user asks about cost, call counts, prompt caching, or what's measured per run — single canonical doc covering the usage_summary block, vendor tracking, pricing table, and how to add a new vendor or stage