From e4cd69640bd02420dd8bfd3ea556aa19fe5bf5f8 Mon Sep 17 00:00:00 2001
From: trs-80 <109326+trs-80@users.noreply.github.com>
Date: Sun, 9 Aug 2026 11:59:55 -0400
Subject: [PATCH 01/17] fix(ai): stop AI diagnosis silently falling back on
 truncated responses
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

aiDiagnose ran at max_tokens=1024 with a 10s timeout. No current model can
return a complete structured diagnosis in that budget: nine live sonnet-5
runs against the real pg-replication prompt came back at 2259-3742 output
tokens and 28-40s. Every response arrived truncated with
stop_reason=max_tokens, JSON.parse threw "Unterminated string", aiDiagnose
returned null, and the caller degraded to its rule-based heuristics.

The failure was invisible: it looked like "AI is unavailable" rather than
"the budget is too small". It affected the pg-replication agent, the kafka
agent, and `bundle ingest` — regardless of whether an API key was set.

- ai-diagnosis.ts: 60s / 6144 tokens (above the measured 3742 ceiling, since
  4096 leaves ~9% headroom and one wordier finding list would truncate again)
- ai-client.ts fallbacks: 60s / 4096
- ai-explainer.ts: 4096 / 30s, measured 1407-1484 tokens at 15.2-16.4s
- root-cause-synthesis.ts: 4096 / 30s, measured 749-1522 tokens at 8.8-17.7s
  Both are foreground paths with an operator waiting, so they take 30s rather
  than 60s: a fast fallback beats a long hang. Both were falling back before.
- root-cause-synthesis.ts also parsed with a bare .trim() and no
  stripCodeFence, so 2 of 3 live calls threw on a ```json fence — a failure
  mode independent of the token budget.
- parseStandardDiagnosisResponse now repairs raw control characters inside
  JSON string literals and retries once, after a live response lost its
  diagnosis to "Bad control character in string literal at position 1741".
- Corrected 8 stale "10s / 1024" claims, including a spec reference to
  claude-sonnet-4-20250514, retired 2026-06-15.

All 7 callClaude call sites audited; each passes both values explicitly, so
no interactive path regressed. 18 hermetic regression tests added, 8 of them
verified to fail against the old constants. No live API calls in tests.

Still at 1024: ai-diagnosis-universal.ts:126 and ask.ts:218. Neither parses
its response, so truncation there is a visibly cut-off answer rather than a
silent fallback.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .../operator-health-and-ai-services.md        |  23 +-
 src/__tests__/ai-client.test.ts               |   2 +-
 .../ai-diagnosis-token-budget.test.ts         | 250 +++++++++++
 src/__tests__/ai-response-budgets.test.ts     | 387 ++++++++++++++++++
 src/agent/kafka/ai-diagnosis.ts               |   2 +-
 src/agent/pg-replication/ai-diagnosis.ts      |   2 +-
 src/framework/ai-client.ts                    |  24 +-
 src/framework/ai-diagnosis.ts                 | 103 ++++-
 src/framework/ai-explainer.ts                 |  35 +-
 src/framework/evidence-bundle-respond.ts      |  12 +-
 src/framework/root-cause-synthesis.ts         |  38 +-
 11 files changed, 846 insertions(+), 32 deletions(-)
 create mode 100644 src/__tests__/ai-diagnosis-token-budget.test.ts
 create mode 100644 src/__tests__/ai-response-budgets.test.ts

diff --git a/specs/architecture/operator-health-and-ai-services.md b/specs/architecture/operator-health-and-ai-services.md
index a913699..24bf663 100644
--- a/specs/architecture/operator-health-and-ai-services.md
+++ b/specs/architecture/operator-health-and-ai-services.md
@@ -140,7 +140,7 @@ AI services in CrisisMode are:
 
 - **Advisory only.** AI outputs are never executable. They inform diagnosis and explain plans but do not modify system state.
 - **Optional.** All AI services degrade gracefully when no API key is configured. Rule-based fallbacks produce valid, if less insightful, results.
-- **Time-bounded.** Every AI call has a hard timeout (default: 10 seconds) via `AbortController`. During a crisis, blocking on an AI API call is unacceptable.
+- **Time-bounded.** Every AI call has a hard timeout via `AbortController`, set per call site rather than globally: 60 seconds for non-interactive paths that must return a complete structured response (the diagnosis toolkit, evidence-bundle responses), and 8-30 seconds for paths with an operator waiting at a prompt (plan explanation, root-cause synthesis, symptom routing, scan summaries, the `ask` REPL). During a crisis, blocking on an AI API call is unacceptable — but a bound below the model's realistic response time is not a safety property, it just guarantees the fallback.
 - **Input-sanitized.** All inputs to AI models are sanitized: control characters stripped, fields length-limited, to mitigate prompt injection from system telemetry.
 - **Framework-level.** AI services are provided by the framework, not individual agents. This ensures consistent safety properties across all agents.
 
@@ -151,11 +151,22 @@ The AI diagnosis toolkit (`src/framework/ai-diagnosis.ts`) provides a reusable A
 ```ts
 interface AiDiagnosisConfig {
   apiKey?: string;       // defaults to ANTHROPIC_API_KEY env var
-  model?: string;        // defaults to claude-sonnet-4-20250514
-  timeoutMs?: number;    // defaults to 10000
-  maxTokens?: number;    // defaults to 1024
+  model?: string;        // defaults to defaultAiModel() — CRISISMODE_AI_MODEL, else claude-sonnet-5
+  timeoutMs?: number;    // defaults to 60000
+  maxTokens?: number;    // defaults to 6144
 }
+```
+
+The token ceiling is not arbitrary. A complete diagnosis for the standard schema
+(status, scenario, confidence, a root-cause paragraph, findings with evidence,
+ordered recommendations) measured 2259-3742 output tokens across nine live
+claude-sonnet-5 responses to the pg-replication prompt. A ceiling below that
+does not shorten the answer — it truncates the JSON mid-string, `JSON.parse`
+throws, `aiDiagnose()` returns `null`, and the agent silently degrades to its
+rule-based fallback. Any new AI call site that parses structured output MUST
+size its budget against a measured response, not a guess.
 
+```ts
 interface AiDiagnosisRequest {
   systemPrompt: string;  // domain-specific analysis instructions
   userMessage: string;   // structured system state
@@ -210,14 +221,14 @@ The explainer:
 - Uses AI when `ANTHROPIC_API_KEY` is set.
 - Falls back to a structural summary (step type + risk level + blast radius) when no key is available.
 - Never modifies the plan. Explanations are purely informational.
-- Uses the same timeout and sanitization as the diagnosis toolkit.
+- Uses the same sanitization as the diagnosis toolkit, but a tighter 30-second timeout: it runs in the foreground with an operator waiting on the plan, where the structural summary is a better outcome than a long stall. Its budget is 4096 tokens, sized from a measured 1407-1450 output tokens for the 10-step reference plan (~143 tokens per step).
 
 ### 3.5 Safety Model
 
 | Property | Guarantee |
 |---|---|
 | Non-mutating | AI outputs are never fed back as executable commands. |
-| Timeout-bounded | 10-second default. `AbortController`-enforced. |
+| Timeout-bounded | Per-call-site, `AbortController`-enforced: 60s where a complete structured response is required, 8-30s on interactive paths. Never below the model's measured response time for that prompt. |
 | Graceful fallback | All callers have rule-based fallbacks. No AI dependency in the critical path. |
 | Input sanitization | Control characters stripped. Length limits enforced. |
 | Lazy SDK loading | The Anthropic SDK is dynamically imported. It is not required at startup. |
diff --git a/src/__tests__/ai-client.test.ts b/src/__tests__/ai-client.test.ts
index 79370e4..887f724 100644
--- a/src/__tests__/ai-client.test.ts
+++ b/src/__tests__/ai-client.test.ts
@@ -66,7 +66,7 @@ describe('callClaude', () => {
     const [params, options] = createMock.mock.calls[0]!;
     expect(params.messages).toEqual([{ role: 'user', content: 'question' }]);
     expect(params.system).toBe('sys');
-    expect(params.max_tokens).toBe(1024);
+    expect(params.max_tokens).toBe(4096);
     expect(typeof params.model).toBe('string');
     expect(options.signal).toBeInstanceOf(AbortSignal);
   });
diff --git a/src/__tests__/ai-diagnosis-token-budget.test.ts b/src/__tests__/ai-diagnosis-token-budget.test.ts
new file mode 100644
index 0000000..b30ce4f
--- /dev/null
+++ b/src/__tests__/ai-diagnosis-token-budget.test.ts
@@ -0,0 +1,250 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 CrisisMode Contributors
+
+/**
+ * Regression: the AI diagnosis response budget must fit a whole diagnosis.
+ *
+ * The toolkit used to default to max_tokens=1024 and a 10s timeout. No current
+ * model can answer the standard diagnosis schema inside 1024 tokens, so the
+ * response came back with stop_reason=max_tokens, `JSON.parse` threw
+ * "Unterminated string in JSON", `aiDiagnose` returned null, and every agent
+ * fell through to its rule-based path. Nothing surfaced that as a budget
+ * problem — it was indistinguishable from "no API key / AI unavailable", and
+ * it made the AI diagnosis path dead for every model, not just slow ones.
+ *
+ * These tests are hermetic: FULL_DIAGNOSIS_RESPONSE is a verbatim capture of a
+ * live claude-sonnet-5 answer to the real pg-replication prompt, so the sizes
+ * asserted here are measured facts rather than estimates. No test in this file
+ * touches the network.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import type * as AnthropicSdk from '@anthropic-ai/sdk';
+import { aiDiagnose, parseStandardDiagnosisResponse } from '../framework/ai-diagnosis.js';
+
+/**
+ * Verbatim claude-sonnet-5 response to the production pg-replication prompt
+ * (captured 2026-08-09). The API reported usage.output_tokens = 2259 for this
+ * body with stop_reason=end_turn — 2.2x the old 1024-token ceiling, which is
+ * why the old default could never return a parseable diagnosis.
+ */
+const FULL_DIAGNOSIS_RESPONSE = `{
+  "status": "identified",
+  "scenario": "replication_lag_cascade",
+  "confidence": 0.78,
+  "root_cause": "The primary is generating WAL faster than the replica fleet can consume it. All three replicas share an identical sent_lsn (0/5000000), meaning the primary has shipped the same volume of WAL to each, yet every replica shows a widening gap between write/flush/replay LSNs — a classic sign of a primary-side WAL generation spike or network throughput ceiling outpacing replica apply capacity. The severity gradient (45s -> 78s -> 342s) indicates the cascade is compounding on the slower replica (10.0.1.52), which is falling further behind not because replay is paused (confirmed false) but because it cannot keep up with apply throughput — likely constrained by disk I/O or CPU on that node, while the healthier replicas absorb the same WAL pressure with proportionally less lag. This is not slot exhaustion (all slots show 'reserved', not 'lost') and not connection pool exhaustion (pool is at 4/25 with no idle-in-transaction sessions).",
+  "findings": [
+    {
+      "source": "pg_stat_replication",
+      "observation": "All three replicas are behind the same sent_lsn, indicating a shared upstream cause rather than an isolated replica fault",
+      "severity": "warning",
+      "evidence": "sent_lsn is 0/5000000 for all three streaming replicas, while replay_lsn ranges from 0/4E00000 down to 0/2800000"
+    },
+    {
+      "source": "pg_stat_replication",
+      "observation": "Replica 10.0.1.52 shows a severe apply gap and the highest self-reported lag, consistent with a replica-side bottleneck compounding the primary-side pressure",
+      "severity": "critical",
+      "evidence": "10.0.1.52: write_lsn 0/3000000, flush_lsn 0/2F00000, replay_lsn 0/2800000 vs sent_lsn 0/5000000 (~0x380000 bytes of unreplayed WAL); lag_seconds 342"
+    },
+    {
+      "source": "Replica self-reported state",
+      "observation": "Replica confirms it is in recovery and lagging, and explicitly reports replay is NOT paused, ruling out deliberate/I-O-triggered replay suspension as the cause",
+      "severity": "info",
+      "evidence": "in_recovery=true, self-reported lag=342s, pg_is_wal_replay_paused()=false"
+    },
+    {
+      "source": "pg_replication_slots",
+      "observation": "All slots remain healthy with wal_status 'reserved', meaning WAL retention is not yet at risk of being recycled out from under the lagging replicas — but restart_lsn values are close to current sent_lsn, leaving little margin",
+      "severity": "warning",
+      "evidence": "restart_lsn values (0/5100000, 0/5100000, 0/5000000) all wal_status='reserved', none 'lost'"
+    },
+    {
+      "source": "Connection-pool usage (primary)",
+      "observation": "Connection pool is nowhere near exhaustion and has no idle-in-transaction sessions, ruling out connection_pool_exhaustion as a contributing scenario",
+      "severity": "info",
+      "evidence": "total=4/max=25, idleInTransactionOldest=[] (empty)"
+    },
+    {
+      "source": "pg_stat_activity",
+      "observation": "Active connection count on the primary (247) is notably higher than the connection-pool's reported total (4), suggesting read traffic may be bypassing the pool or hitting the primary directly while replicas lag",
+      "severity": "warning",
+      "evidence": "pg_stat_activity reports 247 active connections vs pool total of 4"
+    }
+  ],
+  "recommendations": [
+    "Check primary WAL generation rate (pg_stat_wal / pg_current_wal_lsn delta over time) to confirm a write/throughput spike is driving the cascade",
+    "Inspect network throughput and latency between primary and the us-east replica group for saturation, especially toward 10.0.1.52",
+    "On 10.0.1.52 specifically, check disk I/O saturation, CPU load, and checkpoint/apply throughput (pg_stat_wal_receiver, iostat) since its apply gap is disproportionately large",
+    "Monitor replication slot restart_lsn vs current WAL LSN closely — margin is currently thin; if lag continues to grow, WAL could begin to be recycled and slots could transition to 'lost'",
+    "Consider throttling or pausing non-critical write-heavy workloads on the primary until lag recovers, and verify whether read traffic is being sent to the primary directly due to replica lag (247 active connections vs minimal pool usage warrants review)",
+    "If 10.0.1.52 does not recover once WAL generation normalizes, consider rebuilding it from a fresh base backup rather than waiting for it to catch up",
+    "Add alerting on replay_lsn-to-sent_lsn gap growth rate, not just absolute lag_seconds, to catch cascading lag earlier"
+  ]
+}`;
+
+/** Measured for FULL_DIAGNOSIS_RESPONSE by the API: 2259 output tokens / 4633 chars. */
+const MEASURED_OUTPUT_TOKENS = 2259;
+const MEASURED_CHARS = 4633;
+const OLD_MAX_TOKENS = 1024;
+
+/**
+ * Where the old ceiling would have severed this body. Derived from the two
+ * measurements above rather than a generic 4-chars-per-token rule of thumb:
+ * dense JSON tokenizes closer to 2 chars/token, and the point of the test is
+ * that the cut lands mid-value, which is what makes the response unparseable.
+ */
+const OLD_BUDGET_CUTOFF = Math.floor(MEASURED_CHARS * (OLD_MAX_TOKENS / MEASURED_OUTPUT_TOKENS));
+
+describe('AI diagnosis response budget', () => {
+  it('parses a complete, full-length model diagnosis', () => {
+    const result = parseStandardDiagnosisResponse(FULL_DIAGNOSIS_RESPONSE);
+
+    expect(result.status).toBe('identified');
+    expect(result.scenario).toBe('replication_lag_cascade');
+    expect(result.confidence).toBeCloseTo(0.78);
+    expect(result.findings).toHaveLength(6);
+    expect(result.findings[0]?.data?.root_cause).toContain('generating WAL faster');
+    expect(result.findings[0]?.data?.recommendations).toHaveLength(7);
+  });
+
+  it('needs more than the old 1024-token ceiling to say all of that', () => {
+    expect(FULL_DIAGNOSIS_RESPONSE).toHaveLength(MEASURED_CHARS);
+    expect(MEASURED_OUTPUT_TOKENS).toBeGreaterThan(OLD_MAX_TOKENS * 2);
+  });
+
+  it('fails to parse when truncated at the old 1024-token ceiling', () => {
+    const truncated = FULL_DIAGNOSIS_RESPONSE.slice(0, OLD_BUDGET_CUTOFF);
+
+    // The cut lands inside a string value, exactly as the live API did.
+    expect(truncated.endsWith('}')).toBe(false);
+    expect(() => parseStandardDiagnosisResponse(truncated)).toThrow(
+      /Unterminated string|Unexpected end of JSON|Expected/,
+    );
+  });
+});
+
+describe('AI diagnosis response repair', () => {
+  /**
+   * Observed live while recording the demo: the model put a literal newline
+   * inside a string value instead of `\n`, JSON.parse threw "Bad control
+   * character in string literal", and that run lost its AI diagnosis to the
+   * rule-based fallback.
+   */
+  it('recovers a response containing a raw newline inside a string value', () => {
+    const withRawNewline = [
+      '{',
+      '  "status": "identified",',
+      '  "scenario": "replication_lag_cascade",',
+      '  "confidence": 0.81,',
+      '  "root_cause": "The primary is outrunning the replicas.',
+      'Replay is not paused.",',
+      '  "findings": [',
+      '    {',
+      '      "source": "pg_stat_replication",',
+      '      "observation": "Line one.\tTabbed continuation.",',
+      '      "severity": "critical",',
+      '      "evidence": "lag_seconds 342"',
+      '    }',
+      '  ],',
+      '  "recommendations": ["Check WAL generation rate"]',
+      '}',
+    ].join('\n');
+
+    // Precondition: this really is the failure mode, not a pre-parseable string.
+    expect(() => JSON.parse(withRawNewline)).toThrow(/control character/i);
+
+    const result = parseStandardDiagnosisResponse(withRawNewline);
+    expect(result.scenario).toBe('replication_lag_cascade');
+    expect(result.confidence).toBeCloseTo(0.81);
+    expect(result.findings).toHaveLength(1);
+    // The repair escapes the control character rather than dropping content.
+    expect(result.findings[0]?.data?.root_cause).toContain('Replay is not paused.');
+    expect(result.findings[0]?.observation).toContain('Tabbed continuation');
+  });
+
+  it('leaves a correctly escaped response byte-identical', () => {
+    const result = parseStandardDiagnosisResponse(FULL_DIAGNOSIS_RESPONSE);
+    expect(result.findings).toHaveLength(6);
+  });
+
+  it('does not paper over a genuinely malformed response', () => {
+    // No control characters to repair — a real structural error must still throw
+    // so the caller falls back instead of acting on a half-read diagnosis.
+    expect(() => parseStandardDiagnosisResponse('{"status": "identified", "findings"')).toThrow();
+    expect(() => parseStandardDiagnosisResponse('not json at all')).toThrow();
+  });
+});
+
+// Capture the SDK's messages.create so the plumbing test can inspect the
+// params the toolkit sends without reaching the network.
+const { createMock } = vi.hoisted(() => ({ createMock: vi.fn() }));
+
+vi.mock('@anthropic-ai/sdk', async (importOriginal) => {
+  const actual = await importOriginal<typeof AnthropicSdk>();
+  return {
+    ...actual,
+    default: class {
+      messages = { create: createMock };
+    },
+  };
+});
+
+describe('aiDiagnose default budget plumbing', () => {
+  let originalApiKey: string | undefined;
+
+  beforeEach(() => {
+    originalApiKey = process.env.ANTHROPIC_API_KEY;
+    process.env.ANTHROPIC_API_KEY = 'test-key';
+    createMock.mockReset();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    if (originalApiKey !== undefined) {
+      process.env.ANTHROPIC_API_KEY = originalApiKey;
+    } else {
+      delete process.env.ANTHROPIC_API_KEY;
+    }
+  });
+
+  it('asks for enough tokens to hold a full diagnosis when the caller sets no config', async () => {
+    createMock.mockResolvedValue({
+      content: [{ type: 'text', text: FULL_DIAGNOSIS_RESPONSE }],
+    });
+
+    const result = await aiDiagnose({ systemPrompt: 'sys', userMessage: 'state' });
+
+    expect(result).not.toBeNull();
+    expect(result?.findings).toHaveLength(6);
+    const [params] = createMock.mock.calls[0]!;
+    expect(params.max_tokens).toBeGreaterThanOrEqual(MEASURED_OUTPUT_TOKENS);
+  });
+
+  it('waits long enough for a reasoning model to finish (was 10s, measured 28-40s)', async () => {
+    vi.useFakeTimers();
+    // Model takes 35s — inside the observed sonnet-5 range for this prompt,
+    // and well past the 10s deadline this default used to impose. The mock
+    // honors the abort signal the way the real SDK does, so an early deadline
+    // actually fails this test instead of being silently ignored.
+    createMock.mockImplementation(
+      (_params: unknown, opts: { signal: AbortSignal }) =>
+        new Promise((resolve, reject) => {
+          const timer = setTimeout(
+            () => resolve({ content: [{ type: 'text', text: FULL_DIAGNOSIS_RESPONSE }] }),
+            35_000,
+          );
+          opts.signal.addEventListener('abort', () => {
+            clearTimeout(timer);
+            reject(new Error('Request was aborted.'));
+          });
+        }),
+    );
+
+    const pending = aiDiagnose({ systemPrompt: 'sys', userMessage: 'state' });
+    await vi.advanceTimersByTimeAsync(35_000);
+
+    const result = await pending;
+    expect(result).not.toBeNull();
+    expect(result?.scenario).toBe('replication_lag_cascade');
+  });
+});
diff --git a/src/__tests__/ai-response-budgets.test.ts b/src/__tests__/ai-response-budgets.test.ts
new file mode 100644
index 0000000..f9ebaa2
--- /dev/null
+++ b/src/__tests__/ai-response-budgets.test.ts
@@ -0,0 +1,387 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 CrisisMode Contributors
+
+/**
+ * Regression: the two remaining AI call sites that parse structured JSON must
+ * ask for enough tokens and wait long enough to actually get it.
+ *
+ * Same defect class as the aiDiagnose truncation bug (see
+ * ai-diagnosis-token-budget.test.ts): a max_tokens ceiling below the model's
+ * real response length does not shorten the answer, it truncates the JSON
+ * mid-string. The parse throws, the caller catches it, and the feature degrades
+ * to its rule-based fallback with no signal that a budget was the cause.
+ *
+ * `ai-explainer` was at 1024 tokens / 10s against a measured 1407-1484 tokens
+ * and 15.2-16.4s. `root-cause-synthesis` was at 1024 / 20s against a measured
+ * 749-1522 tokens and 8.8-17.7s, AND parsed with a bare `.trim()` instead of
+ * `stripCodeFence`, so a fenced response failed outright — 2 of 3 live calls.
+ *
+ * All fixtures here are verbatim live claude-sonnet-5 captures, so the token
+ * counts asserted are measured facts. No test in this file touches the network.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import type * as AnthropicSdk from '@anthropic-ai/sdk';
+import { explainPlan } from '../framework/ai-explainer.js';
+import { synthesizeByAi } from '../framework/root-cause-synthesis.js';
+import type { AgentEvidence } from '../framework/root-cause-synthesis.js';
+import type { RecoveryPlan } from '../types/recovery-plan.js';
+import type { DiagnosisResult } from '../types/diagnosis-result.js';
+
+// Capture the SDK's messages.create so every test controls the response
+// without reaching the network.
+const { createMock } = vi.hoisted(() => ({ createMock: vi.fn() }));
+
+vi.mock('@anthropic-ai/sdk', async (importOriginal) => {
+  const actual = await importOriginal<typeof AnthropicSdk>();
+  return {
+    ...actual,
+    default: class {
+      messages = { create: createMock };
+    },
+  };
+});
+
+const OLD_MAX_TOKENS = 1024;
+
+/** Resolve after `ms`, but honor the abort signal the way the real SDK does. */
+function respondAfter(ms: number, text: string) {
+  return (_params: unknown, opts: { signal: AbortSignal }) =>
+    new Promise((resolve, reject) => {
+      const timer = setTimeout(() => resolve({ content: [{ type: 'text', text }] }), ms);
+      opts.signal.addEventListener('abort', () => {
+        clearTimeout(timer);
+        reject(new Error('Request was aborted.'));
+      });
+    });
+}
+
+/**
+ * Truncate at the character offset the old 1024-token ceiling would have cut,
+ * derived from this body's own measured chars-per-token rather than a generic
+ * rule of thumb. The point is that the cut lands mid-value.
+ */
+function truncateAtOldCeiling(text: string, measuredTokens: number): string {
+  return text.slice(0, Math.floor(text.length * (OLD_MAX_TOKENS / measuredTokens)));
+}
+
+// ─────────────────────────────────────────────────────────────────────────
+// ai-explainer
+// ─────────────────────────────────────────────────────────────────────────
+
+/**
+ * Verbatim claude-sonnet-5 response to the real explainer prompt for the
+ * 10-step pg-replication reference plan (captured 2026-08-09). The API reported
+ * usage.output_tokens = 1484 with stop_reason=end_turn — 45% past the old
+ * 1024-token ceiling, so this exact explanation could never have been returned.
+ */
+const EXPLAINER_RESPONSE = `{
+  "summary": "This plan fixes a problem where one database copy (a 'replica' at address 10.0.1.52) has fallen too far behind the main database (the 'primary'), which risks slowing down the whole system. The fix works by temporarily disconnecting the lagging copy, redirecting traffic away from it, and then rebuilding it from scratch using a fresh copy of the primary's data. The whole process should take about 15 minutes, will not risk losing any data, and may cause slightly slower read speeds for users during recovery, but no impact to writes (saving new data) is expected.",
+  "stepExplanations": [
+    {
+      "stepId": "step-001",
+      "name": "Assess current replication lag across all replicas",
+      "explanation": "The system checks how far behind each database copy is compared to the primary, to confirm which ones are affected and how severe the problem is. This is just information-gathering and doesn't change anything."
+    },
+    {
+      "stepId": "step-002",
+      "name": "Notify on-call DBA of replication recovery initiation",
+      "explanation": "An alert is sent to the on-call database administrator letting them know this automated recovery process is starting, so they can monitor or step in if needed."
+    },
+    {
+      "stepId": "step-003",
+      "name": "Pre-recovery checkpoint",
+      "explanation": "The system records the current state of things as a safety snapshot, so if something goes wrong later, it knows exactly what to roll back to."
+    },
+    {
+      "stepId": "step-004",
+      "name": "Disconnect lagging replica 10.0.1.52 from replication",
+      "explanation": "The problematic database copy is cut off from receiving updates from the primary. This copy will become temporarily unavailable for reads, but the primary and other replicas keep working normally. This is a moderate-risk action but only affects this one replica."
+    },
+    {
+      "stepId": "step-005",
+      "name": "Redirect read traffic away from disconnected replica",
+      "explanation": "The system reconfigures the load balancer (the traffic router) so that user read requests no longer go to the disconnected replica, avoiding errors or timeouts. This is a routine, low-risk change."
+    },
+    {
+      "stepId": "step-006",
+      "name": "Assess recovery progress before proceeding",
+      "explanation": "The system pauses to re-check that everything is going as expected before moving to the riskier next steps. This is an automatic checkpoint, not a user-facing change."
+    },
+    {
+      "stepId": "step-007",
+      "name": "Approve replica resynchronization",
+      "explanation": "A human (likely the on-call DBA) must manually approve before the system proceeds to rebuild the broken replica, since the next step is more resource-intensive and impactful."
+    },
+    {
+      "stepId": "step-008",
+      "name": "Initiate pg_basebackup and re-establish replication for 10.0.1.52",
+      "explanation": "The system performs a full fresh copy of the primary database's data onto the broken replica to rebuild it from scratch. This is the highest-risk step because it puts extra load on the primary database, which could temporarily slow it down for other users."
+    },
+    {
+      "stepId": "step-009",
+      "name": "Restore traffic or notify for manual intervention",
+      "explanation": "The system checks whether the rebuilt replica is healthy again. If yes, it automatically restores normal traffic to it; if not, it alerts a human to step in and investigate manually."
+    },
+    {
+      "stepId": "step-010",
+      "name": "Send recovery summary",
+      "explanation": "A final report is sent out summarizing what happened during the recovery, so the team has a record of the incident and the actions taken."
+    }
+  ],
+  "risks": [
+    "During the rebuild step (pg_basebackup), the primary database will experience increased load, which could slow down performance for other reads or queries system-wide.",
+    "Read queries may be slightly slower than usual throughout the recovery process, though no write/data-loss impact is expected.",
+    "If the resynchronization fails, the system will require manual intervention from a human operator rather than resolving automatically.",
+    "The disconnected replica will be completely unavailable for reads until it's successfully rebuilt and reconnected.",
+    "This plan includes rollback steps for each stage, but a failure during the high-risk rebuild step could still require careful manual recovery."
+  ]
+}`;
+
+const EXPLAINER_MEASURED_TOKENS = 1484;
+
+/** Measured latency range for the explainer prompt: 15.2-16.4s. */
+const EXPLAINER_MEASURED_MS = 16_400;
+
+/**
+ * The plan only has to satisfy the fallback builder and the prompt assembly —
+ * the SDK is mocked, so the response is EXPLAINER_RESPONSE regardless of what
+ * is sent. The fixture itself is the real answer to the 10-step reference plan.
+ */
+function makePlan(): RecoveryPlan {
+  return {
+    planId: 'rp-test-001',
+    metadata: {
+      scenario: 'replication_lag_cascade',
+      summary: 'Recover PostgreSQL replication by resyncing the lagging replica',
+      estimatedDuration: 'PT15M',
+    },
+    steps: [
+      {
+        stepId: 'step-001',
+        type: 'diagnosis_action',
+        name: 'Assess current replication lag across all replicas',
+        command: { type: 'sql', operation: 'SELECT * FROM pg_stat_replication' },
+      },
+      {
+        stepId: 'step-004',
+        type: 'system_action',
+        name: 'Disconnect lagging replica 10.0.1.52 from replication',
+        riskLevel: 'elevated',
+        command: { type: 'sql', operation: 'SELECT pg_terminate_backend(pid)' },
+        blastRadius: { directComponents: ['pg-replica-10-0-1-52'] },
+      },
+    ],
+    rollbackStrategy: { type: 'stepwise' },
+    impact: {
+      dataLossRisk: 'none',
+      estimatedUserImpact: 'Read queries may experience elevated latency',
+    },
+  } as unknown as RecoveryPlan;
+}
+
+const DIAGNOSIS: DiagnosisResult = {
+  status: 'identified',
+  scenario: 'replication_lag_cascade',
+  confidence: 0.78,
+  findings: [],
+  diagnosticPlanNeeded: false,
+};
+
+describe('ai-explainer response budget', () => {
+  let originalApiKey: string | undefined;
+
+  beforeEach(() => {
+    originalApiKey = process.env.ANTHROPIC_API_KEY;
+    process.env.ANTHROPIC_API_KEY = 'test-key';
+    createMock.mockReset();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    if (originalApiKey !== undefined) {
+      process.env.ANTHROPIC_API_KEY = originalApiKey;
+    } else {
+      delete process.env.ANTHROPIC_API_KEY;
+    }
+  });
+
+  it('asks for enough tokens to explain every step of a real plan', async () => {
+    createMock.mockResolvedValue({ content: [{ type: 'text', text: EXPLAINER_RESPONSE }] });
+
+    const result = await explainPlan(makePlan(), DIAGNOSIS);
+
+    expect(result.source).toBe('ai');
+    expect(result.stepExplanations).toHaveLength(10);
+    expect(result.risks).toHaveLength(5);
+    const [params] = createMock.mock.calls[0]!;
+    expect(params.max_tokens).toBeGreaterThanOrEqual(EXPLAINER_MEASURED_TOKENS);
+  });
+
+  it('silently loses the explanation when truncated at the old 1024-token ceiling', async () => {
+    const truncated = truncateAtOldCeiling(EXPLAINER_RESPONSE, EXPLAINER_MEASURED_TOKENS);
+    expect(truncated.endsWith('}')).toBe(false);
+    createMock.mockResolvedValue({ content: [{ type: 'text', text: truncated }] });
+
+    const result = await explainPlan(makePlan(), DIAGNOSIS);
+
+    // This is the bug the budget fixes: a usable-looking answer with no
+    // indication that the model actually replied.
+    expect(result.source).toBe('fallback');
+  });
+
+  it('waits past the old 10s deadline for a response that really takes 16s', async () => {
+    vi.useFakeTimers();
+    createMock.mockImplementation(respondAfter(EXPLAINER_MEASURED_MS, EXPLAINER_RESPONSE));
+
+    const pending = explainPlan(makePlan(), DIAGNOSIS);
+    await vi.advanceTimersByTimeAsync(EXPLAINER_MEASURED_MS);
+
+    expect((await pending).source).toBe('ai');
+  });
+
+  it('still gives up well before the 60s batch bound, because an operator is waiting', async () => {
+    vi.useFakeTimers();
+    createMock.mockImplementation(respondAfter(45_000, EXPLAINER_RESPONSE));
+
+    const pending = explainPlan(makePlan(), DIAGNOSIS);
+    await vi.advanceTimersByTimeAsync(45_000);
+
+    // 45s is past this call site's interactive deadline: the operator gets the
+    // structural summary instead of a stalled terminal.
+    expect((await pending).source).toBe('fallback');
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────────
+// root-cause-synthesis
+// ─────────────────────────────────────────────────────────────────────────
+
+/**
+ * Shape of a real synthesis response for a wide cascade. The live 10-agent call
+ * measured 1522 output tokens; this body is trimmed to the same structure so the
+ * fixture stays readable, and the measured count is asserted separately.
+ */
+const SYNTHESIS_BODY = `{
+  "clusters": [
+    {
+      "rootCause": "A primary-side WAL generation surge is saturating downstream consumers across the stack",
+      "confidence": 0.82,
+      "agents": ["pg-replication", "kafka", "queue-backlog"],
+      "reasoning": "All three began degrading within the same two-minute window, and each reports a growing backlog rather than an error spike, which points to a shared upstream throughput ceiling rather than three independent faults.",
+      "investigationOrder": ["pg-replication", "kafka", "queue-backlog"]
+    },
+    {
+      "rootCause": "Node-level disk pressure on the shared worker pool",
+      "confidence": 0.64,
+      "agents": ["kubernetes", "disk"],
+      "reasoning": "Disk reports a filling volume on node-7 and kubernetes reports evictions scheduled from the same node, so the eviction churn is a symptom of the disk condition.",
+      "investigationOrder": ["disk", "kubernetes"]
+    }
+  ],
+  "uncorrelated": ["tls", "dns"],
+  "narrative": "Two independent incidents are in flight. A WAL generation surge on the primary is cascading into Kafka and the order queue, while unrelated disk pressure on node-7 is driving Kubernetes evictions. TLS and DNS degradation appear coincidental."
+}`;
+
+/** The fenced form the model actually returns — 2 of 3 live calls came back like this. */
+const SYNTHESIS_FENCED = '```json\n' + SYNTHESIS_BODY + '\n```';
+
+/** Measured for a 10-agent cascade: 1522 output tokens, 17.7s. */
+const SYNTHESIS_MEASURED_TOKENS = 1522;
+const SYNTHESIS_MEASURED_MS = 17_700;
+
+function makeEvidence(): AgentEvidence[] {
+  return ['pg-replication', 'kafka', 'kubernetes', 'disk'].map((agentKind) => ({
+    agentKind,
+    targetName: `prod-${agentKind}`,
+    signals: [
+      {
+        type: 'error_rate',
+        source: `${agentKind}_probe`,
+        detail: `${agentKind} is degraded with a growing backlog`,
+        severity: 'critical',
+      },
+    ],
+  })) as AgentEvidence[];
+}
+
+describe('root-cause-synthesis response handling', () => {
+  let originalApiKey: string | undefined;
+
+  beforeEach(() => {
+    originalApiKey = process.env.ANTHROPIC_API_KEY;
+    process.env.ANTHROPIC_API_KEY = 'test-key';
+    createMock.mockReset();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    if (originalApiKey !== undefined) {
+      process.env.ANTHROPIC_API_KEY = originalApiKey;
+    } else {
+      delete process.env.ANTHROPIC_API_KEY;
+    }
+  });
+
+  it('parses a fenced response instead of falling back on the fence', async () => {
+    // Precondition: this is the failure the bare .trim() hit.
+    expect(() => JSON.parse(SYNTHESIS_FENCED.trim())).toThrow();
+    createMock.mockResolvedValue({ content: [{ type: 'text', text: SYNTHESIS_FENCED }] });
+
+    const result = await synthesizeByAi(makeEvidence());
+
+    expect(result.source).toBe('ai');
+    expect(result.clusters).toHaveLength(2);
+    expect(result.clusters[0]?.agents).toContain('kafka');
+    expect(result.uncorrelated).toEqual(['tls', 'dns']);
+  });
+
+  it('parses an unfenced response too', async () => {
+    createMock.mockResolvedValue({ content: [{ type: 'text', text: SYNTHESIS_BODY }] });
+
+    const result = await synthesizeByAi(makeEvidence());
+    expect(result.source).toBe('ai');
+    expect(result.clusters).toHaveLength(2);
+  });
+
+  it('asks for enough tokens to correlate a wide cascade', async () => {
+    createMock.mockResolvedValue({ content: [{ type: 'text', text: SYNTHESIS_BODY }] });
+
+    await synthesizeByAi(makeEvidence());
+
+    const [params] = createMock.mock.calls[0]!;
+    expect(params.max_tokens).toBeGreaterThanOrEqual(SYNTHESIS_MEASURED_TOKENS);
+  });
+
+  it('falls back to rules when truncated at the old 1024-token ceiling', async () => {
+    const truncated = truncateAtOldCeiling(SYNTHESIS_BODY, SYNTHESIS_MEASURED_TOKENS);
+    createMock.mockResolvedValue({ content: [{ type: 'text', text: truncated }] });
+
+    const result = await synthesizeByAi(makeEvidence());
+    expect(result.source).toBe('rules');
+  });
+
+  // Note: unlike the explainer's 10s, the old 20s bound did admit the measured
+  // 17.7s — barely, with 2.3s of margin. This test locks in that the measured
+  // worst case must succeed; it is a guard on the headroom, not proof that the
+  // old value failed.
+  it('completes a 10-agent cascade that takes the measured 17.7s', async () => {
+    vi.useFakeTimers();
+    createMock.mockImplementation(respondAfter(SYNTHESIS_MEASURED_MS, SYNTHESIS_BODY));
+
+    const pending = synthesizeByAi(makeEvidence());
+    await vi.advanceTimersByTimeAsync(SYNTHESIS_MEASURED_MS);
+
+    expect((await pending).source).toBe('ai');
+  });
+
+  it('keeps an interactive-scale deadline rather than the 60s batch bound', async () => {
+    vi.useFakeTimers();
+    createMock.mockImplementation(respondAfter(45_000, SYNTHESIS_BODY));
+
+    const pending = synthesizeByAi(makeEvidence());
+    await vi.advanceTimersByTimeAsync(45_000);
+
+    expect((await pending).source).toBe('rules');
+  });
+});
diff --git a/src/agent/kafka/ai-diagnosis.ts b/src/agent/kafka/ai-diagnosis.ts
index 87b1732..a367274 100644
--- a/src/agent/kafka/ai-diagnosis.ts
+++ b/src/agent/kafka/ai-diagnosis.ts
@@ -9,7 +9,7 @@
  *
  * Falls back to rule-based diagnosis if:
  * - ANTHROPIC_API_KEY is not set
- * - The API call fails or times out (10s max)
+ * - The API call fails or times out (60s max — the toolkit default)
  * - The response can't be parsed
  */
 
diff --git a/src/agent/pg-replication/ai-diagnosis.ts b/src/agent/pg-replication/ai-diagnosis.ts
index 9db0cbf..7ccb0bc 100644
--- a/src/agent/pg-replication/ai-diagnosis.ts
+++ b/src/agent/pg-replication/ai-diagnosis.ts
@@ -9,7 +9,7 @@
  *
  * Falls back to rule-based diagnosis if:
  * - ANTHROPIC_API_KEY is not set
- * - The API call fails or times out (10s max)
+ * - The API call fails or times out (60s max — the toolkit default)
  * - The response can't be parsed
  */
 
diff --git a/src/framework/ai-client.ts b/src/framework/ai-client.ts
index 92d1e14..9731c95 100644
--- a/src/framework/ai-client.ts
+++ b/src/framework/ai-client.ts
@@ -20,8 +20,24 @@
 
 import { defaultAiModel } from './ai-model.js';
 
-const DEFAULT_TIMEOUT_MS = 10_000;
-const DEFAULT_MAX_TOKENS = 1024;
+/**
+ * Fallback budgets for callers that don't set their own.
+ *
+ * Sized so a full structured response fits: the previous 1024-token ceiling
+ * truncated every JSON diagnosis mid-string, and since a truncated response
+ * cannot be parsed, the AI path failed closed to heuristics with no signal
+ * beyond a parse error on stderr. 60s likewise leaves headroom for a
+ * reasoning model — measured 28-40s for a full-length sonnet-5 diagnosis
+ * against the 10s that was here before.
+ *
+ * Every production call site currently passes both explicitly (which is why
+ * these values only ever applied to the two toolkit entry points in
+ * ai-diagnosis.ts). New callers on an INTERACTIVE path should keep doing so
+ * with a tighter `timeoutMs` — a human waiting at a prompt is better served
+ * by a fast fallback than by a 60s hang.
+ */
+const DEFAULT_TIMEOUT_MS = 60_000;
+const DEFAULT_MAX_TOKENS = 4096;
 
 /**
  * Thrown when the request did not complete within `timeoutMs`.
@@ -60,9 +76,9 @@ export interface CallClaudeOptions {
   user?: string;
   /** Full conversation history. Overrides `user` when set (used by the ask REPL). */
   messages?: ClaudeMessage[];
-  /** Max tokens for the response. Defaults to 1024. */
+  /** Max tokens for the response. Defaults to 4096. */
   maxTokens?: number;
-  /** Timeout in milliseconds. Defaults to 10000. */
+  /** Timeout in milliseconds. Defaults to 60000. */
   timeoutMs?: number;
   /** Model to use. Defaults to defaultAiModel() (CRISISMODE_AI_MODEL override). */
   model?: string;
diff --git a/src/framework/ai-diagnosis.ts b/src/framework/ai-diagnosis.ts
index 287779a..1031f19 100644
--- a/src/framework/ai-diagnosis.ts
+++ b/src/framework/ai-diagnosis.ts
@@ -10,7 +10,7 @@
  * response parsing, and fallback.
  *
  * Safety:
- * - 10s timeout via AbortController to prevent blocking during a crisis
+ * - 60s timeout via AbortController to prevent blocking during a crisis
  * - Input sanitization (field length limits, control character stripping)
  * - AI findings are advisory only — never executable
  * - Raw evidence is always preserved alongside AI interpretation
@@ -21,7 +21,35 @@ import { getNetworkProfile } from './network-profile.js';
 import { defaultAiModel } from './ai-model.js';
 import { AiTimeoutError, callClaude, stripCodeFence } from './ai-client.js';
 
-const DEFAULT_TIMEOUT_MS = 10_000;
+/**
+ * Response budget for every agent that calls the toolkit without its own config
+ * (the pg-replication and kafka agents, and `bundle ingest`).
+ *
+ * These were 10s / 1024 tokens, which no current model could satisfy: a
+ * complete diagnosis for the standard JSON schema (status, scenario,
+ * confidence, a root-cause paragraph, findings with evidence, ordered
+ * recommendations) runs past 1024 tokens, so the response arrived truncated
+ * with stop_reason=max_tokens and `JSON.parse` threw "Unterminated string".
+ * That made `aiDiagnose` return null on EVERY call and every agent degrade
+ * silently to its rule-based fallback — the failure looked like "AI is
+ * unavailable" rather than "the budget is too small". Measured against the
+ * real pg-replication prompt: sonnet-5 needs ~28-40s, haiku-4.5 ~12-14s, and
+ * both parse cleanly once the token ceiling is lifted.
+ *
+ * 60s matches the value `evidence-bundle-respond` already ships for the same
+ * class of structured response. The token ceiling is set above it: nine live
+ * sonnet-5 diagnoses of the pg prompt came back at 2259-3742 output tokens, so
+ * 4096 leaves only ~9% headroom and one wordier finding list would truncate —
+ * reintroducing exactly the silent fallback this constant exists to prevent.
+ * An unused ceiling costs nothing (responses stop at end_turn), so the margin
+ * is free.
+ *
+ * Only non-interactive paths reach these; interactive callers (ask, scan
+ * summaries, symptom routing) set their own tighter bounds at the call site so
+ * a human is never left hanging.
+ */
+const DEFAULT_TIMEOUT_MS = 60_000;
+const DEFAULT_MAX_TOKENS = 6144;
 const MAX_FIELD_LENGTH = 10_000;
 
 export interface AiDiagnosisConfig {
@@ -29,9 +57,9 @@ export interface AiDiagnosisConfig {
   apiKey?: string;
   /** Model to use. Defaults to defaultAiModel() (CRISISMODE_AI_MODEL override). */
   model?: string;
-  /** Timeout in milliseconds. Defaults to 10000. */
+  /** Timeout in milliseconds. Defaults to 60000. */
   timeoutMs?: number;
-  /** Max tokens for the response. Defaults to 1024. */
+  /** Max tokens for the response. Defaults to 6144. */
   maxTokens?: number;
 }
 
@@ -72,13 +100,76 @@ export function sanitizeInput(text: string, maxLength: number = MAX_FIELD_LENGTH
   return cleaned;
 }
 
+/**
+ * Escape raw control characters that appear INSIDE JSON string literals.
+ *
+ * `sanitizeInput` strips control characters on the way to the model; this is the
+ * missing counterpart on the way back. Models occasionally emit a literal
+ * newline or tab inside a string value instead of `\n`/`\t`, which is illegal
+ * JSON — observed live as "Bad control character in string literal in JSON at
+ * position 1741" while recording the demo, which silently cost that run its AI
+ * diagnosis. Repairing it is strictly better than discarding a whole diagnosis
+ * over a quoting slip: only text that already failed to parse reaches this, and
+ * if the repair does not help, the caller falls back exactly as it did before.
+ *
+ * Deliberately narrow — it tracks in-string state and rewrites nothing but
+ * control characters, so structure and content are otherwise untouched.
+ */
+function escapeControlCharsInStrings(json: string): string {
+  const ESCAPES: Record<string, string> = {
+    '\n': '\\n',
+    '\r': '\\r',
+    '\t': '\\t',
+    '\b': '\\b',
+    '\f': '\\f',
+  };
+
+  let out = '';
+  let inString = false;
+  let escaped = false;
+
+  for (const char of json) {
+    if (escaped) {
+      out += char;
+      escaped = false;
+      continue;
+    }
+    if (char === '\\' && inString) {
+      out += char;
+      escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      inString = !inString;
+      out += char;
+      continue;
+    }
+    if (inString && char.charCodeAt(0) < 0x20) {
+      out += ESCAPES[char] ?? `\\u${char.charCodeAt(0).toString(16).padStart(4, '0')}`;
+      continue;
+    }
+    out += char;
+  }
+
+  return out;
+}
+
 /**
  * Default response parser for the standard AI diagnosis JSON schema.
  */
 export function parseStandardDiagnosisResponse(text: string): DiagnosisResult {
   // Strip markdown code fences if present
   const jsonStr = stripCodeFence(text);
-  const parsed: AiRawResponse = JSON.parse(jsonStr);
+  let parsed: AiRawResponse;
+  try {
+    parsed = JSON.parse(jsonStr);
+  } catch (err) {
+    // Retry once with control characters escaped. A response that is truncated
+    // or otherwise malformed still throws, and the caller still falls back.
+    const repaired = escapeControlCharsInStrings(jsonStr);
+    if (repaired === jsonStr) throw err;
+    parsed = JSON.parse(repaired);
+  }
 
   const findings: DiagnosisFinding[] = (parsed.findings ?? []).map((f) => ({
     source: String(f.source ?? 'ai_analysis'),
@@ -128,7 +219,7 @@ export async function aiCallText(
 
   const model = config.model ?? defaultAiModel();
   const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const maxTokens = config.maxTokens ?? 1024;
+  const maxTokens = config.maxTokens ?? DEFAULT_MAX_TOKENS;
 
   const sanitizedSystem = sanitizeInput(systemPrompt, 5000);
   const sanitizedUser = sanitizeInput(userMessage, MAX_FIELD_LENGTH);
diff --git a/src/framework/ai-explainer.ts b/src/framework/ai-explainer.ts
index b8c2e8f..c6cd2cf 100644
--- a/src/framework/ai-explainer.ts
+++ b/src/framework/ai-explainer.ts
@@ -8,7 +8,7 @@
  * a human-readable explanation. Falls back gracefully when no API key is set.
  *
  * Safety:
- * - 10s timeout via AbortController
+ * - 30s timeout via AbortController (see EXPLAINER_TIMEOUT_MS)
  * - Input sanitization via framework AI toolkit
  * - Advisory only — the explanation never modifies the plan
  */
@@ -22,7 +22,34 @@ import { callClaude, stripCodeFence } from './ai-client.js';
 import { riskExceeds } from './risk.js';
 
 const DEFAULT_MODEL = defaultAiModel();
-const DEFAULT_TIMEOUT_MS = 10_000;
+
+/**
+ * Response budget for one plan explanation.
+ *
+ * Measured live (claude-sonnet-5, the 10-step pg-replication reference plan):
+ * 1407, 1431 and 1450 output tokens at 15.2-16.4s. The previous ceiling of
+ * 1024 could not fit any of those, so the response came back truncated,
+ * `JSON.parse` threw, and `explainPlan` swallowed it into the structural
+ * fallback — the same silent degradation that made aiDiagnose useless. Cost
+ * scales with step count at roughly 143 tokens/step plus ~200 tokens of
+ * summary and risks, so 4096 covers a ~27-step plan against a reference plan
+ * of 10. An unused ceiling costs nothing: responses stop at end_turn.
+ */
+const EXPLAINER_MAX_TOKENS = 4096;
+
+/**
+ * 30s, not the 60s the diagnosis toolkit uses.
+ *
+ * This is an INTERACTIVE path: both callers (src/live.ts, src/cli/interactive.ts)
+ * run it in the foreground immediately after printing the plan table, with an
+ * operator waiting mid-incident. A 60s stall there is worse for that operator
+ * than dropping to the structural summary, which is already a usable answer.
+ * 10s was on the wrong side of the tradeoff though — it is below the measured
+ * floor, so it guaranteed the fallback every time rather than trading off
+ * anything. 30s clears the measured 16.4s with headroom and matches the bound
+ * the `ask` REPL already uses for interactive AI.
+ */
+const EXPLAINER_TIMEOUT_MS = 30_000;
 
 export interface PlanExplanation {
   /** One-paragraph summary of what the plan does and why. */
@@ -130,8 +157,8 @@ ${JSON.stringify(planSummary, null, 2)}`);
     system: systemPrompt,
     user: userMessage,
     model: DEFAULT_MODEL,
-    maxTokens: 1024,
-    timeoutMs: DEFAULT_TIMEOUT_MS,
+    maxTokens: EXPLAINER_MAX_TOKENS,
+    timeoutMs: EXPLAINER_TIMEOUT_MS,
     apiKey,
   });
 
diff --git a/src/framework/evidence-bundle-respond.ts b/src/framework/evidence-bundle-respond.ts
index 58149bb..ee48ef7 100644
--- a/src/framework/evidence-bundle-respond.ts
+++ b/src/framework/evidence-bundle-respond.ts
@@ -75,11 +75,13 @@ import type {
 const RESPONSE_SCHEMA_VERSION = 'incident-generator.agent-adapter-response/v1' as const;
 
 // Bundle prompts include the full evidence body + a structured-output
-// system prompt. Real-crisis agents use a tight 10s/1024-token budget;
-// here we give Claude more room because (a) the response is rich JSON
-// covering hypotheses, evidence_refs, actions, abstention, uncertainty
-// and (b) we're typically running in a benchmark, not a live incident.
-// Overridable via env vars so benchmark callers can tune without rebuilding.
+// system prompt. These values were the first in the framework sized for a rich
+// JSON response (hypotheses, evidence_refs, actions, abstention, uncertainty)
+// rather than a one-paragraph answer, and they turned out to be the right
+// shape: the diagnosis toolkit has since converged on the same 60s bound after
+// its 10s/1024-token budget was found to truncate every structured response it
+// ever produced. Kept overridable via env vars so benchmark callers can tune
+// without rebuilding.
 const DEFAULT_BUNDLE_TIMEOUT_MS = 60_000;
 const DEFAULT_BUNDLE_MAX_TOKENS = 4096;
 
diff --git a/src/framework/root-cause-synthesis.ts b/src/framework/root-cause-synthesis.ts
index c1b9c1a..c780b8c 100644
--- a/src/framework/root-cause-synthesis.ts
+++ b/src/framework/root-cause-synthesis.ts
@@ -51,7 +51,7 @@ import type { RecurringPattern, HealthSnapshot } from './watch-state.js';
 import type { HealthAssessment } from '../types/health.js';
 import type { DiagnosisResult } from '../types/diagnosis-result.js';
 import { defaultAiModel } from './ai-model.js';
-import { AiTimeoutError, callClaude } from './ai-client.js';
+import { AiTimeoutError, callClaude, stripCodeFence } from './ai-client.js';
 
 // ── Types ──
 
@@ -520,6 +520,31 @@ export function synthesizeByRules(evidence: AgentEvidence[]): SynthesisResult {
 
 // ── AI-assisted synthesis ──
 
+/**
+ * Response budget for one synthesis across all degraded agents.
+ *
+ * Measured live (claude-sonnet-5, synthetic scan evidence with health signals,
+ * diagnosis findings and patterns per agent): 804 output tokens for 4 agents,
+ * 749 for 7, and 1522 for 10, at 8.8s / 9.5s / 17.7s. The previous 1024-token
+ * ceiling therefore truncated exactly when synthesis is most valuable — a wide
+ * multi-system cascade — and a truncated response throws in JSON.parse and
+ * falls back to rule-based correlation with no indication why. Cost grows at
+ * roughly 150 tokens per degraded agent, so 4096 covers ~25 simultaneously
+ * degraded targets; a stack in that state has bigger problems than this call.
+ */
+const SYNTHESIS_MAX_TOKENS = 4096;
+
+/**
+ * 30s, up from 20s, and deliberately not the diagnosis toolkit's 60s.
+ *
+ * 20s left almost no margin over the measured 17.7s for a 10-agent cascade.
+ * This is scan-adjacent work with an operator watching, so it keeps an
+ * interactive-scale bound rather than the batch 60s: rule-based correlation is
+ * a genuinely useful answer, so waiting a full minute to maybe do better is
+ * the wrong trade at a terminal.
+ */
+const SYNTHESIS_TIMEOUT_MS = 30_000;
+
 const SYNTHESIS_SYSTEM_PROMPT = `You are a root cause analyst for CrisisMode, an infrastructure recovery framework. You receive evidence from multiple recovery agents that are simultaneously detecting problems.
 
 Your job is to identify shared root causes — failures in one system that cascade to others. For example:
@@ -606,12 +631,17 @@ async function callSynthesisAi(
     system: SYNTHESIS_SYSTEM_PROMPT,
     user: userMessage,
     model: defaultAiModel(),
-    maxTokens: 1024,
-    timeoutMs: 20_000,
+    maxTokens: SYNTHESIS_MAX_TOKENS,
+    timeoutMs: SYNTHESIS_TIMEOUT_MS,
     apiKey,
   });
 
-  const parsed = JSON.parse(text.trim()) as {
+  // stripCodeFence, not a bare trim: the model wraps this response in a ```json
+  // fence often enough that omitting it was the dominant failure mode here —
+  // 2 of 3 live calls came back fenced, threw "Unexpected token '`'", and fell
+  // through to rule-based correlation. Every other JSON-parsing AI call site in
+  // the framework already strips it.
+  const parsed = JSON.parse(stripCodeFence(text)) as {
     clusters?: Array<{
       rootCause: string;
       confidence: number;

From 2230bb81331ee69fea987153eb8c1a1751ddd408 Mon Sep 17 00:00:00 2001
From: trs-80 <109326+trs-80@users.noreply.github.com>
Date: Sun, 9 Aug 2026 12:00:10 -0400
Subject: [PATCH 02/17] fix(cli): suggest commands that actually run
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Two copy-pasteable dead ends in scan output.

scan.ts pointed at `crisismode init --plugin my-check`, but init only parses
--agent, so the suggested command errors out.

incident-summary.ts suggested `crisismode diagnose <finding-id>`. diagnose
reads positionals[0] as a *target* name, and only PLUG-<n> is routed to a
plugin's diagnose verb — so the hint worked for plugin findings and failed
with `Target "PG-001" not found in config` for every agent finding.
diagnoseCommandFor now derives the addressable target from the trailing
parenthesized group scan builds into `service`, keeps the raw id for PLUG-<n>,
and falls back to the bare command rather than emitting something broken.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 src/__tests__/ai-summary.test.ts       |  2 +-
 src/__tests__/incident-summary.test.ts | 57 +++++++++++++++++++++++---
 src/cli/commands/scan.ts               |  2 +-
 src/cli/incident-summary.ts            | 23 ++++++++++-
 4 files changed, 75 insertions(+), 9 deletions(-)

diff --git a/src/__tests__/ai-summary.test.ts b/src/__tests__/ai-summary.test.ts
index cda28f2..0c0b559 100644
--- a/src/__tests__/ai-summary.test.ts
+++ b/src/__tests__/ai-summary.test.ts
@@ -22,7 +22,7 @@ function makeIncidentSummary(overrides?: Partial<IncidentSummary>): IncidentSumm
     healthy: [
       { id: 'DNS-001', service: 'dns (local-dns)', status: 'healthy', summary: 'All DNS lookups OK' },
     ],
-    nextSteps: ['Investigate: `crisismode diagnose PG-001`'],
+    nextSteps: ['Investigate: `crisismode diagnose detected-postgresql`'],
     durationMs: 1200,
     ...overrides,
   };
diff --git a/src/__tests__/incident-summary.test.ts b/src/__tests__/incident-summary.test.ts
index 9a00515..ceeadde 100644
--- a/src/__tests__/incident-summary.test.ts
+++ b/src/__tests__/incident-summary.test.ts
@@ -4,8 +4,10 @@
 import { describe, it, expect } from 'vitest';
 import {
   buildIncidentSummary,
+  diagnoseCommandFor,
   formatIncidentSummaryText,
 } from '../cli/incident-summary.js';
+import type { SummaryFinding } from '../cli/incident-summary.js';
 import type { ScanResult } from '../cli/output.js';
 
 function makeFinding(
@@ -36,6 +38,47 @@ function makeResult(
   };
 }
 
+describe('diagnoseCommandFor', () => {
+  function summaryFinding(overrides: Partial<SummaryFinding> = {}): SummaryFinding {
+    return { id: 'PG-001', service: 'postgresql (prod-db)', status: 'unhealthy', summary: 'x', ...overrides };
+  }
+
+  it('names the target, not the finding id — `diagnose PG-001` does not resolve', () => {
+    expect(diagnoseCommandFor(summaryFinding())).toBe('crisismode diagnose prod-db');
+  });
+
+  it('keeps the finding id for PLUG-* findings, which diagnose routes by index', () => {
+    expect(
+      diagnoseCommandFor(summaryFinding({ id: 'PLUG-002', service: 'plugin (check-disk-usage)' })),
+    ).toBe('crisismode diagnose PLUG-002');
+  });
+
+  it('matches PLUG-* case-insensitively', () => {
+    expect(diagnoseCommandFor(summaryFinding({ id: 'plug-7', service: 'plugin (x)' })))
+      .toBe('crisismode diagnose plug-7');
+  });
+
+  it('falls back to the bare command when no target name is recoverable', () => {
+    expect(diagnoseCommandFor(summaryFinding({ service: 'postgresql' })))
+      .toBe('crisismode diagnose');
+  });
+
+  it('handles kinds that themselves contain dots and dashes', () => {
+    expect(
+      diagnoseCommandFor(summaryFinding({
+        id: 'LLM-004',
+        service: 'llm-provider.anthropic (derived-llm-anthropic)',
+      })),
+    ).toBe('crisismode diagnose derived-llm-anthropic');
+  });
+
+  it('takes the trailing group when the service string has more than one', () => {
+    expect(
+      diagnoseCommandFor(summaryFinding({ service: 'postgresql (v16) (prod-db)' })),
+    ).toBe('crisismode diagnose prod-db');
+  });
+});
+
 describe('buildIncidentSummary', () => {
   it('handles zero findings', () => {
     const summary = buildIncidentSummary(makeResult());
@@ -70,8 +113,8 @@ describe('buildIncidentSummary', () => {
     const result = makeResult({
       score: 50,
       findings: [
-        makeFinding({ id: 'PG-001', service: 'postgresql', status: 'unhealthy', summary: 'Replication lag' }),
-        makeFinding({ id: 'REDIS-001', service: 'redis', status: 'healthy' }),
+        makeFinding({ id: 'PG-001', service: 'postgresql (prod-db)', status: 'unhealthy', summary: 'Replication lag' }),
+        makeFinding({ id: 'REDIS-001', service: 'redis (cache-01)', status: 'healthy' }),
       ],
     });
 
@@ -81,7 +124,9 @@ describe('buildIncidentSummary', () => {
     expect(summary.critical[0]!.id).toBe('PG-001');
     expect(summary.healthy).toHaveLength(1);
     expect(summary.headline).toContain('1 service unhealthy');
-    expect(summary.nextSteps[0]).toContain('crisismode diagnose PG-001');
+    // The suggestion must name the target, not the finding id — `diagnose PG-001`
+    // does not resolve.
+    expect(summary.nextSteps[0]).toContain('crisismode diagnose prod-db');
   });
 
   it('groups recovering and unknown as warning', () => {
@@ -104,15 +149,15 @@ describe('buildIncidentSummary', () => {
     const result = makeResult({
       score: 0,
       findings: [
-        makeFinding({ id: 'PG-001', status: 'unhealthy', summary: 'Down' }),
-        makeFinding({ id: 'REDIS-001', status: 'unhealthy', summary: 'OOM' }),
+        makeFinding({ id: 'PG-001', service: 'postgresql (prod-db)', status: 'unhealthy', summary: 'Down' }),
+        makeFinding({ id: 'REDIS-001', service: 'redis (cache-01)', status: 'unhealthy', summary: 'OOM' }),
       ],
     });
 
     const summary = buildIncidentSummary(result);
 
     expect(summary.nextSteps).toHaveLength(3);
-    expect(summary.nextSteps[0]).toContain('crisismode diagnose PG-001');
+    expect(summary.nextSteps[0]).toContain('crisismode diagnose prod-db');
     expect(summary.nextSteps[1]).toContain('1 more unhealthy');
     expect(summary.nextSteps[2]).toContain('crisismode recover');
   });
diff --git a/src/cli/commands/scan.ts b/src/cli/commands/scan.ts
index e08b6d2..d55460d 100644
--- a/src/cli/commands/scan.ts
+++ b/src/cli/commands/scan.ts
@@ -571,7 +571,7 @@ export async function runScan(opts: ScanOptions): Promise<ScanResult> {
 
   // Hint about check plugins when none are discovered
   if (healthPlugins.length === 0) {
-    printInfo('No check plugins found. Add custom checks in ./checks/ or scaffold one with: crisismode init --plugin my-check');
+    printInfo('No check plugins found. Add custom checks in ./checks/ or scaffold one with: crisismode init --agent my-check');
   }
 
   return result;
diff --git a/src/cli/incident-summary.ts b/src/cli/incident-summary.ts
index d40e12e..46476cb 100644
--- a/src/cli/incident-summary.ts
+++ b/src/cli/incident-summary.ts
@@ -38,6 +38,27 @@ export interface SummaryFinding {
   summary: string;
 }
 
+/**
+ * Build a `crisismode diagnose` invocation that actually resolves for a finding.
+ *
+ * `diagnose` takes a **target name**, not a finding id — the one exception is
+ * `PLUG-<n>`, which `runDiagnose` routes to the check plugin's diagnose verb by
+ * index. So suggesting the raw finding id works for plugin findings and fails
+ * with `Target "PG-001" not found in config` for every agent finding.
+ *
+ * Scan builds `service` as `${kind} (${target.name})` (or `plugin (${name})`),
+ * so the addressable target name is the trailing parenthesized group. When it
+ * cannot be recovered, fall back to the bare command, which diagnoses the first
+ * configured target — less specific, but never a copy-pasteable dead end.
+ */
+export function diagnoseCommandFor(finding: SummaryFinding): string {
+  if (/^PLUG-\d+$/i.test(finding.id)) {
+    return `crisismode diagnose ${finding.id}`;
+  }
+  const targetName = finding.service.match(/\(([^()]+)\)\s*$/)?.[1]?.trim();
+  return targetName ? `crisismode diagnose ${targetName}` : 'crisismode diagnose';
+}
+
 /**
  * Build an incident summary from scan results.
  */
@@ -104,7 +125,7 @@ function buildNextSteps(
 
   if (critical.length > 0) {
     const first = critical[0]!;
-    steps.push(`Investigate: \`crisismode diagnose ${first.id}\``);
+    steps.push(`Investigate: \`${diagnoseCommandFor(first)}\``);
     if (critical.length > 1) {
       steps.push(`${critical.length - 1} more unhealthy — diagnose each before attempting recovery`);
     }

From 2f0055c2ec10d4799f7a243468a38db3f6861bd8 Mon Sep 17 00:00:00 2001
From: trs-80 <109326+trs-80@users.noreply.github.com>
Date: Sun, 9 Aug 2026 12:00:25 -0400
Subject: [PATCH 03/17] docs: restructure for a cold reader and correct
 overstated coverage
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

README was 477 lines and doubled as a manual, while QUICKSTART (205) and
GETTING_STARTED (263) largely repeated it — three competing onboarding paths.

- README down to 258 lines; depth moved into docs/cli-reference.md and
  docs/coverage.md
- one home per audience: QUICKSTART = using the CLI, GETTING_STARTED =
  developing on it, CONTRIBUTING = contributing (its duplicated setup section
  now links out)

Corrected claims that contradicted the codebase:

- the agent table listed Redis, AWS, deploy-rollback, db-migration,
  queue-backlog and config-drift as "Live (execute-capable)" when their
  manifests say simulator_only — the README was overstating what the tool
  itself reports. Now uses the real two-label vocabulary and the verified
  9-of-26 live-validated count.
- both agent guides told readers to set plugin.maturity to "beta"/"stable";
  neither is a valid PluginMaturity
- playbook-authoring.md's flagship example failed validation until a missing
  capability id was added
- GETTING_STARTED claimed 19 agents against 26 actual

Every command and flag verified against a fresh build; no broken internal
links or anchors.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 CONTRIBUTING.md                               |  69 +--
 GETTING_STARTED.md                            | 335 ++++++-----
 QUICKSTART.md                                 | 274 +++++----
 README.md                                     | 530 +++++-------------
 docs/architecture.md                          |  87 ++-
 docs/cli-reference.md                         | 281 ++++++++++
 docs/coverage.md                              | 159 ++++++
 .../2026-08-09-docs-pass-report.md            | 192 +++++++
 docs/guides/creating-a-recovery-agent.md      |   2 +-
 docs/guides/your-first-agent.md               |   9 +-
 docs/playbook-authoring.md                    |   8 +
 11 files changed, 1267 insertions(+), 679 deletions(-)
 create mode 100644 docs/cli-reference.md
 create mode 100644 docs/coverage.md
 create mode 100644 docs/guide-verification/2026-08-09-docs-pass-report.md

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 18aea2e..3998924 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -22,42 +22,18 @@ Choose based on what you need and how much time you have:
 
 ## Development Setup
 
-### Prerequisites
-
-- Node.js >= 18
-- pnpm 10+ (the repo pins the exact version via `packageManager` in `package.json`)
-
-### Quick start
+Full setup — prerequisites, build, the podman test environment, failure
+injection, and the project layout — lives in
+**[GETTING_STARTED.md](GETTING_STARTED.md)**. The short version:
 
 ```bash
 git clone https://github.com/trs-80/crisismode.git
 cd crisismode
-pnpm install
-pnpm run build        # Compile to dist/ (also builds the agent-sdk workspace)
-pnpm run typecheck    # Verify types
-pnpm test             # Run unit tests
+pnpm install && pnpm run build
+pnpm run typecheck && pnpm test
+npx tsx src/cli/index.ts scan        # run the CLI from source
 ```
 
-### Running the CLI
-
-```bash
-npx tsx src/cli/index.ts scan        # Health scan
-npx tsx src/cli/index.ts demo        # Simulator demo
-npx tsx src/cli/index.ts diagnose    # AI-powered diagnosis
-```
-
-### Test environment
-
-For testing against real infrastructure:
-
-```bash
-./test/podman/scripts/start.sh       # Start PG, Prometheus, etc.
-./test/smoke/run-all.sh              # Validate the test environment
-pnpm run live                        # Dry-run against test PG
-```
-
-See [GETTING_STARTED.md](GETTING_STARTED.md) for full setup instructions.
-
 ## Your First Contribution
 
 ### Check plugin (simplest)
@@ -89,12 +65,36 @@ Agents are TypeScript modules that follow the 6-file pattern (`backend.ts`, `sim
 
 1. Build the simulator first -- it enables testing without real infrastructure
 2. Implement `assessHealth`, `diagnose`, `plan`, `replan`
-3. Register in `src/config/builtin-agents.ts`
-4. Add tests in `src/__tests__/`
-5. Submit a PR
+3. Declare `metadata.plugin.maturity` honestly (see below)
+4. Register in `src/config/builtin-agents.ts`
+5. Add tests in `src/__tests__/`
+6. Submit a PR
 
 See the [Your First Agent](docs/guides/your-first-agent.md) tutorial for a step-by-step walkthrough. The PostgreSQL agent at `src/agent/pg-replication/` is the canonical reference implementation.
 
+### Declaring maturity honestly
+
+Your manifest's `metadata.plugin.maturity` is a claim operators rely on during an
+incident, so it is the one field never to be optimistic about. Valid values are
+`experimental`, `simulator_only`, `dry_run_only`, `live_validated`, and
+`production_certified`.
+
+**A new agent is `simulator_only`.** That is not a placeholder to be upgraded when
+the code feels finished — CrisisMode's honesty layer
+(`src/framework/agent-maturity.ts`) treats everything except `live_validated` as
+best-effort and labels its findings as leads rather than conclusions in operator
+output. That default is the point.
+
+Only claim `live_validated` when the agent has actually been run against a real
+deployment of its target system, and say in the PR description what you ran it
+against. "The live client compiles" is not validation. If you validated diagnosis
+in dry-run but never executed a mutating plan, `dry_run_only` is the accurate
+label.
+
+Where each agent currently stands is tracked in
+[docs/coverage.md](docs/coverage.md) — update it in the same PR that changes a
+maturity value.
+
 ## Code Standards
 
 - **TypeScript strict mode** with ESM modules (`"type": "module"`)
@@ -243,8 +243,11 @@ When you open a pull request:
 
 ## Further Reading
 
+- [GETTING_STARTED.md](GETTING_STARTED.md) -- development setup, test environment, project layout
 - [Agent Development Guide](docs/guides/creating-a-recovery-agent.md) -- full agent contract, manifest reference, and safety checklist
 - [Check Plugin Reference](docs/guides/creating-a-check-plugin.md) -- wire protocol, Nagios/Goss/Sensu adapters
 - [Architecture Overview](docs/architecture.md) -- system architecture and key abstractions
+- [CLI Reference](docs/cli-reference.md) -- every command, flag, exit code, and output format
+- [Coverage & Validation Status](docs/coverage.md) -- what each agent has actually been validated against
 - [Recovery Agent Contract](specs/foundational/recovery-agent-contract.md) -- the authoritative specification
 - [Plugin Platform Guide](specs/architecture/plugin-platform.md) -- plugin taxonomy and platform architecture
diff --git a/GETTING_STARTED.md b/GETTING_STARTED.md
index 81c2110..86e0c2f 100644
--- a/GETTING_STARTED.md
+++ b/GETTING_STARTED.md
@@ -1,263 +1,260 @@
-# Getting Started
+# Getting Started (Development)
 
-This guide covers everything you need to start developing on CrisisMode — from first clone to running recovery agents against real infrastructure.
+Setting up a CrisisMode development environment — first clone through running
+agents against real degraded PostgreSQL.
+
+> **Just want to use the CLI?** That's [QUICKSTART.md](QUICKSTART.md) — install a
+> binary and scan your stack. This guide is about building and modifying
+> CrisisMode itself.
+>
+> **Ready to contribute?** [CONTRIBUTING.md](CONTRIBUTING.md) covers the
+> contribution tracks, code standards, and PR expectations.
 
 ## Prerequisites
 
-- **Node.js** >= 18 (recommended: use [fnm](https://github.com/Schniz/fnm) or [nvm](https://github.com/nvm-sh/nvm))
-- **pnpm** — `npm install -g pnpm`
-- **Podman** — for the containerized test environment. `brew install podman && podman machine init && podman machine start`
-- **Git** — with the repo cloned: `git clone git@github.com:trs-80/crisismode.git`
+- **Node.js** >= 22 (recommended: [fnm](https://github.com/Schniz/fnm) or
+  [nvm](https://github.com/nvm-sh/nvm)) — Node 18 and 20 are end-of-life; CI
+  tests 22 and 24
+- **pnpm** — `npm install -g pnpm`. The exact version is pinned via
+  `packageManager` in `package.json`
+- **Podman** — for the containerized test environment:
+  `brew install podman && podman machine init && podman machine start`
+- **Git** — `git clone git@github.com:trs-80/crisismode.git`
 
-### Optional
+Optional, but the pre-commit hooks want them:
 
-- **shellcheck** — `brew install shellcheck` (required by pre-commit hooks for `.sh` files)
-- **gitleaks** — `brew install gitleaks` (required by pre-commit hooks for secret scanning)
+- **shellcheck** — `brew install shellcheck` (lints staged `.sh` files)
+- **gitleaks** — `brew install gitleaks` (secret scanning)
 
-## First-time Setup
+## First-time setup
 
 ```bash
 cd crisismode
-pnpm install
+pnpm install          # also installs husky pre-commit hooks via `prepare`
+pnpm run build        # compiles to dist/, including the agent-sdk workspace
 ```
 
-This installs dependencies and sets up husky pre-commit hooks automatically (via the `prepare` script).
-
-Verify the hooks are working:
+Verify the toolchain:
 
 ```bash
-pnpm run typecheck    # TypeScript compilation check
+pnpm run typecheck    # tsc --noEmit
+pnpm test             # vitest unit tests
+pnpm run lint         # eslint
 ```
 
-## Running the Demo
-
-The demo runs entirely in-memory using simulators — no database or infrastructure required:
+Then run the in-memory demo — no database or infrastructure required:
 
 ```bash
 pnpm dev
 ```
 
-This walks through the full recovery pipeline for a PostgreSQL replication lag cascade: trigger → diagnosis → plan → validation → execution → forensic record.
+That walks the full recovery pipeline for a PostgreSQL replication lag cascade:
+trigger → diagnosis → plan → validation → execution → forensic record.
 
-## Setting Up the Test Environment
-
-The test environment gives you real PostgreSQL with streaming replication, Prometheus, AlertManager, and a mock hub API.
-
-### Start the stack
+To run the CLI from source without building:
 
 ```bash
-./test/podman/scripts/start.sh
+npx tsx src/cli/index.ts scan
+npx tsx src/cli/index.ts agent list
 ```
 
-This pulls container images and starts:
-- **PostgreSQL primary** on `localhost:5432` (user: `crisismode`, password: `crisismode`)
-- **PostgreSQL replica** on `localhost:5433` (streaming replication from primary)
-- **Prometheus** on `http://localhost:9090` (scraping PG metrics)
-- **AlertManager** on `http://localhost:9093` (configured to webhook to `localhost:3000`)
-- **postgres_exporter** on `http://localhost:9187`
-- **Mock Hub API** on `http://localhost:8080`
+## The test environment
 
-### Validate
+Real PostgreSQL with streaming replication, Prometheus, AlertManager, and a mock
+hub API.
 
 ```bash
-./test/smoke/run-all.sh                # 16 checks: services, replication, metrics, hub API
-./test/smoke/test-failure-injection.sh  # 6 checks: inject failures, verify, reset
+./test/podman/scripts/start.sh     # start
+./test/podman/scripts/status.sh    # check
+./test/podman/scripts/stop.sh      # tear down
 ```
 
-### Inject failures
+`start.sh` pulls images and brings up:
+
+| Service | Where | Notes |
+|---|---|---|
+| PostgreSQL primary | `localhost:5432` | user `crisismode`, password `crisismode` |
+| PostgreSQL replica | `localhost:5433` | streaming replication from primary |
+| Prometheus | `http://localhost:9090` | scraping PG metrics |
+| AlertManager | `http://localhost:9093` | webhooks to `localhost:3000` |
+| postgres_exporter | `http://localhost:9187` | |
+| Mock Hub API | `http://localhost:8080` | |
 
-These scripts create real degraded states in the test PostgreSQL:
+Validate it came up correctly:
 
 ```bash
-./test/failures/inject-replication-lag.sh     # Pause WAL replay → growing lag
-./test/failures/inject-connection-flood.sh    # Open 200 idle connections
-./test/failures/inject-long-queries.sh        # Hold row locks + expensive scans
-./test/failures/inject-slot-overflow.sh       # Abandoned slot accumulating WAL
-./test/failures/reset.sh                      # Restore everything to healthy
+./test/smoke/run-all.sh                 # services, replication, metrics, hub API
+./test/smoke/test-failure-injection.sh   # inject, verify, reset round-trip
+./test/smoke/test-alert-pipeline.sh      # AlertManager → spoke webhook path
 ```
 
-### Run the spoke against real PostgreSQL
+Each script prints a `passed/total` tally at the end.
 
-```bash
-# Dry-run: reads from real PG, logs mutations
-pnpm run live
+### Injecting real failures
 
-# With lag injected first:
-./test/failures/inject-replication-lag.sh
-pnpm run live
+These create genuinely degraded states in the test PostgreSQL — not mocks:
 
-# Execute mode: actually runs SQL mutations
-pnpm run live -- --execute
+```bash
+./test/failures/inject-replication-lag.sh      # pause WAL replay → growing lag
+./test/failures/inject-connection-flood.sh     # 200 idle connections
+./test/failures/inject-long-queries.sh         # hold row locks + expensive scans
+./test/failures/inject-slot-overflow.sh        # abandoned slot accumulating WAL
+./test/failures/inject-pgvector-unindexed.sh   # vector column with no ANN index
+./test/failures/reset.sh                       # restore everything to healthy
+./test/failures/reset-pgvector.sh              # undo just the pgvector injection
 ```
 
-### Run the webhook receiver
+### Running against real PostgreSQL
 
 ```bash
-pnpm run webhook                # dry-run, listens on :3000
-pnpm run webhook --execute      # execute mode
+pnpm run live                    # dry-run: reads real PG, logs mutations
+pnpm run live -- --execute       # execute mode: runs real SQL mutations
 
-# Then inject lag — AlertManager will fire an alert to the spoke
-./test/failures/inject-replication-lag.sh
+# A useful loop:
+./test/failures/inject-replication-lag.sh && pnpm run live
 ```
 
-### Tear down
+### Webhook receiver
 
 ```bash
-./test/podman/scripts/stop.sh
+pnpm run webhook                 # dry-run, listens on :3000
+pnpm run webhook --execute       # execute mode
+
+# Inject lag; AlertManager fires an alert at the spoke
+./test/failures/inject-replication-lag.sh
 ```
 
-## Project Layout
+## Project layout
 
 ### CLI (`src/cli/`)
 
-The unified `crisismode` CLI provides commands: `scan` (default), `diagnose`, `recover`, `status`, `ask`, `demo`, `init`, `webhook`, `watch`, `readiness`, plus subcommand groups `bundle` (ingest/respond/execute for SRE evidence bundles), `playbook` (list/validate/dry-run), `agent` (list/info), `registry` (list/search/install), and `mcp` (stdio MCP server) and `completions` (shell completions). Running `crisismode` with no arguments performs a zero-config health scan. Supporting modules handle system detection (`detect.ts`), zero-config agent discovery (`autodiscovery.ts`), structured output (`output.ts`), and error formatting (`errors.ts`); escalation levels live in `src/framework/escalation.ts`. See the [README CLI reference](README.md#cli-reference) for the full command list.
+`src/cli/index.ts` is the entry point. Commands live in `src/cli/commands/`.
+Supporting modules: `detect.ts` (port probing), `autodiscovery.ts` (zero-config
+agent detection), `output.ts` (structured output), `errors.ts` (error
+formatting), `status-presentation.ts` (single source for status → presentation
+mappings), `visibility.ts` (coverage and maturity reporting).
 
-### Core Framework (`src/framework/`)
+Full command surface: [docs/cli-reference.md](docs/cli-reference.md).
+
+### Framework (`src/framework/`)
 
 | File | Purpose |
 |---|---|
-| `engine.ts` | Executes recovery plans step-by-step. Handles dry-run vs execute mode. |
-| `graph-engine.ts` | LangGraph-based graph execution engine for complex workflows |
-| `backend.ts` | ExecutionBackend contract — shared interface for all execution backends |
-| `safety.ts` | State capture, blast radius validation |
-| `coordinator.ts` | Human approval logic (auto-approve decisions based on trust + catalog) |
-| `validator.ts` | Validates plans against agent manifests |
+| `engine.ts` | `LegacyExecutionEngine` — sequential step execution, dry-run vs execute |
+| `graph-engine.ts` | `RecoveryGraphEngine` — LangGraph-based, supports checkpoint/resume |
+| `backend.ts` | `ExecutionBackend` contract shared by all backends |
+| `safety.ts` | State capture, blast-radius validation |
+| `validator.ts` | Validates plans against agent manifests and safety rules |
+| `coordinator.ts` | Human approval logic (trust + catalog driven) |
 | `catalog.ts` | Pre-authorized action catalog matching |
 | `forensics.ts` | Forensic record assembly and persistence |
-| `hub-client.ts` | Spoke ↔ hub communication (bootstrap, heartbeat, forensics, policies) |
-| `capability-registry.ts` | Global registry of standard recovery capabilities |
+| `escalation.ts` | The five-level progressive escalation model |
+| `agent-maturity.ts` | Collapses manifest maturity to the two labels operators see |
+| `capability-registry.ts` | Registry of standard recovery capabilities |
 | `provider-registry.ts` | Resolves capability providers for plan steps |
-| `operator-summary.ts` | Builds operator-facing health and readiness summaries |
-| `symptom-router.ts` | Routes symptoms to appropriate recovery agents |
+| `symptom-router.ts` | Routes symptoms to the appropriate agent |
+| `root-cause-synthesis.ts` | Correlation clustering (the rule set is frozen — see CONTRIBUTING) |
 | `ai-diagnosis-universal.ts` | Universal AI-powered diagnosis for any agent |
+| `operator-summary.ts` | Operator-facing health and readiness summaries |
 | `incident-report.ts` | Structured incident report generation |
 | `network-profile.ts` | Network diagnostics and profiling |
-| `index.ts` | Barrel export for all framework modules |
+| `triage.ts` / `triage-probes.ts` | Offline layered localization and verdict synthesis |
+| `service-status/` | Third-party status checker — status page + reachability, never conflated |
+| `guidance/` | Static `RemediationGuide` registry for console-only fixes |
+| `hooks/` | 9-point lifecycle hook system |
+| `playbook/` | Markdown playbook parser, runtime, discovery |
+| `registry/` | Agent plugin discovery and manifest handling |
+| `hub-client.ts` | Spoke ↔ hub communication |
+
+`src/readiness/` holds the scale-readiness rule registry and capacity ceilings —
+see [docs/readiness.md](docs/readiness.md).
 
 ### Agents (`src/agent/`)
 
-Each agent follows the same pattern:
+Every agent follows the same six-file pattern:
 
 ```
-agent/
-  <system>/
-    backend.ts        # Interface that both simulator and live client implement
-    simulator.ts      # In-memory implementation for demos and tests
-    live-client.ts    # Real infrastructure client (connects to actual systems)
-    manifest.ts       # Agent manifest (capabilities, risk profile, triggers)
-    agent.ts          # RecoveryAgent implementation (diagnose, plan, replan)
-    registration.ts   # Lazy factory for the agent registry
+src/agent/<system>/
+  backend.ts        # Interface both simulator and live client implement
+  simulator.ts      # In-memory implementation for demos and tests
+  live-client.ts    # Real infrastructure client
+  manifest.ts       # Capabilities, risk profile, triggers, maturity
+  agent.ts          # RecoveryAgent implementation
+  registration.ts   # Lazy factory for the agent registry
 ```
 
-**PostgreSQL Replication** (`pg-replication/`) — the MVP agent. Has a full live client that queries real `pg_stat_replication`.
-
-**Redis Memory** (`redis/`) — cache recovery agent. Live client complete; execute-verified via the torture harness.
-
-**etcd Recovery** (`etcd/`) — consensus cluster recovery. Handles leader election loops, NOSPACE alarms, member failures. Simulator complete.
-
-**Kafka Recovery** (`kafka/`) — broker recovery agent. Handles under-replicated partitions, leader imbalance, consumer lag cascades. Simulator complete.
-
-**Kubernetes Recovery** (`kubernetes/`) — cluster recovery agent. Handles node failures, pod crash loops, stuck deployments, PVC issues. Live client complete.
-
-**Ceph Storage** (`ceph/`) — distributed storage recovery. Handles OSD failures, degraded placement groups, pool near-full conditions. Simulator complete.
-
-**Flink Stream Processing** (`flink/`) — stream job recovery. Handles checkpoint failure cascades, savepoint corruption, backpressure. Simulator complete.
-
-**AI Provider** (`ai-provider/`) — AI service failover and fallback. Handles provider failover routing, rate limit management. Live client complete.
-
-**Config Drift** (`config-drift/`) — configuration drift detection and remediation. Handles drift detection, compliance enforcement. Live client complete; diagnosis validated in dry-run via the torture harness.
-
-**DB Migration** (`db-migration/`) — database migration safety. Handles migration safety checks, rollback orchestration. Live client complete; diagnosis validated in dry-run via the torture harness.
-
-**Deploy Rollback** (`deploy-rollback/`) — deployment rollback orchestration (Vercel, requires `VERCEL_TOKEN`). Handles rollback coordination, canary failure response. Live client complete.
+`src/config/builtin-agents.ts` is the authoritative roster. For the live list
+with maturity labels, ask the CLI:
 
-**Queue Backlog** (`queue-backlog/`) — queue backlog and lag recovery. Handles backlog reduction, consumer lag recovery. Live client complete; diagnosis validated in dry-run via the torture harness.
-
-**AWS S3 / DynamoDB / RDS** (`aws-s3/`, `aws-dynamodb/`, `aws-rds/`) — AWS backup verification and recovery (bucket versioning/lifecycle, PITR status, backup retention and snapshot recency). Live clients validated in dry-run against real AWS.
-
-**DNS** (`dns/`) — DNS resolution failure recovery. Live diagnosis plus local cache flush.
-
-**TLS** (`tls/`) — certificate expiry and chain health. Live diagnosis only.
-
-**Disk** (`disk/`) — local disk exhaustion detection. Live diagnosis only.
+```bash
+crisismode agent list      # 26 registrations
+crisismode agent info postgresql-replication-recovery
+```
 
-**Backup Verification** (`backup/`) — backup verification and DR readiness across pluggable providers (filesystem, `aws_s3`, `aws_rds`). Live diagnosis only.
+**Do not duplicate that roster in prose.** Which agents are validated versus
+best-effort is tracked in one place: [docs/coverage.md](docs/coverage.md).
+`src/agent/pg-replication/` is the reference implementation — read it first.
 
-See `src/config/builtin-agents.ts` for the authoritative roster (19 agents) and the README status tables for what is execute-verified versus dry-run validated.
+### Types (`src/types/`)
 
-### Type System (`src/types/`)
+Public types are defined in `packages/agent-sdk` (zero runtime dependencies) and
+re-exported from `src/types/index.ts`. Key ones:
 
-All contract types are defined here. Key types:
-- `RecoveryPlan` — the plan structure with steps, impact analysis, rollback strategy
-- `RecoveryStep` — 7 step types (system_action, diagnosis_action, human_notification, human_approval, checkpoint, replanning_checkpoint, conditional)
-- `AgentManifest` — agent capabilities declaration
+- `RecoveryPlan` — steps, impact analysis, rollback strategy
+- `RecoveryStep` — the 7 step types
+- `AgentManifest` — capability and risk declaration, including `plugin.maturity`
 - `ForensicRecord` — immutable audit trail
 - `AgentContext` — trigger, topology, trust levels, policies
-- `HealthAssessment` / `OperatorSummary` — health assessment and operator-facing readiness types
-- `PluginKind` / `CapabilityProviderDescriptor` — plugin ecosystem types for capability providers
-
-## Building a New Agent
-
-1. Create `src/agent/<system>/backend.ts` — define the interface for querying your target system
-2. Create `src/agent/<system>/simulator.ts` — implement the interface with canned data
-3. Create `src/agent/<system>/manifest.ts` — declare what your agent targets and its risk profile
-4. Create `src/agent/<system>/agent.ts` — implement `RecoveryAgent` (diagnose, plan, replan)
-5. Create `src/agent/<system>/registration.ts` — lazy factory for the agent registry
-6. Register your agent in `src/config/builtin-agents.ts` via the agent registry (`src/config/agent-registry.ts`)
-7. Add capabilities to `src/framework/capability-registry.ts` if your agent uses new capability domains
-
-The framework handles validation, approval workflows, forensic recording, and hub communication — your agent only needs to diagnose and produce plans.
-
-## Commit Conventions
-
-This repo uses [Conventional Commits](https://www.conventionalcommits.org/):
-
-```
-type(scope): description
-
-feat(agent): add Redis memory pressure recovery
-fix: correct replication lag threshold check
-docs: update README with webhook instructions
-chore: update dependencies
-test: add failure injection round-trip tests
-```
-
-Allowed types: `feat`, `fix`, `docs`, `style`, `refactor`, `test`, `chore`, `ci`, `perf`, `build`
-
-The commit-msg hook enforces this format.
-
-## Pre-commit Hooks
+- `HealthAssessment` / `OperatorSummary` — health and operator-facing readiness
+- `PluginKind` / `PluginMaturity` / `CapabilityProviderDescriptor` — plugin types
 
-All hooks run automatically on `git commit`. To bypass (e.g., for WIP commits):
+## Pre-commit hooks
 
-```bash
-git commit --no-verify -m "wip: work in progress"
-```
+All hooks run on `git commit`. Bypass with `--no-verify` only for genuine WIP.
 
-| Hook | What it checks |
+| Hook | Checks |
 |---|---|
 | TypeScript typecheck | `tsc --noEmit` on staged `.ts` files |
-| gitleaks | Secret detection (API keys, tokens, passwords) |
+| gitleaks | Secrets (API keys, tokens, passwords) |
 | Sensitive files | Blocks `.pem`, `.key`, `.p12`, `.env`, `kubeconfig`, `tfstate` |
-| shellcheck | Lints staged `.sh` files |
+| shellcheck | Staged `.sh` files |
 | Large files | Blocks files >1MB |
-| Conflict markers | Catches leftover `<<<<<<<` / `>>>>>>>` |
-| Conventional commits | Enforces commit message format |
+| Conflict markers | Leftover `<<<<<<<` / `>>>>>>>` |
+| Conventional commits | Commit message format |
+
+Commit messages follow [Conventional Commits](https://www.conventionalcommits.org/):
+`type(scope): description`, where type is one of `feat`, `fix`, `docs`, `style`,
+`refactor`, `test`, `chore`, `ci`, `perf`, `build`.
 
-## Useful Commands
+## Command reference
 
 ```bash
 pnpm dev                              # Demo mode (simulated)
 pnpm run live                         # Live mode against test PG (dry-run)
 pnpm run live -- --execute            # Live mode with mutations
 pnpm run webhook                      # Start webhook receiver
-pnpm test                             # Run unit tests (vitest)
-pnpm run test:watch                   # Run tests in watch mode
+pnpm test                             # Unit tests (vitest)
+pnpm run test:watch                   # Tests in watch mode
+pnpm run test:coverage                # Tests with coverage
+pnpm run test:cli                     # CLI smoke test
 pnpm run typecheck                    # TypeScript check
+pnpm run lint                         # ESLint  (lint:fix to autofix)
 pnpm run build                        # Compile to dist/
-./test/podman/scripts/start.sh        # Start test environment
-./test/podman/scripts/status.sh       # Check test environment status
-./test/smoke/run-all.sh               # Run smoke tests
-./test/failures/inject-replication-lag.sh  # Inject test failure
-./test/failures/reset.sh              # Reset to healthy
+pnpm run build:bundle                 # esbuild single-file bundle
+pnpm run build:binary                 # Standalone binary
+pnpm run eval:diagnosis               # Diagnosis eval, writes eval/reports/
+pnpm run eval:diagnosis:gate          # Fails below the 13/14 score gate
+pnpm run guides:walkthrough           # Generate a remediation-guide checklist
+pnpm run guides:apply <checklist>     # Stamp verifiedOn for verified guides
 ```
+
+Lint-time TypeScript is pinned to 6.0.2 via `.pnpmfile.cjs` because
+typescript-eslint does not yet support the TS 7 native compiler; `tsc` itself
+stays on TS 7.
+
+## Next steps
+
+- [CONTRIBUTING.md](CONTRIBUTING.md) — contribution tracks, code standards, PR expectations
+- [docs/architecture.md](docs/architecture.md) — layers, engines, safety, plugin model
+- [Your First Agent](docs/guides/your-first-agent.md) — build an agent start to finish
+- [specs/foundational/recovery-agent-contract.md](specs/foundational/recovery-agent-contract.md) — the authoritative contract
diff --git a/QUICKSTART.md b/QUICKSTART.md
index 577289b..e2797fc 100644
--- a/QUICKSTART.md
+++ b/QUICKSTART.md
@@ -1,110 +1,170 @@
 # Quick Start
 
-Get CrisisMode running in under 5 minutes. No configuration required.
+Running CrisisMode against your own stack, from nothing to a useful answer. No
+configuration required to start.
 
-> **Fastest path:** prebuilt binaries (no Node.js required) are on
-> [GitHub Releases](https://github.com/trs-80/crisismode/releases/latest) —
-> see the [README install section](README.md#install). This guide covers
-> running from source, which you'll want for development.
-
-## Prerequisites
-
-- **Node.js** >= 18
-- **pnpm** — `npm install -g pnpm`
+> **Want to build or modify CrisisMode instead?** That's
+> [GETTING_STARTED.md](GETTING_STARTED.md) — clone, build, test environment,
+> project layout. This guide is about *using* the CLI.
 
 ## Install
 
+Grab a prebuilt binary — no Node.js needed:
+
 ```bash
-git clone https://github.com/trs-80/crisismode.git
-cd crisismode
-pnpm install
-pnpm run build
+# macOS (Apple Silicon); see README for other platforms
+curl -fsSL https://github.com/trs-80/crisismode/releases/latest/download/crisismode-darwin-arm64 -o crisismode
+chmod +x crisismode
 ```
 
-## Run your first scan
-
-CrisisMode auto-detects services on your machine and checks what it finds:
+Put it on your `PATH`, then optionally enable tab completion:
 
 ```bash
-node dist/cli/index.js scan
+crisismode completions zsh    # or bash, fish
 ```
 
-No config file needed. The scan:
-- Probes common ports for databases, caches, and message brokers
-- Runs bundled check plugins (disk, memory, DNS, HTTP, TLS certificates)
-- Scores overall system health 0–100
-- Suggests a next command for anything it finds
+Running from a source checkout instead? Use `node dist/cli/index.js` in place of
+`crisismode` after `pnpm install && pnpm run build`.
 
-Example output:
+## Your first scan
 
+CrisisMode auto-detects services on the machine and checks whatever it finds:
+
+```bash
+crisismode
 ```
-  System Health Score: 83/100
-  Scanned at 2026-03-18T16:47:28.181Z (52ms)
 
-  ID            Service             Status        Level     Summary
-  --------------------------------------------------------------------------------
-  PLUG-001      plugin (check-certificate-expiry)UNKNOWN       Diagnose  Could not connect to localhost:443
-  PLUG-002      plugin (check-disk-usage)OK            Observe   Disk usage normal, max 45%
-  PLUG-003      plugin (check-dns-resolution)OK            Observe   DNS resolution healthy
-  PLUG-004      plugin (check-http-endpoint)UNKNOWN       Diagnose  Endpoint unreachable
-  PLUG-005      plugin (check-memory-usage)OK            Observe   Memory usage normal at 53%
+`scan` is the default command, so bare `crisismode` and `crisismode scan` do the
+same thing.
 
-  → Run `crisismode diagnose PLUG-001` to investigate plugin (check-certificate-expiry)
 ```
+  Scanning for services...
+  Detected services:
+    ✓ postgresql at localhost:5432
+    ✓ dns at localhost:53
+
+  Running health checks on 7 target(s)...
+
+  System Health Score: 100/100
+  Scanned at 2026-08-09T15:09:00.480Z (586ms)
+
+  HEALTHY
+  PG-001      OK postgresql (default-postgres) — PostgreSQL replication is healthy.
+                 All replicas are streaming and worst replay lag is 0s.
+  DNS-002     OK dns (local-dns) — DNS resolution is healthy. All configured
+                 resolvers are reachable and returning consistent answers.
+  DISK-003    OK disk (local-disk) — Disk usage is healthy. All filesystems have
+                 sufficient free space and inodes.
+```
+
+No config file needed. The scan:
+
+- TCP-probes common ports for databases, caches, and brokers
+- Picks up LLM providers from environment variables (`ANTHROPIC_API_KEY`,
+  `OPENAI_API_KEY`, `GEMINI_API_KEY`, `OPENROUTER_API_KEY`)
+- Scores overall health 0–100
+- Suggests a next command for anything it flags
+
+Findings from best-effort agents are labelled as such in the output — they're
+leads, not conclusions. [docs/coverage.md](docs/coverage.md) explains which is
+which and why.
+
+### What gets detected without config
+
+These ports are probed by default:
+
+| Service | Port |
+|---|---|
+| PostgreSQL | 5432 |
+| Redis | 6379 |
+| etcd | 2379 |
+| Kafka | 9092 |
+| Kubernetes | 6443 |
+| Ceph | 6789 |
+| Flink | 8081 |
+| DNS | 53 |
+| RabbitMQ / AMQP | 5672 |
+
+Check plugins are discovered from `~/.crisismode/checks/`, `./checks/`, or
+`$CRISISMODE_CHECK_PATH`. The prebuilt binary ships none — the example plugins
+(disk usage, memory, DNS resolution, HTTP endpoint, certificate expiry, plus
+Nagios/Goss/Sensu adapter samples) live in `checks/` in a repo checkout, so
+you'll see them when running from source or after copying them into
+`~/.crisismode/checks/`.
 
 ## Drill into a finding
 
-The scan tells you what to run next. Copy the suggested command:
+Scan findings are labelled by target — `PG-001` above is the PostgreSQL target
+`default-postgres`. To investigate one, pass the **target name**:
 
 ```bash
-node dist/cli/index.js diagnose PLUG-002
+crisismode diagnose default-postgres
+# equivalently
+crisismode diagnose --target default-postgres
 ```
 
-For check plugins this runs the plugin's diagnose verb — a deeper inspection that lists individual findings with severity levels:
+> Note: `diagnose` resolves its positional argument as a *target name*, not a
+> finding id, so `crisismode diagnose PG-001` returns
+> `Target "PG-001" not found in config` followed by the names you can use.
+> Check-plugin findings are the exception — `PLUG-<n>` ids are routed straight to
+> the plugin's diagnose verb, so `crisismode diagnose PLUG-002` works as written.
+> Scan's own "Investigate:" suggestion accounts for both.
 
-```
-  Plugin: check-disk-usage
+For infrastructure agents this connects to the live service and runs AI-powered
+analysis when `ANTHROPIC_API_KEY` is set, falling back to rule-based diagnosis
+otherwise:
 
-  ✓ Healthy: All partitions below 70% usage
+```bash
+export ANTHROPIC_API_KEY=sk-ant-...
+crisismode diagnose --target default-postgres
 ```
 
-For infrastructure agents (PostgreSQL, Redis, etcd, etc.), diagnose connects to the live service and runs AI-powered analysis if you have an `ANTHROPIC_API_KEY` set:
+`diagnose` is read-only. It never mutates anything.
+
+## Three questions before you touch anything
+
+These are the commands worth reaching for first during an actual incident,
+because all three are read-only and fast.
+
+**Is it me, my network, or them?**
 
 ```bash
-export ANTHROPIC_API_KEY=sk-ant-...
-node dist/cli/index.js diagnose --target my-postgres
+crisismode triage
 ```
 
-## What services can CrisisMode detect?
+Works offline. Walks outward from local interfaces → gateway → DNS → captive
+portal → internet → your configured targets, and tells you which layer broke.
+Exits 1 when the cause is local, network, or mixed — so it works in a script.
+
+**Is it down for everyone, or just me?**
 
-Without any configuration, `scan` probes these ports:
+```bash
+crisismode down stripe github
+```
+
+Keeps two facts separate: what the provider's status page says, and whether this
+machine can actually reach it. A status-page hiccup is never reported as an
+outage. Exits 1 if anything looks down.
 
-| Service      | Port  |
-|-------------|-------|
-| PostgreSQL   | 5432  |
-| Redis        | 6379  |
-| etcd         | 2379  |
-| Kafka        | 9092  |
+**Will this break under load?**
 
-It also runs these bundled check plugins automatically:
+```bash
+crisismode readiness
+```
 
-| Plugin                    | What it checks                          |
-|--------------------------|----------------------------------------|
-| check-disk-usage          | Filesystem usage (warns at 80%, critical at 90%) |
-| check-memory-usage        | System memory utilization               |
-| check-dns-resolution      | DNS resolver health                     |
-| check-http-endpoint       | HTTP connectivity to localhost           |
-| check-certificate-expiry  | TLS certificate validity on localhost:443 |
+Forward-looking and read-only: connection headroom, pooling, missing indexes,
+slow queries, pgvector index health, plus honest capacity ceilings. It reports
+`unknown` rather than guessing — see [docs/readiness.md](docs/readiness.md).
 
-## Add a config file (optional)
+## Add a config file
 
-For non-default ports or remote hosts, generate a config:
+For non-default ports, remote hosts, or credentials:
 
 ```bash
-node dist/cli/index.js init
+crisismode init
 ```
 
-This creates `crisismode.yaml`. Edit it to point at your infrastructure:
+That writes `crisismode.yaml`. Point it at your infrastructure:
 
 ```yaml
 apiVersion: crisismode/v1
@@ -127,27 +187,37 @@ targets:
       passwordVar: PG_PASSWORD
 ```
 
-### AWS targets
+Credentials are always read from environment variables or K8s Secrets at runtime
+— never stored in the config file.
+
+### Third-party services
 
-CrisisMode can verify backups stored in AWS services. Add an `aws` block with service-specific fields:
+A `services:` list works on its own, with no `targets:` block. Bare
+`crisismode down` then checks all of them:
+
+```yaml
+services:
+  - stripe
+  - github
+  - example.com        # raw domain — reachability only, no known status page
+```
+
+### AWS targets
 
 ```yaml
 targets:
-  # S3 backup bucket
   - name: s3-backups
     kind: aws-s3
     aws:
       bucket: my-backup-bucket
       region: us-east-1
 
-  # DynamoDB table (point-in-time recovery check)
   - name: orders-table
     kind: aws-dynamodb
     aws:
       table: orders
       region: us-east-1
 
-  # RDS instance (automated backup / snapshot check)
   - name: prod-rds
     kind: aws-rds
     aws:
@@ -155,51 +225,59 @@ targets:
       region: us-east-1
 ```
 
-AWS credentials are resolved via the standard SDK chain (environment variables, `~/.aws/credentials`, IAM roles, IRSA).
+Credentials resolve through the standard AWS SDK chain — environment variables,
+`~/.aws/credentials`, IAM roles, IRSA. The AWS agents are best-effort: diagnosis
+has been validated in dry-run against real AWS, but no execute path has been
+verified.
+
+Then `crisismode scan` picks the config up automatically.
 
-Then scan picks it up automatically:
+## Recovery
 
 ```bash
-node dist/cli/index.js scan
+crisismode recover              # dry-run: reads live systems, plans, executes nothing
+crisismode recover --execute    # actually runs recovery actions
 ```
 
-## Recovery (dry-run by default)
+Dry-run is the default and you always see the plan first. Before trusting
+`--execute` against anything you care about, read
+[docs/coverage.md](docs/coverage.md) — end-to-end mutating recovery is verified
+for exactly three scenarios today, and everything else should be treated as
+experimental.
 
-When scan finds an unhealthy service, step through the full recovery flow:
+To watch the whole pipeline safely, run the simulator:
 
 ```bash
-# Dry-run — reads from live systems, plans recovery, but does not execute
-node dist/cli/index.js recover
-
-# Execute mode — actually runs recovery actions
-node dist/cli/index.js recover --execute
+crisismode demo
 ```
 
-Dry-run is the default. You always see the plan before anything is executed.
-
-## Demo mode
+That walks a PostgreSQL replication lag cascade from trigger through diagnosis,
+plan, validation, execution, and forensic record — entirely in memory.
 
-See the full recovery pipeline with simulated data — no infrastructure needed:
+## Output for scripts and pipelines
 
 ```bash
-node dist/cli/index.js demo
+crisismode scan --json          # JSON Lines, one object per line
+crisismode scan | cat           # plain tab-separated (auto-detected when piped)
+crisismode scan --terse         # drop the plain-language explanations
 ```
 
-Walks through a PostgreSQL replication lag cascade: trigger → diagnosis → plan → validation → execution → forensic record.
-
-## Output modes
-
 ```bash
-# Machine-readable JSON (pipe to jq, scripts, dashboards)
-node dist/cli/index.js scan --json
-
-# Disable color (auto-detected when piping)
-node dist/cli/index.js scan | cat
+crisismode readiness --json | jq 'select(.type == "readiness") | .verdict'
 ```
 
-## What's next
-
-- `node dist/cli/index.js ask "why is my database slow"` — natural language diagnosis
-- `node dist/cli/index.js watch` — continuous health monitoring
-- `node dist/cli/index.js webhook` — receive alerts from Prometheus AlertManager
-- See [GETTING_STARTED.md](GETTING_STARTED.md) for the full development setup
+Field-by-field format contracts are in
+[docs/cli-reference.md](docs/cli-reference.md#output-modes).
+
+## Where to go next
+
+| Goal | Go to |
+|---|---|
+| Look up any command, flag, or exit code | [docs/cli-reference.md](docs/cli-reference.md) |
+| Know what's actually been validated | [docs/coverage.md](docs/coverage.md) |
+| Let Claude or another AI client drive it | [MCP server](docs/cli-reference.md#mcp-server) |
+| Receive Prometheus AlertManager alerts | `crisismode webhook` |
+| Monitor continuously | `crisismode watch` |
+| Ask in plain English | `crisismode ask "why is my database slow"` |
+| Write a recovery procedure | [Playbook Authoring](docs/playbook-authoring.md) |
+| Build or modify CrisisMode | [GETTING_STARTED.md](GETTING_STARTED.md) |
diff --git a/README.md b/README.md
index 3d40998..c9169c9 100644
--- a/README.md
+++ b/README.md
@@ -4,75 +4,33 @@
 [![codecov](https://codecov.io/gh/trs-80/crisismode/graph/badge.svg)](https://codecov.io/gh/trs-80/crisismode)
 [![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 [![TypeScript](https://img.shields.io/badge/TypeScript-strict-blue?logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
-[![Node](https://img.shields.io/badge/Node-%3E%3D18-green?logo=node.js&logoColor=white)](https://nodejs.org/)
+[![Node](https://img.shields.io/badge/Node-%3E%3D22-green?logo=node.js&logoColor=white)](https://nodejs.org/)
 
-CrisisMode is the recovery layer for your infrastructure. Monitoring tells you something is wrong. CrisisMode tells you what to do about it — safely.
+**Monitoring tells you something is wrong. CrisisMode tells you what to do about it — safely.**
 
-It diagnoses issues using AI, builds validated recovery plans with blast-radius controls, and executes them with human-in-the-loop oversight. Every action is preceded by a state capture. Every execution produces an immutable forensic record. Domain experts contribute recovery knowledge as agents and check plugins — the framework ensures that knowledge is applied safely when infrastructure is degraded and the cost of wrong actions is highest.
+CrisisMode diagnoses infrastructure failures, builds validated recovery plans with
+blast-radius controls, and executes them under human-in-the-loop oversight. Every
+mutation is preceded by a state capture. Every execution leaves an immutable
+forensic record.
 
-**Website:** [crisismode.ai](https://crisismode.ai)
-
-## Who This Is For
-
-- SREs and platform engineers who get paged and need to act under pressure.
-- AI app builders operating managed infrastructure with limited ops depth.
-- On-call engineers who inherit systems they didn't build.
-- Domain experts (database specialists, Kafka engineers, storage admins) who want to codify recovery knowledge.
-
-## From Alert to Recovery
-
-Live mode diagnosing real PostgreSQL replication lag (local podman test
-environment; the excerpt shows a single elevated-risk step executing — see
-[Validation status](#validation-status) for what is and isn't verified today):
-
-```
-  Connecting to PostgreSQL...
-  ✅ Primary connected — 3 active connections
-  ✅ Replication: 1 replica(s) streaming
-  ✅ Replica connected — recovery mode: true, lag: 636s
-
-  ── Live Replication Status ──
-  🔴 10.89.0.5/32 | streaming | lag: 41s | sent: 0/63704F0 | replay: 0/5EDE5F8
+It is built for the moment when infrastructure is degraded and the cost of a wrong
+action is highest — which is also why it reports what it *hasn't* verified. See
+[Maturity and validation](#maturity-and-validation).
 
-  Phase 3: Diagnosis (Live — AI-Powered)
-  ──────────────────────────────────────
-  🤖 AI analyzing system state...
-     Status:      identified
-     Scenario:    replication_lag_cascade
-     Confidence:  94%
-     Root cause:  WAL replay paused on replica — sent LSN is advancing
-                  but replay LSN is static, indicating a deliberate pause
-                  or I/O bottleneck on the replica, not a network issue.
-
-  Phase 4: Plan Creation
-  ──────────────────────
-     #   Type                    Risk        Name
-     ────────────────────────────────────────────────────────────
-     1   diagnosis_action        —           Assess replication lag
-     2   human_notification      —           Notify on-call DBA
-     3   checkpoint              —           Pre-recovery state capture
-     4   system_action           elevated    Disconnect lagging replica
-     5   system_action           routine     Redirect read traffic
-     6   replanning_checkpoint   —           Assess progress
-     7   human_approval          —           Approve resynchronization
-     8   system_action           high        pg_basebackup + resync
-     9   conditional             —           Restore traffic or notify
-     10  human_notification      —           Recovery summary
+**Website:** [crisismode.ai](https://crisismode.ai)
 
-  Phase 7: Execution (Live — EXECUTE MODE)
-  ─────────────────────────────────────────
-  🔴 EXECUTE MODE — SQL mutations WILL be run against real PostgreSQL.
+## Who it's for
 
-     Step step-004 [system_action]
-     Disconnect lagging replica 10.89.0.5/32 from replication
-     ✓ Precondition: Replica 10.89.0.5/32 is currently connected
-     ✓ Success: WAL sender for 10.89.0.5/32 is no longer present
-     ● SUCCESS (6ms)
-```
+- **SREs and platform engineers** who get paged and need to act under pressure.
+- **AI app builders** running managed infrastructure without deep ops backup.
+- **On-call engineers** who inherit systems they didn't build.
+- **Domain experts** — DBAs, Kafka and storage specialists — who want to codify
+  recovery knowledge as something executable instead of a wiki page.
 
 ## Install
 
-Download a prebuilt binary from [GitHub Releases](https://github.com/trs-80/crisismode/releases/latest) — no Node.js required. macOS binaries are codesigned and notarized; every artifact ships with a SHA256 checksum.
+Prebuilt binaries need no Node.js. macOS builds are codesigned and notarized, and
+every artifact ships a SHA256 checksum.
 
 ```bash
 # Linux (x64)
@@ -81,370 +39,184 @@ curl -fsSL https://github.com/trs-80/crisismode/releases/latest/download/crisism
 # macOS (Apple Silicon)
 curl -fsSL https://github.com/trs-80/crisismode/releases/latest/download/crisismode-darwin-arm64 -o crisismode
 
-chmod +x crisismode
-./crisismode scan
+chmod +x crisismode && ./crisismode scan
 ```
 
-Also available: `crisismode-linux-arm64` and `crisismode-darwin-x64`. To verify a download, fetch the matching `.sha256` file and run `shasum -a 256 -c`.
-
-Enable tab completion for your shell:
-
-```bash
-crisismode completions bash|zsh|fish
-```
+Also built: `crisismode-linux-arm64`, `crisismode-darwin-x64`. To verify a
+download, fetch the matching `.sha256` and run `shasum -a 256 -c`. Building from
+source needs Node.js >= 22 — see [GETTING_STARTED.md](GETTING_STARTED.md).
 
-## Quick Start
+## 60-second demo
 
-**Zero-config scan** — CrisisMode autodiscovers databases, caches, and brokers on your machine and checks what it finds:
+No config, no infrastructure. CrisisMode autodiscovers what's running locally and
+checks it:
 
 ```bash
-crisismode
+crisismode                 # zero-config health scan (the default command)
 ```
 
-**Demo mode** (no infrastructure required, building from source):
+```
+  System Health Score: 100/100
+  Scanned at 2026-08-09T15:09:00.480Z (586ms)
 
-```bash
-pnpm install && pnpm dev
+  HEALTHY
+  PG-001      OK postgresql (default-postgres) — PostgreSQL replication is healthy.
+  DNS-002     OK dns (local-dns) — DNS resolution is healthy.
+  DISK-003    OK disk (local-disk) — Disk usage is healthy.
 ```
 
-**Real PostgreSQL** (requires [test environment setup](test/podman/scripts/start.sh)):
+Three questions it answers without touching your infrastructure:
 
 ```bash
-pnpm run live                  # Dry-run — reads real PG, logs mutations
-pnpm run live -- --execute     # Execute mode — runs recovery commands
+crisismode triage          # is it me, my network, or them?  (exit 1 on local/network)
+crisismode down stripe     # is it down for everyone, or just me?
+crisismode readiness       # will this stack break under load?
 ```
 
-**AlertManager webhook:**
+Then the full pipeline against a simulator — trigger → diagnosis → plan →
+validation → execution → forensic record:
 
 ```bash
-pnpm run webhook               # Dry-run, listens on :3000
-pnpm run webhook --execute     # Execute mode
+crisismode demo
 ```
 
-See [QUICKSTART.md](QUICKSTART.md) for a full walkthrough.
+Recovery is **dry-run by default**. `crisismode recover` reads live systems and
+shows you the plan; mutations require an explicit `--execute`.
 
-## What CrisisMode Recovers
+## From alert to recovery
 
-Status legend:
+Live mode against real PostgreSQL replication lag (local podman test
+environment), abridged:
 
-- **Live (execute-capable)** — queries real infrastructure and can run recovery mutations in `--execute` mode
-- **Live (diagnosis only)** — queries real infrastructure; recovery output is advisory (no mutating actions)
-- **Simulator** — full agent logic against an in-memory simulator; live client not yet wired into the CLI
-
-### Modern Application Incidents
-
-| Scenario | Agent | Status |
-|---|---|---|
-| Bad deploy rollback | Deploy Rollback | Live (execute-capable) -- Vercel, requires `VERCEL_TOKEN` |
-| LLM provider failures (key, quota, rate limit, model, outage) | LLM Provider | Live (diagnosis only) -- validated against real Anthropic and OpenAI keys; Google and OpenRouter paths implemented, best-effort validated |
-| AI provider degradation / failover | AI Provider | Simulator -- explicit config and demo only; no longer auto-detected from API keys |
-| Database migration failures | DB Migration | Live (execute-capable) -- diagnosis validated in dry-run via torture harness |
-| Queue and worker backlog | Queue Backlog | Live (execute-capable) -- diagnosis validated in dry-run via torture harness |
-| Config and environment drift | Config Drift | Live (execute-capable) -- diagnosis validated in dry-run via torture harness |
-
-### Stateful Infrastructure Recovery
-
-| System | Scenarios | Status |
-|---|---|---|
-| PostgreSQL | Replication lag, slot overflow, replica divergence, connection-pool exhaustion | Live (execute-capable) -- see validation status below |
-| Redis | Memory pressure, client exhaustion, slow queries, cluster health | Live (execute-capable) |
-| etcd | Leader election loop, member thrashing, snapshot corruption | Simulator |
-| Kafka | Under-replicated partitions, consumer lag cascade | Simulator |
-| Kubernetes | Node not-ready cascade, pod crashloop, stuck reconciliation | Live (execute-capable) |
-| Ceph | OSD down cascade, degraded PGs, pool near-full | Simulator |
-| Flink | Checkpoint failure cascade, TaskManager loss, backpressure | Simulator |
-| AWS | S3, DynamoDB, and RDS recovery; backup verification, PITR, snapshot staleness | Live (execute-capable) -- validated in dry-run against real AWS |
-| Terraform | Drift detection: intended state vs. observed AWS resources (RDS, S3, DynamoDB); read-only, suggests reconciliation | Simulator |
-
-### Host & Platform Health
-
-| Check | Scenarios | Status |
-|---|---|---|
-| DNS | Resolution failures, resolver health | Live (diagnosis + local cache flush) |
-| TLS | Certificate expiry and chain health | Live (diagnosis only) |
-| Disk | Local disk exhaustion | Live (diagnosis only) |
-| Backup | Backup verification and DR readiness | Live (diagnosis only) |
-
-### Validation status
-
-The [crisismode-torture](https://github.com/trs-80/crisismode-torture) harness
-runs CrisisMode against real degraded infrastructure (PostgreSQL replication,
-Redis, 3-node etcd, 3-broker Kafka, Redis Cluster partitions, cascading
-failures, and real AWS RDS/S3/DynamoDB). What it currently proves:
-
-- **Validated:** failure detection (typically 3–5s), AI diagnosis, and dry-run
-  recovery planning against real infrastructure, including real AWS and Vercel.
-- **Execute-verified (as of 2026-07-13):** end-to-end `--execute` recovery —
-  a mutating recovery plan that actually ran, plus post-recovery health
-  verification confirming the underlying fault was resolved (not just that
-  the engine exited without error) — for exactly three scenarios: Redis
-  memory pressure, PostgreSQL WAL-replay-paused replication lag, and
-  PostgreSQL connection-pool exhaustion. All three are reproducible via the
-  crisismode-torture harness.
-- **Not yet validated:** end-to-end `--execute` recovery for every other
-  agent/scenario in the tables above. Execute mode is functional for
-  individual actions, and the engine correctly refuses to run a plan when a
-  required live provider is missing (a blocked run is never counted as a
-  recovery), but no torture scenario besides the three above has completed a
-  full mutating recovery with post-recovery verification — treat the rest as
-  experimental until the harness verifies them. AWS and Vercel scenarios
-  remain dry-run/skipped in `--execute` mode.
-
-## Building Agents
-
-CrisisMode is extensible through recovery agents. Two contribution tracks:
-
-### Markdown Playbooks (low-code)
-
-Write recovery procedures as Markdown files with YAML frontmatter:
-
-```markdown
----
-name: "my-recovery-playbook"
-version: "1.0.0"
-description: "Recovery for my system"
-severity: elevated
-tags: [postgresql, replication]
----
-
-### 1. Diagnose the issue
-- type: diagnosis_action
-- target: primary
-
-### 2. Notify the team
-- type: human_notification
-- channel: default
 ```
+  Phase 3: Diagnosis (Live — AI-Powered)
+  🤖 AI analyzing system state...
+     Scenario:    replication_lag_cascade
+     Confidence:  94%
+     Root cause:  WAL replay paused on replica — sent LSN is advancing
+                  but replay LSN is static, indicating a deliberate pause
+                  or I/O bottleneck on the replica, not a network issue.
 
-Validate and test:
-```sh
-crisismode playbook validate my-playbook.md
-crisismode playbook dry-run my-playbook.md
-```
-
-See [Playbook Authoring Guide](docs/playbook-authoring.md) for details.
-
-### TypeScript Agents
-
-For complex recovery logic, build agents with the SDK. The types-only SDK lives at [`packages/agent-sdk`](packages/agent-sdk) and is consumed from a repo checkout via the pnpm workspace (`@crisismode/agent-sdk`).
-
-Implement the `RecoveryAgent` interface with `assessHealth()`, `diagnose()`, `plan()`, and `replan()` methods.
+  Phase 4: Plan Creation
+     #   Type                    Risk        Name
+     1   diagnosis_action        —           Assess replication lag
+     2   human_notification      —           Notify on-call DBA
+     3   checkpoint              —           Pre-recovery state capture
+     4   system_action           elevated    Disconnect lagging replica
+     7   human_approval          —           Approve resynchronization
+     8   system_action           high        pg_basebackup + resync
+    10   human_notification      —           Recovery summary
 
-See the [Agent Development Guide](docs/guides/creating-a-recovery-agent.md) for a full tutorial.
+  Phase 7: Execution (Live — EXECUTE MODE)
+     Step step-004 [system_action]
+     ✓ Precondition: Replica 10.89.0.5/32 is currently connected
+     ✓ Success: WAL sender for 10.89.0.5/32 is no longer present
+     ● SUCCESS (6ms)
+```
 
-## Architecture
+## Safety model
 
-```
-Alert Source (Prometheus) → Spoke Webhook Receiver
-                              ↓
-                           Diagnose (query real systems)
-                              ↓
-                           Plan (build recovery steps)
-                              ↓
-                           Validate (manifest + policy checks)
-                              ↓
-                           Execute (dry-run or live)
-                              ↓
-                           Forensic Record → Hub API
-```
+- Dry-run by default — reads real systems, logs mutations without running them.
+- Pre-mutation state capture on every `elevated`-or-higher action.
+- Blast-radius validation against the agent's declared manifest.
+- Human approval gates; `--execute` fails closed when confirmation can't be
+  collected (non-interactive stdin).
+- Five escalation levels: observe → diagnose → suggest → repair-safe →
+  repair-destructive.
+- Immutable forensic record per execution, and a rollback strategy on every plan.
 
-Hub-and-spoke topology: **spokes** (Layers 1-2) run close to target systems and handle execution and safety; the **hub** (Layers 3-4) provides coordination, analytics, and AI enrichment. Recovery actions progress through five escalation levels: observe, diagnose, suggest, repair-safe, and repair-destructive.
+These are enforced by the plan validator, not by convention — see
+[docs/architecture.md](docs/architecture.md).
 
-See [Architecture Overview](docs/architecture.md) for details.
+## Maturity and validation
 
-## Safety Model
+CrisisMode registers more agents than it has validated against real
+infrastructure, and it says so at runtime rather than in a footnote. Its honesty
+layer collapses every agent to one of two labels:
 
-- Blast radius validation on every system action
-- Pre-mutation state capture (checkpoint before any change)
-- Human approval gates for elevated-risk operations
-- Dry-run mode by default (reads real systems, logs mutations without executing)
-- `--execute` fails closed when confirmation can't be collected (non-interactive stdin)
-- Five-level progressive escalation (observe → diagnose → suggest → repair-safe → repair-destructive)
-- Immutable forensic record for every execution
+- **live-validated** — exercised against a real deployment of that system.
+- **best-effort** — the checks exist and run, but have never been proven against
+  a live system. Findings are leads, not conclusions. This is the default; an
+  agent has to earn the other label.
 
-## CLI Reference
+Ask the tool directly — this is the authoritative roster, not this README:
 
 ```bash
-crisismode                            # Zero-config health scan (default)
-crisismode scan                       # Health scan with scored summary and next-action hints
-crisismode diagnose                   # Health check + AI-powered diagnosis (read-only)
-crisismode recover                    # Full recovery flow with plain-English AI summaries
-crisismode status                     # Quick health probe
-crisismode triage                     # Is it me, my network, or them? Offline localization — exits 1 when the cause is this machine or its network
-crisismode down [<service>...]        # Is it down for everyone, or just me? Bare invocation checks the config's services: list — exits 1 if anything looks down, 2 on bad usage
-crisismode ask "<question>"           # Natural language AI diagnosis
-crisismode ask                        # Interactive diagnostic REPL
-crisismode demo                       # Simulator demo mode
-crisismode init                       # Generate crisismode.yaml configuration
-crisismode init --agent <name>        # Scaffold a check plugin
-crisismode webhook                    # Start webhook receiver for AlertManager
-crisismode watch                      # Continuous shadow observation
-crisismode readiness                  # Scale-readiness report (read-only): will this stack break under load, and where are the capacity ceilings? See docs/readiness.md
-
-crisismode bundle ingest <path|->     # Ingest an SRE evidence bundle (v1) for AI diagnosis
-crisismode bundle respond <path|->    # Emit AdapterResponse v1 ("-" reads from stdin)
-crisismode bundle execute <path|->    # Translate a bundle to a RecoveryPlan (dry-run)
-
-crisismode playbook list              # List discovered playbooks
-crisismode playbook validate <path>   # Validate a playbook file
-crisismode playbook dry-run <path>    # Preview compiled recovery plan
-
-crisismode agent list                 # List all registered agents
-crisismode agent info <name>          # Show agent details
-
-crisismode registry list              # List available check plugins
-crisismode registry search <query>    # Search check plugins
-crisismode registry install <name>    # Install a check plugin
-
-crisismode mcp                        # Start MCP server on stdio (read-only diagnosis tools)
-
-crisismode completions bash|zsh|fish  # Generate shell completions
+crisismode agent list      # 26 registrations, each with its maturity label
 ```
 
-Output modes: `--json` for machine-readable output, plain text auto-detected when piped, colored TTY output by default.
-
-### Pipe output format
+Today **9 of 26** registrations are live-validated: PostgreSQL replication,
+Kubernetes, DNS, TLS, disk, backup verification, third-party service status, and
+the LLM-provider agent for Anthropic and OpenAI (it registers once per provider).
+Everything else — Redis, etcd, Kafka, Ceph, Flink, AWS (S3/DynamoDB/RDS),
+Terraform drift, deploy rollback, DB migration, queue backlog, config drift,
+vector stores, AI-provider failover — is best-effort.
 
-When stdout is not a TTY and `--json` isn't set, `crisismode scan` emits plain, tab-separated rows instead of colored output — stable enough to feed to `cut`/`awk`.
+Separately, end-to-end `--execute` recovery (a mutating plan that ran, plus
+post-recovery verification that the fault was actually gone) is proven for
+**exactly three scenarios** as of 2026-07-13, all reproducible in the
+[crisismode-torture](https://github.com/trs-80/crisismode-torture) harness:
+Redis memory pressure, PostgreSQL WAL-replay-paused replication lag, and
+PostgreSQL connection-pool exhaustion. Treat every other execute path as
+experimental. AWS and Vercel scenarios remain dry-run only.
 
-A `scan` row has 4 fields:
+Full per-system coverage tables and what each harness proves:
+**[docs/coverage.md](docs/coverage.md)**.
 
-```
-scan\t<score>\t<scanned_at>\t<duration_ms>
-```
+## Extending it
 
-Each `finding` row has 7 fixed fields, so every row has the same column count regardless of whether a finding has a guide:
-
-```
-finding\t<id>\t<service>\t<status>\t<confidence>\t<summary>\t<guide_refs>
-```
+Two contribution tracks, depending on whether your recovery knowledge is a
+procedure or a decision tree:
 
-| # | Field | Notes |
+| Track | You write | Good for |
 |---|---|---|
-| 1 | `finding` | literal row-type marker |
-| 2 | `id` | finding id |
-| 3 | `service` | e.g. `postgresql (prod-db-01)` |
-| 4 | `status` | `healthy` / `recovering` / `unhealthy` / `unknown` |
-| 5 | `confidence` | 0–1 |
-| 6 | `summary` | free text; tab/newline characters are stripped so they can't shift later columns |
-| 7 | `guide_refs` | `guide:<id>[,<id>...]`, empty string when the finding has no matched remediation guide |
+| **Playbook** | Markdown + YAML frontmatter | A runbook with fixed steps |
+| **Agent** | TypeScript implementing `RecoveryAgent` | Diagnosis that builds different plans for different failures |
 
-### JSON output format
-
-The `--json` flag emits **JSON lines** (one JSON object per line), not a single JSON document. Each line has a `type` field indicating the data it carries:
-
-| Type | Description |
-|---|---|
-| `health` | Health assessment with `status` and `signals` array |
-| `diagnosis` | AI-powered diagnosis with `scenario`, `confidence`, and root cause |
-| `plan` | Recovery plan with `steps` array |
-| `triage` | Localization verdict (`local`/`network`/`remote`/`mixed`/`healthy`) with per-layer results. Exit code 0 for `healthy`/`remote`, 1 for `local`/`network`/`mixed` |
-
-Example usage:
+Playbooks compile to the same `RecoveryPlan` the engine runs for code-based
+agents, through the same validator — no shortcuts, no second safety path.
 
 ```bash
-# Pipe to jq for human-readable inspection
-crisismode recover --target my-db --json | jq 'select(.type == "diagnosis")'
-
-# Extract just the plan steps
-crisismode recover --target my-db --json | jq 'select(.type == "plan") | .plan.steps'
+crisismode playbook validate my-playbook.md
+crisismode playbook dry-run my-playbook.md
 ```
 
-### Third-party service checks (`down`)
+Check plugins are a third, smaller entry point: a shell script that probes a
+system and reports health on a JSON wire protocol. CrisisMode also adapts
+existing Nagios/Icinga/Checkmk plugins, Goss assertions, and Sensu checks, so
+established checks work without a rewrite.
 
-`crisismode down` checks third-party dependencies (Stripe, GitHub, Vercel, an LLM provider, ...) against two separate facts: what the provider's own status page reports, and whether this machine can reach it — a status-page hiccup is never reported as an outage. Read-only (escalation level 2: Diagnose).
+- [Playbook Authoring Guide](docs/playbook-authoring.md)
+- [Your First Agent](docs/guides/your-first-agent.md) · [Agent reference](docs/guides/creating-a-recovery-agent.md)
+- [Your First Check Plugin](docs/guides/your-first-check-plugin.md) · [Check plugin reference](docs/guides/creating-a-check-plugin.md)
 
-Exit codes: `0` nothing checked looks like a problem, `1` at least one service does, `2` the command itself was called wrong (an unrecognized flag — the only CrisisMode command that does this).
+## Works with your tools
 
-Check specific services ad hoc — catalog ids (`stripe`, `github`, `vercel`, `netlify`, `supabase`, `cloudflare`, `npm`, `twilio`, `sendgrid`, `render`, `fly`, `upstash`), aliases (`flyio` → `fly`), raw domains (reachability only, no known status page), or `anthropic`/`openai` (routed through the LLM Provider agent's own status source — `down`-only; see below):
+**MCP server** — `crisismode mcp` exposes 8 read-only diagnosis tools over stdio,
+so Claude Code or any MCP client can inspect your infrastructure. The MCP surface
+never mutates anything.
 
 ```bash
-crisismode down stripe github
-```
-
-```text
-  ✅ Stripe (healthy)
-      Stripe is healthy and reachable.
-  ✅ GitHub (healthy)
-      GitHub is healthy and reachable.
-```
-
-Or configure a standing list in `crisismode.yaml` and run `crisismode down` with no arguments. A `services:` list is valid on its own — no `targets:` block required:
-
-```yaml
-apiVersion: crisismode/v1
-kind: SiteConfig
-metadata:
-  name: my-stack
-services:
-  - stripe
-  - example.com
+claude mcp add crisismode -- crisismode mcp
 ```
 
-Each `services:` entry is a catalog id/alias, a raw domain (reachability-only — no known status page, so a `down` verdict there means "can't reach it," not "provider incident"), or `{ host, port }` for a non-default port. `anthropic`/`openai` are rejected here (config validation error) — they're covered automatically by the LLM Provider agent whenever the corresponding API key is set, and are only meant for the ad-hoc `crisismode down anthropic` form above. Listing them in `services:` would make `scan`/`watch` DNS-probe the literal hostname instead of routing through the provider's real status source.
-
-## Evidence Bundles
-
-CrisisMode speaks the SRE evidence-bundle v1 format, so external incident tooling can hand it a bundle of evidence (logs, metrics, operator notes) and get back a ranked diagnosis with policy-checked recovery actions:
-
-- `bundle ingest` — read-only AI diagnosis of the evidence
-- `bundle respond` — full AdapterResponse v1: ranked hypotheses with evidence citations, proposed actions gated by action-class policy, and explicit abstention when evidence is insufficient
-- `bundle execute` — translate a bundle into a validated RecoveryPlan (dry-run)
-
-All three accept a file path or `-` for stdin, making them easy to wire into pipelines:
+**Evidence bundles** — CrisisMode speaks the SRE evidence-bundle v1 format, so
+external incident tooling can hand it logs, metrics, and operator notes and get
+back ranked hypotheses with policy-gated actions. Reads a path or stdin:
 
 ```bash
 cat incident-bundle.json | crisismode bundle respond -
 ```
 
-## MCP Server
-
-`crisismode mcp` starts a [Model Context Protocol](https://modelcontextprotocol.io) server on stdio, so AI agents (Claude Code, Claude Desktop, or any MCP client) can diagnose your infrastructure directly:
+**Pipelines** — `--json` emits JSON lines; plain tab-separated output is
+auto-detected when stdout isn't a TTY.
 
 ```bash
-# Claude Code
-claude mcp add crisismode -- crisismode mcp
-```
-
-Or in `.mcp.json`:
-
-```json
-{
-  "mcpServers": {
-    "crisismode": { "command": "crisismode", "args": ["mcp"] }
-  }
-}
+crisismode recover --target my-db --json | jq 'select(.type == "diagnosis")'
 ```
 
-Every MCP tool is read-only — the MCP surface never mutates infrastructure:
-
-| Tool | What it does |
-|---|---|
-| `crisismode_scan` | Zero-config health scan with a 0–100 score and per-service findings |
-| `crisismode_diagnose` | Health assessment + diagnosis for one target (AI-powered with `ANTHROPIC_API_KEY`, rule-based otherwise) |
-| `crisismode_status` | Quick UP/DOWN probe of configured or detected services |
-| `crisismode_list_agents` | The built-in recovery agent roster |
-| `crisismode_bundle_ingest` | Read-only diagnosis of an SRE evidence bundle (v1) |
-| `crisismode_bundle_respond` | Ranked hypotheses with evidence citations and policy-gated proposed actions |
-| `crisismode_bundle_plan` | Translate a bundle into a dry-run RecoveryPlan (returned, never executed) |
-| `crisismode_readiness` | Forward-looking scale-readiness report: connection headroom, pooling, indexes, slow queries; includes capacity ceilings and a conditional weak-link verdict — see [docs/readiness.md](docs/readiness.md) |
-
-## Check Plugin Ecosystem
-
-CrisisMode consumes external health checks through a unified adapter layer, making thousands of existing checks available without rewriting them:
-
-- **Native check plugins** — JSON wire protocol for purpose-built CrisisMode checks
-- **Nagios/Icinga/Checkmk plugins** — thousands of battle-tested infrastructure checks
-- **Goss YAML health assertions** — declarative system state validation
-- **Sensu checks** — Graphite, InfluxDB, OpenTSDB, and Prometheus metric formats
-
-See [docs/guides/creating-a-check-plugin.md](docs/guides/creating-a-check-plugin.md) for the check plugin authoring guide.
-
-## Contributing
-
-Domain experts contribute recovery knowledge as agents, playbooks, and check plugins — the framework handles safety, validation, and execution.
-
-See [CONTRIBUTING.md](CONTRIBUTING.md) for contribution workflows and [GETTING_STARTED.md](GETTING_STARTED.md) for developer setup.
+Full command list, flags, exit codes, and output-format contracts:
+**[docs/cli-reference.md](docs/cli-reference.md)**.
 
 ## Deployment
 
@@ -456,22 +228,30 @@ helm install crisis-spoke deploy/helm/crisismode-spoke/ \
   --set targetNamespaces='{default,production}'
 ```
 
-The spoke runs in 256Mi and operates autonomously when the hub is unreachable.
+Spokes (Layers 1–2) run close to target systems and own execution and safety;
+the hub (Layers 3–4) adds coordination, analytics, and AI enrichment. A spoke
+runs in 256Mi and keeps working when the hub is unreachable.
 
-## Specifications
+## Documentation
 
-- [Recovery Agent Contract](specs/foundational/recovery-agent-contract.md) — the authoritative agent interface definition
-- [Deployment & Operations](specs/deployment/operations.md) — hub-and-spoke architecture, integration patterns, operational management
-- [Plugin Platform Architecture Guide](specs/architecture/plugin-platform.md) — how the repo evolves from bespoke agents to a scalable plugin ecosystem
-- [Operator Health & AI Services](specs/architecture/operator-health-and-ai-services.md) — operator summary, AI diagnosis, and site config spec
+| If you want to… | Read |
+|---|---|
+| Use the CLI on your own stack | [QUICKSTART.md](QUICKSTART.md) |
+| Build and hack on CrisisMode | [GETTING_STARTED.md](GETTING_STARTED.md) |
+| Contribute an agent or playbook | [CONTRIBUTING.md](CONTRIBUTING.md) |
+| Understand the design | [docs/architecture.md](docs/architecture.md) |
+| Look up a command or output format | [docs/cli-reference.md](docs/cli-reference.md) |
+| Know what's actually validated | [docs/coverage.md](docs/coverage.md) |
+| Check scale readiness | [docs/readiness.md](docs/readiness.md) |
+
+Specifications: [Recovery Agent Contract](specs/foundational/recovery-agent-contract.md)
+(authoritative) · [Deployment & Operations](specs/deployment/operations.md) ·
+[Plugin Platform](specs/architecture/plugin-platform.md) ·
+[Operator Health & AI Services](specs/architecture/operator-health-and-ai-services.md)
 
 ## License
 
-The spoke runtime, agent SDK, and specifications are licensed under **Apache 2.0**. See [LICENSE](LICENSE) and [NOTICE](NOTICE) for details.
-
-| Component | License |
-|---|---|
-| Spoke runtime (`src/framework/`, `src/agent/`, `src/types/`) | Apache 2.0 |
-| Agent SDK and contract spec (`specs/foundational/`) | Apache 2.0 |
-| Test infrastructure (`test/`, `deploy/`) | Apache 2.0 |
-| Hub API, coordination, and management UI | Commercial (not in this repo) |
+Apache 2.0 for everything in this repo — spoke runtime, agent SDK, specs, and
+test infrastructure. See [LICENSE](LICENSE) and [NOTICE](NOTICE). The hub API,
+coordination service, and management UI are commercial and not part of this
+repository.
diff --git a/docs/architecture.md b/docs/architecture.md
index 1e00317..4bc7b2e 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -46,7 +46,7 @@ graph TB
 The execution kernel runs recovery plans step by step. Two execution engines are available:
 
 - **LegacyExecutionEngine** — Sequential, callback-based. Each step runs in order. Failures halt execution. Suitable for simple recovery flows.
-- **RecoveryGraphEngine** — Built on LangGraph. Steps become graph nodes with conditional edges. Supports durable checkpointing (MemorySaver for dev, PostgresSaver for production), interrupt/resume for human-in-the-loop approval, and crash recovery from the last checkpoint.
+- **RecoveryGraphEngine** — Built on LangGraph. Steps become graph nodes with conditional edges. Supports checkpointing, interrupt/resume for human-in-the-loop approval, and recovery from the last checkpoint. The checkpointer is injectable and defaults to LangGraph's in-memory `MemorySaver`; a durable store (e.g. `PostgresSaver`) is the intended hub deployment but is not wired up in this repo.
 
 Both engines share the same `ExecutionBackend` interface for command execution and check evaluation.
 
@@ -193,8 +193,93 @@ Two execution modes control whether mutations actually run:
 - **`dry-run`** (default) — Reads from real systems, logs what mutations would happen, but does not execute them. All safety checks still run. State transitions are simulated.
 - **`execute`** — Runs all operations including system mutations. Requires explicit opt-in via `--execute` flag.
 
+## Escalation Levels
+
+Every action CrisisMode can take is placed on a five-level scale
+(`src/framework/escalation.ts`), which is what lets output say how far a
+suggestion goes before anyone runs it:
+
+| Level | Name | Touches the system? |
+|---|---|---|
+| 1 | Observe | No — read-only health checks, no interaction |
+| 2 | Diagnose | Reads only — live queries |
+| 3 | Suggest | Generates plans, executes nothing |
+| 4 | Repair (safe) | Executes `routine` and `elevated` risk actions |
+| 5 | Repair (destructive) | Executes `high` and `critical` risk actions |
+
+`triage`, `down`, and `readiness` never exceed level 2 by design.
+
+## The Honesty Layer
+
+CrisisMode registers more agents than it has validated, so it treats "how much do
+we actually know" as a first-class part of the architecture rather than a
+documentation problem.
+
+- **Maturity collapse** (`src/framework/agent-maturity.ts`) — a manifest's
+  five-value `PluginMaturity` is reduced to two operator-facing labels:
+  `live_validated`, or best-effort for everything else. Unknown and unregistered
+  kinds default to best-effort, and a *kind* only counts as live-validated when
+  every agent registered for it says so. Best-effort findings carry an explicit
+  "treat this as a lead, not a conclusion" suffix in human output.
+- **Unknown is a real status.** Health findings, readiness rules, and provider
+  checks can return `unknown` with a `reason` instead of guessing. `unknown`
+  never moves a readiness score or verdict — demanding zero unknowns would
+  invite fabrication.
+- **Omit rather than estimate.** A capacity ceiling that cannot be computed from
+  declared or measured inputs is dropped with a reason, never approximated.
+- **Failures degrade coverage, not delivery.** Per-rule and per-agent error
+  isolation turns a thrown error into an `unknown` finding, leaving the rest of
+  the report intact.
+- **Blocked is not recovered.** When a required live capability provider is
+  missing, the engine refuses to run the plan, and a blocked run is never counted
+  as a successful recovery.
+
+See [coverage.md](coverage.md) for where each agent currently stands.
+
+## Localization and Outward Checks
+
+Not every incident is inside your infrastructure, so three read-only subsystems
+answer questions that precede recovery:
+
+- **Triage** (`triage.ts`, `triage-probes.ts`) — offline layered localization.
+  Probes outward through interfaces → gateway → DNS → captive portal → internet
+  → configured targets, then synthesizes a verdict of `local`, `network`,
+  `remote`, `mixed`, or `healthy`. It works with no connectivity at all, which is
+  the situation it exists for.
+- **Service status** (`service-status/`) — combines a provider's own status page
+  (Statuspage v2 parsing, plus a catalog of known services) with an independent
+  reachability probe, and never conflates the two: a status-page hiccup is not
+  reported as an outage, and an unreachable host is not reported as a provider
+  incident.
+- **Readiness** (`src/readiness/`) — forward-looking rules and capacity ceilings
+  answering "will this break under load?" rather than "is it broken now?". See
+  [readiness.md](readiness.md).
+
+## Remediation Guidance
+
+Some fixes CrisisMode must not perform itself — rotating a key, changing a
+billing plan, resizing a managed instance through a vendor console. Rather than
+staying silent, it ships a static `RemediationGuide` registry
+(`src/framework/guidance/`) keyed to readiness rule ids and agent `checkId`s.
+Each guide carries console steps, a CLI equivalent, the expected outcome, and a
+`verifiedOn` date.
+
+Two properties keep this from rotting into stale instructions:
+
+- A guide's `applicableFindingTypes` must name something the codebase actually
+  emits; a test fails otherwise, so a renamed rule cannot silently orphan its
+  guidance.
+- A test fails when any guide's `verifiedOn` is more than 12 months old, so
+  console paths are re-walked on a schedule instead of during someone's incident.
+
+`scan`, `diagnose`, `readiness`, and `recover` all render guidance identically,
+from the same registry.
+
 ## Further Reading
 
 - [Recovery Agent Contract](../specs/foundational/recovery-agent-contract.md) — authoritative specification
 - [Deployment & Operations](../specs/deployment/operations.md) — hub-and-spoke deployment details
 - [Agent Development Guide](guides/creating-a-recovery-agent.md) — building a new agent from scratch
+- [CLI Reference](cli-reference.md) — commands, flags, exit codes, output formats
+- [Coverage & Validation Status](coverage.md) — what has actually been validated
+- [Scale Readiness](readiness.md) — readiness rules, ceilings, and the honesty contract
diff --git a/docs/cli-reference.md b/docs/cli-reference.md
new file mode 100644
index 0000000..7eb2442
--- /dev/null
+++ b/docs/cli-reference.md
@@ -0,0 +1,281 @@
+# CLI Reference
+
+Every command, flag, exit code, and output-format contract. Run
+`crisismode --help` for the same command list from the binary itself.
+
+From a source checkout, substitute `node dist/cli/index.js` (after
+`pnpm run build`) or `npx tsx src/cli/index.ts` for `crisismode`.
+
+## Commands
+
+### Diagnosis and recovery
+
+| Command | What it does |
+|---|---|
+| `crisismode` | Zero-config health scan — the default when no command is given |
+| `crisismode scan` | Health scan with a 0–100 score, findings, and next-action hints |
+| `crisismode diagnose [<target>]` | Health check plus diagnosis (read-only). The positional is a **target name** from config (`--target` is equivalent), except that a `PLUG-<n>` finding id is routed to that check plugin's diagnose verb |
+| `crisismode recover` | Full recovery flow. Dry-run unless `--execute` |
+| `crisismode status` | Quick health probe |
+| `crisismode ask "<question>"` | Natural-language AI diagnosis |
+| `crisismode ask` | Interactive diagnostic REPL |
+
+### Localization and outlook
+
+| Command | What it does |
+|---|---|
+| `crisismode triage` | Is the problem this machine, its network, or the remote services? Offline. Exits 1 on `local`/`network`/`mixed` |
+| `crisismode down [<service>...]` | Is it down for everyone, or just me? Bare form checks the config's `services:` list. Exits 0/1, or 2 on bad usage |
+| `crisismode readiness` | Scale-readiness report (read-only): will this stack break under load, and where are the capacity ceilings? See [readiness.md](readiness.md) |
+
+### Setup and operation
+
+| Command | What it does |
+|---|---|
+| `crisismode init [path]` | Generate `crisismode.yaml` |
+| `crisismode init --agent <name>` | Scaffold a check plugin |
+| `crisismode demo` | Simulator demo — full pipeline, no infrastructure |
+| `crisismode webhook` | Start a webhook receiver for Prometheus AlertManager |
+| `crisismode watch` | Continuous shadow observation |
+| `crisismode mcp` | Start the MCP server on stdio (read-only tools) |
+| `crisismode completions bash\|zsh\|fish` | Generate shell completions |
+
+### Subcommand groups
+
+| Command | What it does |
+|---|---|
+| `crisismode agent list` | All registered agents with maturity labels |
+| `crisismode agent info <name>` | One agent's targets, risk profile, and maturity |
+| `crisismode playbook list` | Discovered playbooks |
+| `crisismode playbook validate <path>` | Validate a playbook and its compiled plan |
+| `crisismode playbook dry-run <path>` | Preview the compiled recovery plan |
+| `crisismode bundle ingest <path\|->` | Read-only AI diagnosis of an SRE evidence bundle (v1) |
+| `crisismode bundle respond <path\|->` | Emit AdapterResponse v1 |
+| `crisismode bundle execute <path\|->` | Translate a bundle into a RecoveryPlan (dry-run) |
+| `crisismode registry list` | Available check plugins |
+| `crisismode registry search <query>` | Search check plugins |
+| `crisismode registry install <name>` | Install a check plugin |
+
+## Flags
+
+This is the complete set — there are no per-command flags beyond these.
+
+| Flag | Applies to | Effect |
+|---|---|---|
+| `--config <path>` | all | Path to `crisismode.yaml` |
+| `--target <name>` | all | Target name from config |
+| `--category <kinds>` | `scan` | Comma-separated service kinds to scan |
+| `--agent <name>` | `init` | Scaffold a check plugin instead of a config file |
+| `--execute` | `recover`, `webhook` | Enable mutations. Without it, everything is dry-run |
+| `--health-only` | `recover` | Health check only, no diagnosis |
+| `--local` | `registry install`, `init --agent` | Install to `./checks/` instead of `~/.crisismode/checks/` |
+| `--force` | `registry install` | Overwrite an existing plugin installation |
+| `--terse` | all | Suppress plain-language explanations and risk framing. Human output only — `--json` always carries the full data |
+| `--json` | all | Machine-readable JSON output |
+| `--no-color` | all | Disable colored output |
+| `--verbose` | all | Additional detail |
+| `-h`, `--help` | all | Show help |
+| `-v`, `--version` | all | Show version |
+
+## Exit codes
+
+Most commands exit 0 on success and non-zero when they fail to run. Two
+commands use the exit code to carry a *verdict*, so they can be used in scripts
+and CI:
+
+| Command | 0 | 1 | 2 |
+|---|---|---|---|
+| `triage` | verdict is `healthy` or `remote` | verdict is `local`, `network`, or `mixed` | — |
+| `down` | nothing checked looks like a problem | at least one service does | the command was called wrong (unrecognized flag) — the only CrisisMode command that does this |
+
+## Output modes
+
+Three modes, auto-selected:
+
+- **human** (default on a TTY) — colored, emoji severity indicators, and
+  plain-language explanations. Suppress the explanations with `--terse`.
+- **pipe** (auto-detected when stdout is not a TTY) — plain text, no ANSI,
+  tab-separated.
+- **machine** (`--json`) — JSON Lines with metadata.
+
+### Pipe format
+
+`crisismode scan` emits tab-separated rows, stable enough to feed `cut`/`awk`.
+
+A `scan` row has 4 fields:
+
+```
+scan\t<score>\t<scanned_at>\t<duration_ms>
+```
+
+Every `finding` row has the same 7 fields, whether or not the finding has a
+remediation guide, so the column count never shifts:
+
+```
+finding\t<id>\t<service>\t<status>\t<confidence>\t<summary>\t<guide_refs>
+```
+
+| # | Field | Notes |
+|---|---|---|
+| 1 | `finding` | Literal row-type marker |
+| 2 | `id` | Finding id, e.g. `PG-001` |
+| 3 | `service` | e.g. `postgresql (default-postgres)` |
+| 4 | `status` | `healthy` / `recovering` / `unhealthy` / `unknown` |
+| 5 | `confidence` | 0–1 |
+| 6 | `summary` | Free text; tabs and newlines are stripped so they can't shift later columns |
+| 7 | `guide_refs` | `guide:<id>[,<id>...]`, empty when no remediation guide matched |
+
+`triage` uses the same shape with a `triage` row and one `layer` row per probe:
+
+```
+triage\t<verdict>\t<checked_at>\t<duration_ms>
+layer\t<name>\t<result>\t<evidence>
+```
+
+### JSON format
+
+`--json` emits **JSON Lines** — one object per line, not a single document. Each
+line carries a `type`:
+
+| Type | Contents |
+|---|---|
+| `health` | Health assessment with `status` and a `signals` array |
+| `diagnosis` | Diagnosis with `scenario`, `confidence`, and root cause |
+| `plan` | Recovery plan with a `steps` array |
+| `triage` | Localization verdict (`local`/`network`/`remote`/`mixed`/`healthy`) with per-layer results |
+| `readiness` | Scale-readiness report, fields spread at the top level (no sub-key) |
+
+```bash
+# Human-readable inspection
+crisismode recover --target my-db --json | jq 'select(.type == "diagnosis")'
+
+# Just the plan steps
+crisismode recover --target my-db --json | jq 'select(.type == "plan") | .plan.steps'
+
+# Readiness verdict only
+crisismode readiness --json | jq 'select(.type == "readiness") | .verdict'
+```
+
+## Third-party service checks (`down`)
+
+`crisismode down` keeps two facts separate: what the provider's own status page
+reports, and whether *this machine* can reach it. A status-page hiccup is never
+reported as an outage. Read-only — escalation level 2 (Diagnose).
+
+```bash
+crisismode down stripe github
+```
+
+```text
+  ✅ Stripe (healthy)
+      Stripe is healthy and reachable.
+  ✅ GitHub (healthy)
+      GitHub is healthy and reachable.
+```
+
+Accepted arguments:
+
+- **Catalog ids** — `stripe`, `github`, `vercel`, `netlify`, `supabase`,
+  `cloudflare`, `npm`, `twilio`, `sendgrid`, `render`, `fly`, `upstash`
+- **Aliases** — e.g. `flyio` → `fly`
+- **Raw domains** — reachability only, since there's no known status page. A
+  `down` verdict there means "can't reach it," not "provider incident"
+- **`anthropic` / `openai`** — routed through the LLM Provider agent's own status
+  source. Ad-hoc only; see the config note below
+
+### Standing list in config
+
+Run bare `crisismode down` to check a configured list. A `services:` block is
+valid on its own — no `targets:` required:
+
+```yaml
+apiVersion: crisismode/v1
+kind: SiteConfig
+metadata:
+  name: my-stack
+services:
+  - stripe
+  - example.com
+```
+
+Each entry is a catalog id/alias, a raw domain, or `{ host, port }` for a
+non-default port.
+
+`anthropic` and `openai` are **rejected** here with a config validation error.
+They're already covered by the LLM Provider agent in `scan`/`watch` whenever the
+matching API key is set. Listing them under `services:` would make CrisisMode DNS-probe
+the literal hostname instead of reading the provider's real status source — a
+strictly worse check, so it's refused rather than silently accepted.
+
+## Evidence bundles
+
+CrisisMode speaks the SRE evidence-bundle v1 format, so external incident tooling
+can hand it a bundle (logs, metrics, operator notes) and get a diagnosis back.
+
+| Command | Output |
+|---|---|
+| `bundle ingest` | Read-only AI diagnosis of the evidence |
+| `bundle respond` | AdapterResponse v1: ranked hypotheses with evidence citations, actions gated by action-class policy, and explicit abstention when evidence is insufficient |
+| `bundle execute` | A validated RecoveryPlan (dry-run) |
+
+All three take a file path or `-` for stdin:
+
+```bash
+cat incident-bundle.json | crisismode bundle respond -
+```
+
+## MCP server
+
+`crisismode mcp` starts a [Model Context Protocol](https://modelcontextprotocol.io)
+server on stdio.
+
+```bash
+claude mcp add crisismode -- crisismode mcp
+```
+
+Or in `.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "crisismode": { "command": "crisismode", "args": ["mcp"] }
+  }
+}
+```
+
+All 8 tools are read-only and annotated `readOnlyHint: true` — the MCP surface
+never mutates infrastructure:
+
+| Tool | What it does |
+|---|---|
+| `crisismode_scan` | Zero-config health scan with a 0–100 score and per-service findings |
+| `crisismode_diagnose` | Health assessment plus diagnosis for one target (AI-powered with `ANTHROPIC_API_KEY`, rule-based otherwise) |
+| `crisismode_status` | Quick UP/DOWN probe of configured or detected services |
+| `crisismode_list_agents` | The registered recovery agent roster with maturity labels |
+| `crisismode_bundle_ingest` | Read-only diagnosis of an SRE evidence bundle (v1) |
+| `crisismode_bundle_respond` | Ranked hypotheses with evidence citations and policy-gated actions |
+| `crisismode_bundle_plan` | Translate a bundle into a dry-run RecoveryPlan (returned, never executed) |
+| `crisismode_readiness` | Scale-readiness report including capacity ceilings and the conditional weak-link verdict — see [readiness.md](readiness.md) |
+
+## Check plugin ecosystem
+
+CrisisMode consumes external health checks through an adapter layer, so existing
+checks work without a rewrite:
+
+- **Native check plugins** — JSON wire protocol for purpose-built checks
+- **Nagios / Icinga / Checkmk plugins** — thousands of existing infrastructure checks
+- **Goss** — declarative YAML system-state assertions
+- **Sensu checks** — Graphite, InfluxDB, OpenTSDB, and Prometheus metric formats
+
+Discovered from `~/.crisismode/checks/`, `./checks/`, or `$CRISISMODE_CHECK_PATH`
+(colon-separated). See
+[Your First Check Plugin](guides/your-first-check-plugin.md) to write one, and the
+[check plugin reference](guides/creating-a-check-plugin.md) for the wire protocol
+and adapters.
+
+## See also
+
+- [QUICKSTART.md](../QUICKSTART.md) — guided first run
+- [coverage.md](coverage.md) — what each agent has actually been validated against
+- [readiness.md](readiness.md) — the readiness rules, ceilings, and honesty contract
+- [architecture.md](architecture.md) — how the engine, safety layers, and plugins fit together
diff --git a/docs/coverage.md b/docs/coverage.md
new file mode 100644
index 0000000..9db42d7
--- /dev/null
+++ b/docs/coverage.md
@@ -0,0 +1,159 @@
+# Coverage and Validation Status
+
+What CrisisMode can look at, and how far each part has actually been proven. This
+page exists because "we support Kafka" is a claim that means nothing without
+saying how it was tested.
+
+The tool is the authoritative source, not this file:
+
+```bash
+crisismode agent list          # every registration with its maturity label
+crisismode agent info <name>   # one agent's targets, risk profile, and maturity
+```
+
+## The two labels
+
+CrisisMode's manifests carry a five-value `PluginMaturity`
+(`experimental`, `simulator_only`, `dry_run_only`, `live_validated`,
+`production_certified`), but the honesty layer that operators see collapses it to
+two (`src/framework/agent-maturity.ts`):
+
+| Label | Means |
+|---|---|
+| **live-validated** | The manifest declares `live_validated` — the agent has been exercised against a real deployment of that system. |
+| **best-effort** | Everything else. The checks exist and run, but have never been proven against a live system. Findings are leads, not conclusions. |
+
+Two deliberate consequences:
+
+- **best-effort is the default.** Unknown kinds, unregistered kinds, and plugin
+  manifests that declare no maturity all land here. The pessimistic reading is
+  the honest one.
+- **A kind is only live-validated when *every* agent registered for it says so.**
+  With several agents per kind, the framework can't know which one will run, so
+  it claims the weaker label.
+
+Best-effort findings say so in the output — human scan output appends a
+"never been validated against real infrastructure — treat this as a lead, not a
+conclusion" suffix rather than presenting them as equal to validated ones.
+
+## Live-validated today
+
+9 of 26 registrations. The LLM-provider agent registers once per provider, so it
+accounts for two of the nine (Anthropic and OpenAI) from the single row below.
+
+| System | Agent | Notes |
+|---|---|---|
+| PostgreSQL | `postgresql-replication-recovery` | Replication lag, slot overflow, replica divergence, connection-pool exhaustion. The reference implementation. |
+| Kubernetes | `kubernetes-recovery` | Node not-ready cascade, pod crashloop, stuck reconciliation |
+| DNS | `dns-recovery` | Resolution failures, resolver health; can flush the local cache |
+| TLS | `tls-certificate-recovery` | Certificate expiry and chain health (diagnosis only) |
+| Disk | `disk-exhaustion-recovery` | Local disk exhaustion (diagnosis only) |
+| Backup | `backup-verification` | Backup verification and DR readiness across filesystem, `aws_s3`, `aws_rds` providers (diagnosis only) |
+| Third-party status | `service-status-diagnosis` | All 12 catalog entries passed live validation |
+| LLM providers | `llm-provider-diagnosis` | **Anthropic and OpenAI only.** Key validity, quota/billing, rate-limit headroom, model deprecation, provider status |
+
+## Best-effort today
+
+17 of 26 registrations. The logic and simulators are complete and unit-tested;
+none has been validated against a live deployment of its target system. The
+Google Gemini and OpenRouter rows are two separate registrations of the
+LLM-provider agent, which is why the table below has 16 rows.
+
+| System | Agent | Scenarios covered |
+|---|---|---|
+| Redis | `redis-memory-recovery` | Memory pressure, client exhaustion, slow queries, cluster health |
+| etcd | `etcd-recovery` | Leader election loop, member thrashing, NOSPACE alarms, snapshot corruption |
+| Kafka | `kafka-recovery` | Under-replicated partitions, leader imbalance, consumer lag cascade |
+| Ceph | `ceph-storage-recovery` | OSD down cascade, degraded PGs, pool near-full |
+| Flink | `flink-recovery` | Checkpoint failure cascade, TaskManager loss, backpressure |
+| AWS S3 | `aws-s3-recovery` | Backup bucket versioning and lifecycle configuration |
+| AWS DynamoDB | `aws-dynamodb-recovery` | Point-in-time-recovery verification |
+| AWS RDS | `aws-rds-recovery` | Control-plane health, metrics, reachability, backup retention and snapshot recency |
+| Terraform | `iac-drift-recovery` | Drift detection: intended state vs. observed AWS resources. Read-only; suggests reconciliation |
+| Deploy rollback | `deploy-rollback-recovery` | Bad-deploy rollback (Vercel; needs `VERCEL_TOKEN`) |
+| DB migration | `db-migration-recovery` | Migration safety checks, rollback orchestration |
+| Queue backlog | `queue-backlog-recovery` | Backlog reduction, consumer lag recovery |
+| Config drift | `config-drift-recovery` | Configuration and environment drift, compliance enforcement |
+| Vector stores | `vector-store-diagnosis` | Managed vector store reachability (Pinecone, Upstash Vector) |
+| AI provider | `ai-provider-failover-recovery` | Provider failover and fallback routing |
+| LLM providers | `llm-provider-diagnosis` | Google Gemini and OpenRouter paths (implemented; not live-validated) |
+
+Some of these have been exercised in *dry-run* against real infrastructure, which
+is worth more than simulator-only but is still not `live_validated`:
+
+- **AWS S3, DynamoDB, RDS** — diagnosis validated in dry-run against real AWS
+  accounts. No execute path has been verified.
+- **DB migration, queue backlog, config drift** — diagnosis validated in dry-run
+  through the torture harness.
+- **Deploy rollback** — exercised against the real Vercel API in dry-run.
+
+### Vector stores: read this before believing the table
+
+`vector-store-diagnosis` is `simulator_only` and neither provider has been
+validated against a real account. Two narrower things *were* checked against the
+live Pinecone API: that an invalid key is rejected, and that secrets are redacted
+from output. Upstash Vector was exercised only in simulator and mocked tests.
+Nothing about healthy-path behaviour against a real index is verified.
+
+## Execute-verified recovery
+
+Maturity labels describe *diagnosis*. Whether a mutating recovery plan actually
+ran and actually fixed the fault is a stricter and much narrower claim.
+
+The [crisismode-torture](https://github.com/trs-80/crisismode-torture) harness
+runs CrisisMode against real degraded infrastructure — PostgreSQL replication,
+Redis, 3-node etcd, 3-broker Kafka, Redis Cluster partitions, cascading failures,
+and real AWS RDS/S3/DynamoDB.
+
+**Validated:** failure detection (typically 3–5s), AI diagnosis, and dry-run
+recovery planning against real infrastructure, including real AWS and Vercel.
+
+**Execute-verified (as of 2026-07-13)** — a mutating plan that ran, *plus*
+post-recovery health verification confirming the underlying fault was resolved,
+not merely that the engine exited without error. Exactly three scenarios:
+
+1. Redis memory pressure
+2. PostgreSQL WAL-replay-paused replication lag
+3. PostgreSQL connection-pool exhaustion
+
+All three are reproducible through the harness.
+
+**Not verified:** end-to-end `--execute` recovery for every other
+agent/scenario on this page. Execute mode is functional for individual actions,
+and the engine correctly refuses to run a plan when a required live provider is
+missing — a blocked run is never counted as a recovery — but no other torture
+scenario has completed a full mutating recovery with post-recovery verification.
+Treat those execute paths as experimental. AWS and Vercel scenarios remain
+dry-run/skipped under `--execute`.
+
+Note that Redis is execute-verified for memory pressure while its manifest still
+declares `simulator_only`. That is not a typo: the two claims measure different
+things, and the manifest deliberately makes the weaker one.
+
+## Readiness rules
+
+`crisismode readiness` is a separate, strictly read-only surface with its own
+honesty contract (unknown is never scored, ceilings are never fabricated). Two
+torture scenarios validate it against real PostgreSQL. Its uncovered paths —
+the `blocking` verdict, the `pg_stat_statements`-present positive path, and the
+`serverless-pooling` heuristic — are listed in
+[docs/readiness.md](readiness.md#validation).
+
+## Other validation surfaces
+
+**Diagnosis eval** — 14 incident families from the external
+[sre-incident-agent-skills](https://github.com/Dbochman/sre-incident-agent-skills)
+benchmark, run against the real CLI with a 13/14 score gate
+(`pnpm run eval:diagnosis:gate`). A recorded run is in
+[docs/evals/2026-07-04-diagnosis-eval.md](evals/2026-07-04-diagnosis-eval.md).
+
+**Remediation guide verification** — the console-step guidance CrisisMode prints
+for fixes it must not perform itself is re-walked against live consoles on a
+schedule; a test fails when any guide's `verifiedOn` is more than 12 months old.
+The most recent walk-through is in
+[docs/guide-verification/2026-08-08-walkthrough.md](guide-verification/2026-08-08-walkthrough.md).
+Guides on platforms nobody has an account for are marked `BLOCKED` and reported
+as a coverage gap rather than quietly assumed correct.
+
+**Unit tests and typecheck** — `pnpm test` and `pnpm run typecheck`, both run in
+CI on Node 22 and 24.
diff --git a/docs/guide-verification/2026-08-09-docs-pass-report.md b/docs/guide-verification/2026-08-09-docs-pass-report.md
new file mode 100644
index 0000000..b0f7cfb
--- /dev/null
+++ b/docs/guide-verification/2026-08-09-docs-pass-report.md
@@ -0,0 +1,192 @@
+# Docs Pass Report — 2026-08-09
+
+Repo-presentation docs pass on branch `chore/repo-presentation`. Goal: make the
+repo read well to an employer reviewing it cold, without inflating any claim.
+
+Pre-existing uncommitted edits (Node >= 22 accuracy fixes across the four root
+docs) were preserved and extended, not reverted.
+
+## Structure decision
+
+The three-competing-onboarding-paths problem was resolved by **sharply
+differentiating** rather than deleting, because the two guides were actually
+serving different audiences that had bled into each other. Every concern now has
+exactly one home:
+
+| Doc | Audience | Owns |
+|---|---|---|
+| `README.md` | Cold visitor | What it is, who it's for, install, 60-second demo, honest maturity summary, where to go next |
+| `QUICKSTART.md` | Operator using the CLI | Install a binary, first scan, drill in, config, recovery, output modes |
+| `GETTING_STARTED.md` | Developer building on it | Clone, build, podman test env, failure injection, project layout, pnpm scripts |
+| `CONTRIBUTING.md` | Contributor | Contribution tracks, maturity honesty rule, code standards, testing, PR expectations |
+| `docs/cli-reference.md` (new) | Reference lookup | Every command, flag, exit code, output-format contract, `down`, bundles, MCP |
+| `docs/coverage.md` (new) | Anyone checking claims | Per-agent maturity, what each harness proves |
+
+Each root doc opens with a one-line pointer to its siblings so a cold reader
+routes correctly instead of reading all three.
+
+`README.md` went 477 → 258 lines. Depth moved into the two new `docs/` files
+rather than being deleted.
+
+## Honesty corrections
+
+Every one of these was a case where existing text claimed more than the codebase
+supports. All were verified against source, not inferred.
+
+### 1. Agent status table overstated live capability (README)
+
+The old table labelled Redis, deploy rollback, DB migration, queue backlog,
+config drift, and all three AWS agents as **"Live (execute-capable)"**. Their
+manifests declare `maturity: 'simulator_only'`, and CrisisMode's own honesty
+layer (`src/framework/agent-maturity.ts`) reports everything except
+`live_validated` as best-effort. An employer running `crisismode agent list`
+would have seen the README and the tool disagree.
+
+Replaced with the tool's own two-label vocabulary and the real count: **9 of 26
+registrations are live-validated** (verified by counting `agent list` output, not
+by eye — the first count of 8 was wrong because the LLM-provider agent registers
+once per provider).
+
+### 2. `checks/` does not ship with the binary (QUICKSTART)
+
+Old text: scan "Runs bundled check plugins (disk, memory, DNS, HTTP, TLS
+certificates)". `package.json` `files` is `dist/**`, `README`, `LICENSE`,
+`NOTICE` — `checks/` is not published. A binary or npm user gets **no** check
+plugins by default; a real scan from outside the repo prints "No check plugins
+found." Softened to state the discovery paths and that the examples live in a
+repo checkout.
+
+### 3. `PostgresSaver for production` (docs/architecture.md)
+
+`graph-engine.ts` imports only `MemorySaver` and defaults to it; `PostgresSaver`
+appears solely in a source comment. Reworded to "the checkpointer is injectable
+and defaults to `MemorySaver`; a durable store is the intended hub deployment but
+is not wired up in this repo."
+
+### 4. Vector store maturity (docs/coverage.md)
+
+Given a dedicated call-out rather than a table row, since the table alone would
+mislead: `simulator_only`, no real Pinecone or Upstash account ever validated.
+The only live checks were invalid-key rejection and secret redaction against the
+real Pinecone API; Upstash is simulator/mocked only.
+
+### 5. Smoke-test check counts
+
+`GETTING_STARTED.md` asserted "16 checks" and "6 checks". The scripts compute
+`TOTAL` dynamically and I could not run them (no podman session), so I replaced
+the hard numbers with "each script prints a `passed/total` tally" rather than
+repeat unverified figures.
+
+### 6. Redis execute-verified vs. `simulator_only`
+
+Left as an explicit, labelled tension in `docs/coverage.md` instead of silently
+picking a side. Redis memory pressure is execute-verified in the torture harness
+(2026-07-13) while its manifest says `simulator_only`. The two claims measure
+different things; the doc says so and notes the manifest deliberately makes the
+weaker claim.
+
+## Drift fixed
+
+- **Invalid maturity values in both agent guides (3 places).** Guides told readers
+  to set `plugin.maturity` to `"beta"` or `"stable"`. Neither is a valid
+  `PluginMaturity` — the real set is `experimental`, `simulator_only`,
+  `dry_run_only`, `live_validated`, `production_certified`. Fixed, and tied to a
+  new CONTRIBUTING section explaining why `simulator_only` is the honest default.
+- **`playbook-authoring.md`'s flagship example did not validate.** Verified by
+  extracting the fenced block and running it: step 4 lacked `capability`, failing
+  with `Missing capabilities on steps: redis-memory-pressure-step-4`. Added
+  `capability: cache.expiry.trigger`; the example now passes 13 safety checks
+  verbatim from the doc. Also documented where valid capability ids come from,
+  since that was the missing information behind the bug.
+- **`GETTING_STARTED.md` said "19 agents"** — actual count is 26. Rather than
+  re-listing the roster (the redundancy that caused this drift), it now points at
+  `crisismode agent list` and `docs/coverage.md`.
+- **Missing recent subsystems.** `docs/architecture.md` had no coverage of
+  escalation levels, the honesty layer, triage, service-status, or the
+  remediation-guidance registry. Added sections for each.
+- **New test scripts undocumented:** `inject-pgvector-unindexed.sh`,
+  `reset-pgvector.sh`, `test-alert-pipeline.sh`.
+
+## Verification performed
+
+Everything documented was checked at the real surface after `pnpm run build`.
+
+- **Flags:** the complete flag set was taken from `node dist/cli/index.js --help`.
+  No invented flags — an audit of every `--flag` across all docs found only
+  `--json`, `--target`, `--agent`, all real. (Subcommand `--help` prints the
+  global help, so the top-level list is authoritative.)
+- **Commands run:** `scan`, `scan --category dns`, `scan --json`/pipe, `triage`,
+  `down stripe github`, `down --badflag` (exit 2 confirmed), `agent list`,
+  `completions zsh`, `init --agent`, `init --plugin`, `playbook validate`,
+  `playbook dry-run`, `diagnose PG-001`, `diagnose default-postgres`.
+- **Output-format contracts confirmed against real output:** the 4-field `scan`
+  row and 7-field `finding` row (including a populated `guide_refs` cell), and
+  the `triage`/`layer` rows.
+- **Counts confirmed:** 26 agent registrations, 9 live-validated, 8 MCP tools, 8
+  readiness rules, 9 hook points, 12 service-catalog ids, 9 default probe ports.
+- **Links:** 0 broken file links and 0 broken anchors across all root docs and
+  `docs/**` (excluding `docs/superpowers/`, untouched — 26 files intact). Also
+  confirmed nothing in the repo still links to README anchors I removed
+  (`#cli-reference`, `#install`, `#validation-status`).
+
+## Two `src/` bugs — found during the audit, fixed in a follow-up
+
+Both were cases where the CLI printed a copy-pasteable command that does not
+work. Initially reported as out-of-scope (the docs dispatch excluded `src/`), then
+fixed on explicit follow-up instruction.
+
+### 1. Scan suggested a `diagnose` command that fails
+
+`src/cli/incident-summary.ts` emitted
+``Investigate: `crisismode diagnose ${first.id}` `` using a finding id such as
+`PG-001`. `diagnose` resolves its positional as a **target name**, so the
+suggested command died with `Target "PG-001" not found in config`.
+
+The nuance that made this more than a one-liner: `runDiagnose` *does* special-case
+`/^PLUG-(\d+)$/i` and route it to a check plugin's diagnose verb by index. So the
+old hint was correct for plugin findings and broken for every agent finding — a
+blanket replacement would have broken the working half.
+
+Fix: extracted `diagnoseCommandFor(finding)`, which keeps the id for `PLUG-*`,
+otherwise uses the target name (the trailing parenthesized group of scan's
+`${kind} (${target.name})` service string), and falls back to bare
+`crisismode diagnose` when no name is recoverable — never a dead end.
+
+Two existing tests asserted the broken output (`toContain('crisismode diagnose
+PG-001')`) using fixtures whose `service` had no parenthesized target, which is
+not a shape real scan produces. Fixtures made realistic, assertions corrected, and
+6 dedicated tests added for the helper.
+
+### 2. Scan suggested a flag that does not exist
+
+`src/cli/commands/scan.ts` printed
+`scaffold one with: crisismode init --plugin my-check`. `--plugin` is not
+recognized: it falls through to the positional path argument and writes a *config
+file* named `my-check` instead of scaffolding a plugin. Corrected to `--agent`,
+which I verified produces `manifest.json` + an executable `check.sh`.
+
+### Verification
+
+`pnpm run typecheck`, `pnpm run lint`, and `pnpm test` (3179 passed / 24 skipped,
+0 failures) all clean, then rebuilt and confirmed at the real surface:
+
+- Failing check-plugin fixture → `Investigate: crisismode diagnose PLUG-001`, and
+  that command runs the plugin's diagnose verb.
+- PostgreSQL target on a wrong port → `Investigate: crisismode diagnose prod-db`,
+  and `diagnose prod-db` resolves (`Target: prod-db (postgresql)`) while the old
+  `diagnose PG-001` still errors.
+- Scan with no plugins discovered → hint now reads `crisismode init --agent my-check`.
+
+## Noted, not changed
+
+`specs/foundational/recovery-agent-contract.md` was not modified. An anchor there
+initially looked broken but is valid — GitHub's em-dash slugging produces the
+double hyphen the link uses.
+
+## Not drifted
+
+Audited and found accurate, so left alone: `docs/readiness.md` (already the
+strongest honesty document in the repo — 8 rules, thresholds, and its uncovered
+validation paths all verified correct), the check-plugin wire protocol in
+`docs/guides/your-first-check-plugin.md` (matches the live scaffold's manifest
+and verb handling), and `docs/agents/backup-verification.md` (all commands valid).
diff --git a/docs/guides/creating-a-recovery-agent.md b/docs/guides/creating-a-recovery-agent.md
index 939efec..c5d7efc 100644
--- a/docs/guides/creating-a-recovery-agent.md
+++ b/docs/guides/creating-a-recovery-agent.md
@@ -197,7 +197,7 @@ export const mySystemManifest: AgentManifest = {
 **`metadata`** -- identity and authorship:
 - `name` -- unique agent name, used as the registry key.
 - `version` -- semver version of the agent.
-- `plugin.maturity` -- set to `"simulator_only"` until a live client exists; change to `"beta"` or `"stable"` later.
+- `plugin.maturity` -- one of `"experimental"`, `"simulator_only"`, `"dry_run_only"`, `"live_validated"`, `"production_certified"`. Start at `"simulator_only"`; CrisisMode reports every value except `"live_validated"` as best-effort, and only real validation against a live system earns the upgrade. See [Declaring maturity honestly](../../CONTRIBUTING.md#declaring-maturity-honestly).
 
 **`spec.targetSystems`** -- what systems this agent manages:
 ```typescript
diff --git a/docs/guides/your-first-agent.md b/docs/guides/your-first-agent.md
index b5babd8..140f64e 100644
--- a/docs/guides/your-first-agent.md
+++ b/docs/guides/your-first-agent.md
@@ -275,7 +275,7 @@ export const websiteManifest: AgentManifest = {
 
 ### Important manifest fields
 
-- **`plugin.maturity`** -- set to `"simulator_only"` until you build a live client. Change to `"beta"` or `"stable"` later.
+- **`plugin.maturity`** -- one of `"experimental"`, `"simulator_only"`, `"dry_run_only"`, `"live_validated"`, `"production_certified"`. Start at `"simulator_only"` and only move up when you have actually validated against a real system -- CrisisMode reports anything other than `"live_validated"` as best-effort, which is deliberate. See [Declaring maturity honestly](../../CONTRIBUTING.md#declaring-maturity-honestly).
 - **`riskProfile.maxRiskLevel`** -- the maximum risk any step in your plans can declare. Do not set to `"critical"` without discussion with maintainers.
 - **`failureScenarios`** -- string identifiers that your `diagnose()` method returns. The framework uses these to match agents to incidents.
 
@@ -769,7 +769,12 @@ Two rules the helper enforces (and that you must not work around):
   not connect" finding. Never catch a live-client error and silently fall
   back to simulated data — that reports fake health for a real system.
 
-Update the manifest's `plugin.maturity` from `"simulator_only"` to `"beta"` once the live client is working.
+A working live client on its own does **not** change your maturity label. Once you
+have run the agent against a real deployment and confirmed it diagnoses correctly,
+move `plugin.maturity` to `"dry_run_only"` (diagnosis validated, no mutating run
+verified) or `"live_validated"` (a mutating recovery actually ran and the fault
+was verified resolved). Until then it stays `"simulator_only"` and CrisisMode
+labels its findings as leads.
 
 ## Distributing as a Plugin
 
diff --git a/docs/playbook-authoring.md b/docs/playbook-authoring.md
index 4f98819..3d95e8b 100644
--- a/docs/playbook-authoring.md
+++ b/docs/playbook-authoring.md
@@ -120,6 +120,13 @@ Capture system state before mutations. The framework snapshots the configured ta
 ### `system_action`
 Execute a command that mutates system state. Must declare `risk` and `capability`; at `elevated` risk or higher must also declare `preserve` (state captured before the step runs, blocking on failure). Should have `precondition`, `success`, and `blast_radius`. Include a code block with the command. `crisismode playbook validate` runs the compiled plan through the same safety validator as code-based agents and reports exactly which rule a step violates.
 
+`capability` values must be ids that are already registered in
+`src/framework/capability-registry.ts` — for example `db.query.read`,
+`db.replica.disconnect`, `cache.expiry.trigger`, `k8s.node.drain`,
+`queue.workers.restart`. An unregistered id fails validation with
+`Missing capabilities on steps: <step-id>`, which is the most common reason a
+playbook parses but will not validate.
+
 ### `human_approval`
 Pause execution until a human approves. Set `timeout` and `escalation`. The body text is shown to the approver as context.
 
@@ -247,6 +254,7 @@ redis-cli info memory
 ### 4. Evict expired keys
 - type: system_action
 - risk: routine
+- capability: cache.expiry.trigger
 - target: redis-primary
 - precondition: "Redis is accepting commands"
 - success: "Memory usage below 85%"

From d9618468c606d63ded977c656f1d3bc2501eee7e Mon Sep 17 00:00:00 2001
From: trs-80 <109326+trs-80@users.noreply.github.com>
Date: Sun, 9 Aug 2026 12:01:07 -0400
Subject: [PATCH 04/17] chore(demo): re-record against live AI diagnosis
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

record-demo.sh ran under `env -u ANTHROPIC_API_KEY` so the capture was
offline and deterministic. That also meant the recording showed the
rule-based fallback — a fixed 92% confidence with three findings and no root
cause — rather than the product's actual AI path.

Recording now runs with the live key against the default model (sonnet-5,
no CRISISMODE_AI_MODEL override) so it shows what a user gets out of the box:
replication_lag_cascade at 78% with a model-authored root-cause paragraph and
six recommendations. 56.2s, 314 events.

The trade-off is stated in the script header: the recording makes a live API
call and is no longer byte-reproducible. pace-cast.mjs now caps idle gaps at
4s so the real 28-56s model wait does not ship as a frozen frame — the cast
was already re-timed for readability rather than real-time, and the header
documents the cap.

The GIF teaser is generated by the same script but not committed here; it
exceeds the repo's 1MB pre-commit ceiling.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 scripts/pace-cast.mjs  | 170 ++++++++++++++++++++++
 scripts/record-demo.sh | 181 +++++++++++++++++++++++
 site/assets/demo.cast  | 315 +++++++++++++++++++++++++++++++++++++++++
 3 files changed, 666 insertions(+)
 create mode 100644 scripts/pace-cast.mjs
 create mode 100644 scripts/record-demo.sh
 create mode 100644 site/assets/demo.cast

diff --git a/scripts/pace-cast.mjs b/scripts/pace-cast.mjs
new file mode 100644
index 0000000..dcc6845
--- /dev/null
+++ b/scripts/pace-cast.mjs
@@ -0,0 +1,170 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 CrisisMode Contributors
+
+/**
+ * Re-time an asciicast v3 recording so it is readable as a web asset.
+ *
+ * WHY: `crisismode demo` sleeps between its 10 phases but emits each phase's
+ * output in a single instantaneous write. Phase 9 (execution) dumps 82 lines at
+ * once, so in a 24-30 row window everything except the last screenful scrolls
+ * past in a single frame and can never be read.
+ *
+ * WHAT THIS DOES: splits multi-line output events into one event per line and
+ * assigns each a delay, so output streams at reading speed.
+ *
+ * WHAT THIS DOES NOT DO: it never alters a single byte of output content. Step
+ * durations the demo prints (e.g. "SUCCESS (1ms)") remain the real measured
+ * values — only the delay between lines arriving is synthesized.
+ *
+ * IDLE GAPS ARE CAPPED at MAX_IDLE_GAP (4s). Original gaps are otherwise a
+ * floor and never shortened, so the demo's own deliberate pauses and the
+ * operator's typing cadence survive untouched — but the live AI diagnosis call
+ * in Phase 5 really does take 28-40s, and a frozen frame that long reads as a
+ * hung page rather than a pause. The cast is already fully re-timed for
+ * readability, so it was never a real-time artifact; clamping one dead gap is
+ * consistent with that. The true latency is reported by whoever records, not
+ * implied by the playback.
+ *
+ * Usage: node scripts/pace-cast.mjs <in.cast> <out.cast>
+ */
+
+import { readFileSync, writeFileSync } from 'node:fs';
+
+// ── Pacing model (seconds) ───────────────────────────────────────────────
+const DELAY = {
+  /** Ordinary content line. */
+  line: 0.1,
+  /** Blank line — a beat, not a full line. */
+  blank: 0.05,
+  /** Box-drawing rule; part of a heading, should land with it. */
+  rule: 0.04,
+  /** Before a `Phase N:` heading — the main structural beat. */
+  phase: 0.85,
+  /** Before an execution step heading. */
+  step: 0.45,
+  /** Before a finding/result marker line. */
+  marker: 0.16,
+};
+
+/**
+ * Ceiling on any single gap between events. Sized above the longest deliberate
+ * pause in the expect driver (2.5s to read the approval panel, 2.5s to hold the
+ * final frame) so those survive untouched, and below the live AI call's real
+ * 28-40s so that one becomes a readable beat instead of a stall.
+ */
+const MAX_IDLE_GAP = 4.0;
+
+const ANSI = /\x1b\[[0-9;]*[A-Za-z]/g;
+
+function stripAnsi(text) {
+  return text.replace(ANSI, '');
+}
+
+/**
+ * An output event is left at its original timing if it looks like interactive
+ * echo (the operator typing at the approval gate) rather than program output:
+ * no newline and only a few characters.
+ */
+function isTypingEcho(data) {
+  return !data.includes('\n') && stripAnsi(data).length <= 3;
+}
+
+function delayForLine(line) {
+  // Strip ANSI so the classifiers match on visible text.
+  const plain = stripAnsi(line);
+  const trimmed = plain.trim();
+
+  if (trimmed === '') return DELAY.blank;
+  if (/^[─═│┌┐└┘├┤┬┴┼]+$/.test(trimmed)) return DELAY.rule;
+  if (/^Phase \d+:/.test(trimmed)) return DELAY.phase;
+  if (/^Step step-/.test(trimmed)) return DELAY.step;
+  if (/^[✓✗●◆◇◈↻⚠→•]/.test(trimmed) || /^\[(CRITICAL|WARNING|INFO)\]/.test(trimmed)) {
+    return DELAY.marker;
+  }
+  return DELAY.line;
+}
+
+const [, , inPath, outPath] = process.argv;
+if (!inPath || !outPath) {
+  console.error('usage: node scripts/pace-cast.mjs <in.cast> <out.cast>');
+  process.exit(1);
+}
+
+const raw = readFileSync(inPath, 'utf8').trim().split('\n');
+const header = JSON.parse(raw[0]);
+if (header.version !== 3) {
+  console.error(`pace-cast: expected asciicast v3, got version ${header.version}`);
+  process.exit(1);
+}
+
+// The capture runs through a temp expect driver, so the recorded `command` is a
+// throwaway /var/folders path. Replace it with the command it actually drove.
+header.command = 'crisismode demo';
+
+const out = [JSON.stringify(header)];
+let originalWall = 0;
+let pacedWall = 0;
+let splitCount = 0;
+let cappedCount = 0;
+let longestOriginalGap = 0;
+
+for (const rawLine of raw.slice(1)) {
+  if (!rawLine.trim()) continue;
+  const event = JSON.parse(rawLine);
+  const [interval, code, data] = event;
+  originalWall += interval;
+  if (interval > longestOriginalGap) longestOriginalGap = interval;
+  if (interval > MAX_IDLE_GAP) cappedCount += 1;
+
+  if (code !== 'o' || isTypingEcho(data) || !data.includes('\n')) {
+    const gap = Math.min(interval, MAX_IDLE_GAP);
+    out.push(JSON.stringify([Number(gap.toFixed(3)), code, data]));
+    pacedWall += gap;
+    continue;
+  }
+
+  // Split on newline, keeping the terminator attached to its line so the
+  // reconstructed stream is byte-identical to the original.
+  const chunks = data.split(/(?<=\n)/);
+  splitCount += 1;
+
+  let first = true;
+  for (const chunk of chunks) {
+    if (chunk === '') continue;
+    // The original gap is a floor: never speed the recording up — except that
+    // no single gap may exceed MAX_IDLE_GAP.
+    const paced = delayForLine(chunk);
+    const gap = first ? Math.min(Math.max(interval, paced), MAX_IDLE_GAP) : paced;
+    out.push(JSON.stringify([Number(gap.toFixed(3)), 'o', chunk]));
+    pacedWall += gap;
+    first = false;
+  }
+}
+
+writeFileSync(outPath, out.join('\n') + '\n');
+
+// Verify content is unchanged — pacing must be timing-only.
+const bytesOf = (path) =>
+  readFileSync(path, 'utf8')
+    .trim()
+    .split('\n')
+    .slice(1)
+    .filter((l) => l.trim())
+    .map((l) => JSON.parse(l))
+    .filter((e) => e[1] === 'o')
+    .map((e) => e[2])
+    .join('');
+
+if (bytesOf(inPath) !== bytesOf(outPath)) {
+  console.error('pace-cast: FAILED — output bytes differ from input; refusing to ship');
+  process.exit(1);
+}
+
+console.log(
+  `pace-cast: ${originalWall.toFixed(1)}s -> ${pacedWall.toFixed(1)}s ` +
+    `(${splitCount} bursts split, output bytes verified identical)`,
+);
+console.log(
+  `pace-cast: longest original gap ${longestOriginalGap.toFixed(1)}s; ` +
+    `${cappedCount} gap(s) capped at ${MAX_IDLE_GAP}s`,
+);
diff --git a/scripts/record-demo.sh b/scripts/record-demo.sh
new file mode 100644
index 0000000..6310a8e
--- /dev/null
+++ b/scripts/record-demo.sh
@@ -0,0 +1,181 @@
+#!/usr/bin/env bash
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 CrisisMode Contributors
+#
+# Record `crisismode demo` as an asciinema cast (+ GIF fallback) for the website.
+#
+# The demo blocks on stdin at the human_approval gate, so the run is driven by
+# expect: it waits for the prompt and types the decision with human-like timing.
+#
+# THIS RECORDING MAKES A LIVE ANTHROPIC API CALL. Phase 5 runs the real AI
+# diagnosis, so ANTHROPIC_API_KEY must be exported in the environment or the
+# demo silently falls back to rule-based heuristics and the capture is wrong.
+# Consequences of that being live:
+#   - The cast is NOT byte-reproducible. The model's root cause, findings and
+#     confidence differ on every run; so does the wall-clock latency (measured
+#     28-40s for claude-sonnet-5 against this prompt).
+#   - The result is pace-adjusted afterwards by scripts/pace-cast.mjs, which
+#     re-times every line for readability and clamps any single idle gap to 4s.
+#     Output bytes are never altered; only timing is synthesized.
+#   - Do not set CRISISMODE_AI_MODEL here. The demo must show the
+#     out-of-the-box path, which is whatever ai-model.ts defaults to.
+# After recording, confirm the cast really shows model reasoning rather than the
+# fallback — the rule-based path prints a fixed 92%-confidence three-finding
+# diagnosis, so a cast that matches it byte-for-byte across runs is a red flag.
+#
+# Usage: bash scripts/record-demo.sh [approve|skip|reject]
+
+set -euo pipefail
+
+DECISION="${1:-approve}"
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+OUT_DIR="$REPO_ROOT/site/assets"
+CAST="$OUT_DIR/demo.cast"
+# The unpaced capture is a build artifact, not a site asset — keep it out of
+# site/assets so it is not published. /output/ is gitignored.
+RAW_CAST="$REPO_ROOT/output/demo.raw.cast"
+GIF="$OUT_DIR/demo.gif"
+
+# 100 cols keeps the demo's 72-char rules and plan table intact while limiting
+# how often the long prose lines (risk/what descriptions) wrap.
+COLS=100
+ROWS=30
+
+for tool in asciinema agg expect; do
+  command -v "$tool" >/dev/null 2>&1 || {
+    echo "error: '$tool' not found. Install with: brew install asciinema agg" >&2
+    exit 1
+  }
+done
+
+[ -f "$REPO_ROOT/dist/cli/index.js" ] || {
+  echo "error: dist/cli/index.js missing. Run 'pnpm run build' first." >&2
+  exit 1
+}
+
+# Fail fast rather than ship a cast that quietly shows the rule-based fallback:
+# a missing key is indistinguishable from a working recording until someone
+# reads the diagnosis text closely.
+[ -n "${ANTHROPIC_API_KEY:-}" ] || {
+  echo "error: ANTHROPIC_API_KEY is not set. This recording requires a live AI" >&2
+  echo "       diagnosis; without the key the demo falls back to rule-based" >&2
+  echo "       heuristics and the capture would misrepresent the product." >&2
+  exit 1
+}
+
+mkdir -p "$OUT_DIR" "$(dirname "$RAW_CAST")"
+
+DRIVER="$(mktemp -t crisismode-demo-driver).exp"
+trap 'rm -f "$DRIVER"' EXIT
+
+cat > "$DRIVER" <<EXPECT_SCRIPT
+#!/usr/bin/env expect -f
+# Drives the demo through its interactive approval gate.
+#
+# 180s still has room after the move to live AI: the diagnosis call is bounded
+# at 60s by the framework's own deadline (src/framework/ai-diagnosis.ts) and the
+# rest of the run to the approval prompt takes ~15s, so the worst case is ~75s.
+set timeout 180
+# Human-like typing: avg 90ms/char, 20ms stddev, 0.2 min, 0.4s at word end.
+set send_human {0.09 0.02 1 0.20 0.40}
+
+# A beat before the first keystroke so the recording does not open mid-command.
+sleep 1.2
+spawn -noecho node "$REPO_ROOT/dist/cli/index.js" demo
+expect {
+  -re {Enter your decision \(approve/skip/reject\): } {
+    # Let the viewer read the approval panel before answering.
+    sleep 2.5
+    send -h -- "$DECISION"
+    sleep 0.6
+    send -- "\r"
+  }
+  timeout { puts stderr "\nrecord-demo: timed out waiting for approval prompt"; exit 1 }
+  eof     { puts stderr "\nrecord-demo: demo exited before approval prompt"; exit 1 }
+}
+expect eof
+# Hold on the final frame so the summary is readable at the end of the loop.
+sleep 2.5
+EXPECT_SCRIPT
+
+chmod +x "$DRIVER"
+
+echo "==> recording ${COLS}x${ROWS} -> $RAW_CAST"
+rm -f "$RAW_CAST"
+
+# ANTHROPIC_API_KEY is inherited deliberately: Phase 5 must reach the real API.
+env TERM=xterm-256color \
+    FORCE_COLOR=3 \
+    COLUMNS="$COLS" \
+    LINES="$ROWS" \
+  asciinema rec "$RAW_CAST" \
+    --window-size "${COLS}x${ROWS}" \
+    --overwrite \
+    --return \
+    --title "crisismode demo — PostgreSQL replication lag cascade recovery" \
+    --command "$DRIVER"
+
+# The demo emits each phase in one instantaneous write, so re-time the cast to
+# reading speed. Timing only — pace-cast verifies output bytes are unchanged.
+echo "==> pacing -> $CAST"
+node "$REPO_ROOT/scripts/pace-cast.mjs" "$RAW_CAST" "$CAST"
+
+# Theme matched to the site palette in site/index.html (--bg-primary, --amber,
+# --red, --green, --cyan) so the GIF sits in the page without clashing.
+THEME="0a0a0b,e4e4e7,27272a,ef4444,22c55e,f59e0b,3b82f6,ec4899,06b6d4,e4e4e7,52525b,f87171,4ade80,fbbf24,60a5fa,f472b6,22d3ee,fafafa"
+
+# The GIF is a fallback/social teaser, not the whole story: a full-length 100x30
+# GIF is >7MB at any usable quality. Cover the opening arc (alert -> diagnosis ->
+# plan table) and let the player carry the rest.
+#
+# The cut point is found in the cast rather than fixed at a percentage: the live
+# AI diagnosis varies in length run to run, so a percentage lands somewhere
+# different every time (36% used to reach the plan table; with a wordier model
+# response it stops short of it). Anchor on the Phase 7 heading instead, which
+# is exactly where the plan table ends.
+CUT="$(node -e '
+const fs = require("node:fs");
+const lines = fs.readFileSync(process.argv[1], "utf8").trim().split("\n").slice(1);
+let t = 0;
+let cut = null;
+for (const line of lines) {
+  if (!line.trim()) continue;
+  const [interval, code, data] = JSON.parse(line);
+  t += interval;
+  if (code === "o" && String(data).replace(/\x1b\[[0-9;]*[A-Za-z]/g, "").includes("Phase 7:")) {
+    // A beat past the heading so the transition is visible in the last frame.
+    cut = t + 0.8;
+    break;
+  }
+}
+if (cut === null) {
+  console.error("record-demo: could not find the Phase 7 heading; cannot place the GIF cut");
+  process.exit(1);
+}
+process.stdout.write(cut.toFixed(2));
+' "$CAST")"
+
+# 6fps, not 10: the wider window needed to reach the plan table past a live AI
+# diagnosis renders at 4.4MB at 10fps. 6fps holds it under 3MB and text output
+# stays legible — nothing is lost, the reveal is just less smooth.
+echo "==> rendering GIF teaser (0..${CUT}s) -> $GIF"
+agg -q \
+  --select "0..$CUT" \
+  --fps-cap 6 \
+  --font-size 14 \
+  --line-height 1.4 \
+  --theme "$THEME" \
+  "$CAST" "$GIF"
+
+# The teaser is embedded in the landing page, so guard the budget out loud
+# rather than discovering a 5MB GIF in production.
+GIF_BYTES="$(wc -c < "$GIF" | tr -d ' ')"
+if [ "$GIF_BYTES" -gt 3145728 ]; then
+  echo "warning: GIF is $((GIF_BYTES / 1024))KiB, over the ~3MB budget." >&2
+  echo "         Lower --fps-cap or --font-size, or shorten the window." >&2
+fi
+
+echo
+echo "done:"
+ls -lh "$CAST" "$GIF" | awk '{print "  " $5 "\t" $9}'
+echo "  (raw unpaced capture kept at $RAW_CAST)"
diff --git a/site/assets/demo.cast b/site/assets/demo.cast
new file mode 100644
index 0000000..d290731
--- /dev/null
+++ b/site/assets/demo.cast
@@ -0,0 +1,315 @@
+{"version":3,"term":{"cols":100,"rows":30},"timestamp":1786289836,"command":"crisismode demo","title":"crisismode demo — PostgreSQL replication lag cascade recovery","env":{"SHELL":"/bin/zsh"}}
+[1.45,"o","\r\r\n"]
+[0.04,"o","\u001b[2m════════════════════════════════════════════════════════════════════════\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[1m\u001b[31m  ⚠  CRISISMODE — Recovery Agent Framework Demo\u001b[39m\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m  Recovery Agent Contract Specification v0.2.1\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m  PostgreSQL Replication Lag Cascade Recovery\u001b[22m\r\r\n"]
+[0.04,"o","\u001b[2m════════════════════════════════════════════════════════════════════════\u001b[22m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.1,"o","\u001b[2m  This demo walks through the full execution flow of the Recovery Agent\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m  Contract using a simulated PostgreSQL replication recovery scenario.\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m  All system interactions are simulated — no real databases are touched.\u001b[22m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.501,"o","\r\r\n"]
+[0.04,"o","\u001b[2m────────────────────────────────────────────────────────────────────────\u001b[22m\r\r\n"]
+[0.85,"o","\u001b[1m\u001b[36m  Phase 1: Trigger\u001b[39m\u001b[22m\r\r\n"]
+[0.04,"o","\u001b[2m────────────────────────────────────────────────────────────────────────\u001b[22m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.1,"o","\u001b[1m\u001b[37m  1. Prometheus alert fires\u001b[39m\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[1m\u001b[33m     ALERT FIRED\u001b[39m\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[33m     Source:  prometheus\u001b[39m\r\r\n"]
+[0.1,"o","\u001b[33m     Type:    alert\u001b[39m\r\r\n"]
+[0.1,"o","\u001b[33m     Label:   alertname=PostgresReplicationLagCritical\u001b[39m\r\r\n"]
+[0.1,"o","\u001b[33m     Time:    2026-08-09T15:37:18.237Z\u001b[39m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.302,"o","\r\r\n"]
+[0.04,"o","\u001b[2m────────────────────────────────────────────────────────────────────────\u001b[22m\r\r\n"]
+[0.85,"o","\u001b[1m\u001b[36m  Phase 2: Pre-Authorized Catalog Check\u001b[39m\u001b[22m\r\r\n"]
+[0.04,"o","\u001b[2m────────────────────────────────────────────────────────────────────────\u001b[22m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.1,"o","\u001b[1m\u001b[37m  2. Checking pre-authorized action catalogs\u001b[39m\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     Catalog ID:   pg-replication-standard-recovery\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     Name:         Standard PostgreSQL Replication Recovery\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     Approved by:  jane.chen@example.com\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     Expires:      2026-05-15T10:00:00Z\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     Covers:       routine, elevated risk levels\u001b[22m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.16,"o","\u001b[32m     ✓ Catalog entry found for this scenario\u001b[39m\r\r\n"]
+[0.302,"o","\r\r\n"]
+[0.04,"o","\u001b[2m────────────────────────────────────────────────────────────────────────\u001b[22m\r\r\n"]
+[0.85,"o","\u001b[1m\u001b[36m  Phase 3: Agent Selection\u001b[39m\u001b[22m\r\r\n"]
+[0.04,"o","\u001b[2m────────────────────────────────────────────────────────────────────────\u001b[22m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.1,"o","\u001b[1m\u001b[37m  3. Selecting recovery agent based on trigger\u001b[39m\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     Agent:        postgresql-replication-recovery v1.2.0\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     Description:  Recovers PostgreSQL streaming replication failures including lag cascades, slot overflow, and replica divergence.\u001b[22m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.16,"o","\u001b[32m     ✓ Agent selected: trigger matches manifest conditions\u001b[39m\r\r\n"]
+[0.302,"o","\r\r\n"]
+[0.04,"o","\u001b[2m────────────────────────────────────────────────────────────────────────\u001b[22m\r\r\n"]
+[0.85,"o","\u001b[1m\u001b[36m  Phase 4: Context Assembly\u001b[39m\u001b[22m\r\r\n"]
+[0.04,"o","\u001b[2m────────────────────────────────────────────────────────────────────────\u001b[22m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.1,"o","\u001b[1m\u001b[37m  4. Assembling agent context from trigger and topology\u001b[39m\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     Topology:\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m       pg-primary-us-east-1         \u001b[22m\u001b[33mdegraded    \u001b[39m\u001b[2mprimary\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m       pg-replica-us-east-1a        \u001b[22m\u001b[33mdegraded    \u001b[39m\u001b[2mreplica\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m       pg-replica-us-east-1b        \u001b[22m\u001b[31munhealthy   \u001b[39m\u001b[2mreplica\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m       pg-replica-us-east-1c        \u001b[22m\u001b[33mdegraded    \u001b[39m\u001b[2mreplica\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m       haproxy-us-east-1            \u001b[22m\u001b[32mhealthy     \u001b[39m\u001b[2mload_balancer\u001b[22m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.1,"o","\u001b[2m     Trust level:  copilot (scenario override: autopilot)\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     Layers:       L1=available, L2=available, L3=unavailable, L4=available\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     Policies:     requireApprovalForAllElevated=false\u001b[22m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.305,"o","\r\r\n"]
+[0.04,"o","\u001b[2m────────────────────────────────────────────────────────────────────────\u001b[22m\r\r\n"]
+[0.85,"o","\u001b[1m\u001b[36m  Phase 5: Diagnosis\u001b[39m\u001b[22m\r\r\n"]
+[0.04,"o","\u001b[2m────────────────────────────────────────────────────────────────────────\u001b[22m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.1,"o","\u001b[1m\u001b[37m  5. Agent performing read-only investigation\u001b[39m\u001b[22m\r\r\n"]
+[4,"o","\u001b[2m     Status:      \u001b[22m\u001b[32midentified\u001b[39m\r\r\n"]
+[0.1,"o","\u001b[2m     Scenario:    replication_lag_cascade\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     Confidence:  78%\u001b[22m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.001,"o","\u001b[36m     Root cause:  \u001b[39m\u001b[37mAll three replicas are behind the same sent_lsn (0/5000000), but each is behind by a different and substantial margin, with lag_seconds climbing from 45s to 78s to 342s in lockstep with increasing LSN gaps at the write/flush/replay stages. Because every replica is affected rather than a single outlier, this points to a primary-side condition — most likely a sustained spike in WAL generation (heavy write/DML load, consistent with the 247 active sessions on the primary) that is outpacing the replicas' ability to receive, write, and apply WAL. The weakest replica (10.0.1.52) is falling behind even at the write stage (write_lsn 0/3000000 vs sent 0/5000000), suggesting it also has a secondary bottleneck (network throughput or disk I/O) that is amplifying the shared primary-side pressure. Replication slots are still 'reserved' (not 'lost'), so WAL has not yet been recycled out from under any replica, but if lag continues to grow at this rate, especially on 10.0.1.52, WAL retention"]
+[0.1,"o"," risk will escalate quickly.\u001b[39m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.1,"o","\u001b[36m     Recommendations:\u001b[39m\r\r\n"]
+[0.1,"o","\u001b[2m       - Check current WAL generation rate on the primary (pg_stat_wal or pg_current_wal_lsn delta over time) to confirm a write/DML volume spike is driving the cascade.\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m       - Inspect primary pg_stat_activity for the top write-heavy queries/transactions among the 247 active connections that may be generating excessive WAL.\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m       - Check network throughput/latency and disk I/O saturation specifically on 10.0.1.52, since it lags even at the write stage — this replica likely has an independent bottleneck.\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m       - Monitor pg_replication_slots restart_lsn vs current WAL location closely; if the gap keeps growing, increase wal_keep_size or add slot retention headroom to avoid transitioning to wal_status 'lost'.\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m       - If read traffic is being redirected to the primary due to replica lag, verify load balancer/read-routing logic isn't creating a feedback loop that increases primary load fu"]
+[0,"o","rther.\u001b"]
+[0.1,"o","[22m\r\r\n"]
+[0.1,"o","\u001b[2m       - If lag continues to widen despite normal WAL rate, consider throttling or batching bulk write operations on the primary until replicas catch up.\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m       - Re-check pg_is_wal_replay_paused() and replica system metrics (CPU, disk, network) directly on 10.0.1.52 to rule out a replica-local resource constraint.\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m       - Once WAL generation rate and replica I/O are confirmed healthy, allow replicas time to catch up and re-measure lag_seconds trend before declaring resolution.\u001b[22m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.16,"o","\u001b[31m     [CRITICAL] \u001b[39m\u001b[2mpg_stat_replication: All three replicas share the same sent_lsn but show escalating lag (45s, 78s, 342s), indicating a systemic primary-side WAL generation or fan-out issue rather than an isolated replica fault.\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[31m     [CRITICAL] \u001b[39m\u001b[2mpg_stat_replication: Replica 10.0.1.52 lags not only in replay but also in write/flush stages, meaning it is failing to even receive/persist WAL at the rate the primary is sending it — a compounding replica-side (net"]
+[0,"o","work o"]
+[0.1,"o","r disk) constraint on top of the primary-side pressure.\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[33m     [WARNING] \u001b[39m\u001b[2mpg_stat_replication: Replicas 10.0.1.50 and 10.0.1.51 are current at write/flush but lag noticeably at replay, showing replay itself is the bottleneck for the healthier nodes.\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[2m     [INFO] \u001b[22m\u001b[2mpg_replication_slots: All slots report wal_status 'reserved', meaning WAL has not yet been recycled out from under any replica — no immediate slot-overflow risk, but this could change if the trend continues, especially for the slot behind 10.0.1.52.\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[2m     [INFO] \u001b[22m\u001b[2mReplica self-reported state: pg_is_wal_replay_paused() explicitly reports false, ruling out a deliberate or stuck replay pause as the cause of lag.\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[33m     [WARNING] \u001b[39m\u001b[2mpg_stat_activity / connection pool: Primary shows 247 active connections while the connection pool usage metric shows only 4/25 in use with no idle-in-transaction sessions, so connection pool exhaustion is not indicated at this layer — but the raw active"]
+[0,"o","-ses"]
+[0.1,"o","sion count on the primary is notably high and consistent with heavy write throughput driving WAL volume.\u001b[22m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.16,"o","\u001b[32m     ✓ Diagnosis complete: replication_lag_cascade (78% confidence)\u001b[39m\r\r\n"]
+[0.304,"o","\r\r\n"]
+[0.04,"o","\u001b[2m────────────────────────────────────────────────────────────────────────\u001b[22m\r\r\n"]
+[0.85,"o","\u001b[1m\u001b[36m  Phase 6: Plan Creation\u001b[39m\u001b[22m\r\r\n"]
+[0.04,"o","\u001b[2m────────────────────────────────────────────────────────────────────────\u001b[22m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.1,"o","\u001b[1m\u001b[37m  6. Agent building recovery plan\u001b[39m\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     Plan ID:      rp-20260809153749-pg-repl-001\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     Duration:     PT15M\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     Summary:      Recover PostgreSQL replication by disconnecting lagging replica 10.0.1.52, stabilizing the primary, and re-syncing.\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     Rollback:     stepwise\u001b[22m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.1,"o","\u001b[2m     \u001b[22m\u001b[1m#   \u001b[22m\u001b[1mType                    \u001b[22m\u001b[1mRisk        \u001b[22m\u001b[1mName\u001b[22m\r\r\n"]
+[0.04,"o","\u001b[2m     ────────────────────────────────────────────────────────────────────\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     \u001b[22m1   diagnosis_action        \u001b[2m—           \u001b[22mAssess current replication lag across all replicas\r\r\n"]
+[0.1,"o","\u001b[2m     \u001b[22m2   human_notification      \u001b[2m—           \u001b[22mNotify on-call DBA of replication recovery initiation\r\r\n"]
+[0.1,"o","\u001b[2m     \u001b[22m3   checkpoint              \u001b[2m—           \u001b[22mPre-recovery checkpoint\r\r\n"]
+[0.1,"o","\u001b[2m     \u001b[22m4   system_action           \u001b[33melevated    \u001b[39mDisconnect lagging replica 10.0.1.52 from replication\r\r\n"]
+[0.1,"o","\u001b[2m          what:  Terminates the WAL sender process for pg-replica-10-0-1-52 to prevent the primary from being blocked by a slow consumer.\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[33m          risk:  \u001b[39m\u001b[2mThis changes a live system. Affects: pg-replica-10-0-1-52, read-pool. Worst case: single_replica_disconnected.\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m          undo:  Replica will automatically attempt to reconnect. No explicit rollback needed.\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     \u001b[22m5   system_action           \u001b[32mroutine     \u001b[39mRedirect read traffic away from disconnected replica\r\r\n"]
+[0.1,"o","\u001b[2m     \u001b[22m6   replanning_checkpoint   \u001b[2m—           \u001b[22mAssess recovery progress before proceeding\r\r\n"]
+[0.1,"o","\u001b[2m     \u001b[22m7   human_approval          \u001b[2m—           \u001b[22mApprove replica resynchronization\r\r\n"]
+[0.1,"o","\u001b[2m     \u001b[22m8   system_action           \u001b[31mhigh        \u001b[39mInitiate pg_basebackup and re-establish replication for 10.0.1.52\r\r\n"]
+[0.1,"o","\u001b[2m          what:  Performs a full base backup from the primary to pg-replica-10-0-1-52 and configures streaming replication.\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[33m          risk:  \u001b[39m\u001b[2mThis makes a significant change to a live system — a mistake here causes real downtime. Affects: pg-replica-10-0-1-52, pg-primary-us-east-1, read-pool. Worst case: increased_primary_io_load_during_basebackup.\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m          undo:  If pg_basebackup fails, manual intervention required to restart the process.\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     \u001b[22m9   conditional             \u001b[2m—           \u001b[22mRestore traffic or notify for manual intervention\r\r\n"]
+[0.1,"o","\u001b[2m     \u001b[22m10  human_notification      \u001b[2m—           \u001b[22mSend recovery summary\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.1,"o","\u001b[2m     Impact:\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m       pg-primary-us-east-1 (primary): reduced_read_capacity\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m       pg-replica-10-0-1-52 (replica): temporary_unavailability\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     User impact:  Read queries may experience elevated latency during recovery. No write impact expected.\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     Data loss:    none\u001b[22m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.302,"o","\r\r\n"]
+[0.04,"o","\u001b[2m────────────────────────────────────────────────────────────────────────\u001b[22m\r\r\n"]
+[0.85,"o","\u001b[1m\u001b[36m  Phase 7: Plan Validation\u001b[39m\u001b[22m\r\r\n"]
+[0.04,"o","\u001b[2m────────────────────────────────────────────────────────────────────────\u001b[22m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.1,"o","\u001b[1m\u001b[37m  7. Framework validating plan against manifest and policies\u001b[39m\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[32m     ✓ Scenario declared in manifest\u001b[39m\r\r\n"]
+[0.16,"o","\u001b[32m     ✓ Execution contexts declared\u001b[39m\r\r\n"]
+[0.16,"o","\u001b[32m     ✓ Risk levels within manifest maximum\u001b[39m\r\r\n"]
+[0.16,"o","\u001b[32m     ✓ Unique step IDs\u001b[39m\r\r\n"]
+[0.16,"o","\u001b[32m     ✓ State preservation for elevated+ steps\u001b[39m\r\r\n"]
+[0.16,"o","\u001b[32m     ✓ Human notification for elevated+ plans\u001b[39m\r\r\n"]
+[0.16,"o","\u001b[32m     ✓ Human notification guide ids resolve\u001b[39m\r\r\n"]
+[0.16,"o","\u001b[32m     ✓ Rollback strategy declared\u001b[39m\r\r\n"]
+[0.16,"o","\u001b[32m     ✓ Blast radius declares affected components\u001b[39m\r\r\n"]
+[0.16,"o","\u001b[32m     ✓ No nested conditionals\u001b[39m\r\r\n"]
+[0.16,"o","\u001b[32m     ✓ System actions declare required capabilities\u001b[39m\r\r\n"]
+[0.16,"o","\u001b[32m     ✓ Manifest capabilities are registered\u001b[39m\r\r\n"]
+[0.16,"o","\u001b[32m     ✓ Step capabilities are registered\u001b[39m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.16,"o","\u001b[32m     ✓ Plan validation passed\u001b[39m\r\r\n"]
+[0.302,"o","\r\r\n"]
+[0.04,"o","\u001b[2m────────────────────────────────────────────────────────────────────────\u001b[22m\r\r\n"]
+[0.85,"o","\u001b[1m\u001b[36m  Phase 8: Catalog Matching\u001b[39m\u001b[22m\r\r\n"]
+[0.04,"o","\u001b[2m────────────────────────────────────────────────────────────────────────\u001b[22m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.1,"o","\u001b[1m\u001b[37m  8. Matching plan against pre-authorized catalog\u001b[39m\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     Agent name matches: postgresql-replication-recovery\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     Scenario matches: replication_lag_cascade\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     Step count (10) within limit (15)\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     Required step patterns present (checkpoint, notification)\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     No forbidden operations detected\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     Catalog entry 'pg-replication-standard-recovery' matched\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[32m     ✓ Catalog match: covers routine, elevated risk levels\u001b[39m\r\r\n"]
+[0.1,"o","\u001b[33m     ! Steps with high/critical risk still require manual approval\u001b[39m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.302,"o","\r\r\n"]
+[0.04,"o","\u001b[2m────────────────────────────────────────────────────────────────────────\u001b[22m\r\r\n"]
+[0.85,"o","\u001b[1m\u001b[36m  Phase 9: Execution\u001b[39m\u001b[22m\r\r\n"]
+[0.04,"o","\u001b[2m────────────────────────────────────────────────────────────────────────\u001b[22m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.1,"o","\u001b[1m\u001b[37m  9. Beginning plan execution\u001b[39m\u001b[22m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.45,"o","\u001b[1m     Step step-001 \u001b[22m\u001b[2m[diagnosis_action]\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     Assess current replication lag across all replicas\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[32m     ● SUCCESS (1ms)\u001b[39m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.45,"o","\u001b[1m     Step step-002 \u001b[22m\u001b[34m[human_notification]\u001b[39m\r\r\n"]
+[0.1,"o","\u001b[2m     Notify on-call DBA of replication recovery initiation\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[34m     → Notification: Automated recovery initiated for PostgreSQL replication lag cascade\u001b[39m\r\r\n"]
+[0.1,"o","\u001b[2m       Recipients: on_call_dba (high)\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[32m     ● SUCCESS (0ms)\u001b[39m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.45,"o","\u001b[1m     Step step-003 \u001b[22m\u001b[2m[checkpoint]\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     Pre-recovery checkpoint\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[2m     ◆ Capture: full_replication_config — captured\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[2m     ◆ Capture: replication_slot_state — captured\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[32m     ● SUCCESS (1ms)\u001b[39m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.45,"o","\u001b[1m     Step step-004 \u001b[22m\u001b[33m[system_action]\u001b[39m\r\r\n"]
+[0.1,"o","\u001b[2m     Disconnect lagging replica 10.0.1.52 from replication\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[2m     ◈ Blast radius: pg-replica-10-0-1-52 (cascade: low)\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[2m     ◆ Capture: replication_state_snapshot — captured\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[32m     ✓ Precondition: Replica 10.0.1.52 is currently connected\u001b[39m\r\r\n"]
+[0.16,"o","\u001b[33m     ◇ Capture: [DRY-RUN] Disconnect lagging replica 10.0.1.52 from replication — skipped\u001b[39m\r\r\n"]
+[0.16,"o","\u001b[32m     ● SUCCESS (3ms)\u001b[39m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.45,"o","\u001b[1m     Step step-005 \u001b[22m\u001b[33m[system_action]\u001b[39m\r\r\n"]
+[0.1,"o","\u001b[2m     Redirect read traffic away from disconnected replica\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[2m     ◈ Blast radius: load-balancer (cascade: none)\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[33m     ◇ Capture: [DRY-RUN] Redirect read traffic away from disconnected replica — skipped\u001b[39m\r\r\n"]
+[0.16,"o","\u001b[32m     ● SUCCESS (1ms)\u001b[39m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.45,"o","\u001b[1m     Step step-006 \u001b[22m\u001b[36m[replanning_checkpoint]\u001b[39m\r\r\n"]
+[0.1,"o","\u001b[2m     Assess recovery progress before proceeding\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[36m     ↻ Replanning checkpoint reached — invoking agent.replan()\u001b[39m\r\r\n"]
+[0.16,"o","\u001b[2m     ◆ Capture: post_stabilization_replication_state — captured\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[2m     ◆ Capture: post_stabilization_slot_state — captured\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[36m     ↻ Agent returned revised plan\u001b[39m\r\r\n"]
+[0.1,"o","\u001b[2m       Revised plan: Revised plan: drop and recreate invalid slot 'replica_us_east_1b' before proceeding.. Fast replan: approved\u001b[22m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.45,"o","\u001b[1m     Step step-006a \u001b[22m\u001b[33m[system_action]\u001b[39m\r\r\n"]
+[0.1,"o","\u001b[2m     Drop invalid replication slot\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[2m     ◈ Blast radius: pg-primary-us-east-1 (cascade: low)\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[2m     ◆ Capture: slot_state_before_drop — captured\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[33m     ◇ Capture: [DRY-RUN] Drop invalid replication slot — skipped\u001b[39m\r\r\n"]
+[0.16,"o","\u001b[32m     ● SUCCESS (0ms)\u001b[39m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.45,"o","\u001b[1m     Step step-006b \u001b[22m\u001b[33m[system_action]\u001b[39m\r\r\n"]
+[0.1,"o","\u001b[2m     Recreate replication slot\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[2m     ◈ Blast radius: pg-primary-us-east-1 (cascade: none)\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[33m     ◇ Capture: [DRY-RUN] Recreate replication slot — skipped\u001b[39m\r\r\n"]
+[0.16,"o","\u001b[32m     ● SUCCESS (0ms)\u001b[39m\r\r\n"]
+[0.16,"o","\u001b[32m     ● SUCCESS (1ms)\u001b[39m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.45,"o","\u001b[1m     Step step-007 \u001b[22m\u001b[35m[human_approval]\u001b[39m\r\r\n"]
+[0.1,"o","\u001b[2m     Approve replica resynchronization\u001b[22m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.04,"o","\u001b[1m\u001b[35m     ┌─────────────────────────────────────────────────────┐\u001b[39m\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[1m\u001b[35m     │          HUMAN APPROVAL REQUIRED                    │\u001b[39m\u001b[22m\r\r\n"]
+[0.04,"o","\u001b[1m\u001b[35m     └─────────────────────────────────────────────────────┘\u001b[39m\u001b[22m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.1,"o","\u001b[1m     Ready to begin resynchronization for 10.0.1.52\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     The primary has been stabilized. The next phase will resynchronize pg-replica-10-0-1-52, which requires a pg_basebackup that will temporarily increase I/O load on the primary.\u001b[22m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.1,"o","\u001b[1m     Proposed actions:\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[2m       • Drop and recreate invalid replication slot for pg-replica-10-0-1-52\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[2m       • Initiate pg_basebackup from primary to pg-replica-10-0-1-52\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[2m       • Re-establish streaming replication\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[2m       • Verify replication lag returns to < 10 seconds\u001b[22m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.1,"o","\u001b[33m     Risk: Primary I/O load will increase during pg_basebackup. No data loss risk.\u001b[39m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.1,"o","\u001b[2m     Alternatives:\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m       [skip] Skip resynchronization. Replication will remain broken for pg-replica-10-0-1-52 until manually repaired.\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m       [abort] Abort the recovery plan. Replica disconnect will remain in effect.\u001b[22m\r\r\n"]
+[0.002,"o","\u001b[1G\u001b[0J"]
+[0.05,"o","\r\r\n"]
+[0.1,"o","    Enter your decision (approve/skip/reject): \u001b[48G"]
+[4,"o","approve"]
+[0.05,"o","\r\r\r\n"]
+[0.16,"o","\u001b[32m     ✓ Approval received: approved\u001b[39m\r\r\n"]
+[0.16,"o","\u001b[32m     ● SUCCESS (4403ms)\u001b[39m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.45,"o","\u001b[1m     Step step-008 \u001b[22m\u001b[33m[system_action]\u001b[39m\r\r\n"]
+[0.1,"o","\u001b[2m     Initiate pg_basebackup and re-establish replication for 10.0.1.52\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[2m     ◈ Blast radius: pg-replica-10-0-1-52, pg-primary-us-east-1 (cascade: medium)\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[2m     ◆ Capture: pre_basebackup_primary_state — captured\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[32m     ✓ Precondition: Primary is reachable and accepting connections\u001b[39m\r\r\n"]
+[0.16,"o","\u001b[33m     ◇ Capture: [DRY-RUN] Initiate pg_basebackup and re-establish replication for 10.0.1.52 — skipped\u001b[39m\r\r\n"]
+[0.16,"o","\u001b[32m     ● SUCCESS (1ms)\u001b[39m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.45,"o","\u001b[1m     Step step-009 \u001b[22m\u001b[37m[conditional]\u001b[39m\r\r\n"]
+[0.1,"o","\u001b[2m     Restore traffic or notify for manual intervention\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[32m     → Condition TRUE — executing thenStep\u001b[39m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.45,"o","\u001b[1m     Step step-009a \u001b[22m\u001b[33m[system_action]\u001b[39m\r\r\n"]
+[0.1,"o","\u001b[2m     Restore read traffic to recovered replica\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[2m     ◈ Blast radius: load-balancer (cascade: none)\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[33m     ◇ Capture: [DRY-RUN] Restore read traffic to recovered replica — skipped\u001b[39m\r\r\n"]
+[0.16,"o","\u001b[32m     ● SUCCESS (0ms)\u001b[39m\r\r\n"]
+[0.16,"o","\u001b[32m     ● SUCCESS (1ms)\u001b[39m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.45,"o","\u001b[1m     Step step-010 \u001b[22m\u001b[34m[human_notification]\u001b[39m\r\r\n"]
+[0.1,"o","\u001b[2m     Send recovery summary\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[34m     → Notification: PostgreSQL replication recovery completed\u001b[39m\r\r\n"]
+[0.1,"o","\u001b[2m       Recipients: on_call_dba (medium), incident_commander (medium)\u001b[22m\r\r\n"]
+[0.16,"o","\u001b[32m     ● SUCCESS (0ms)\u001b[39m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.04,"o","\u001b[2m────────────────────────────────────────────────────────────────────────\u001b[22m\r\r\n"]
+[0.85,"o","\u001b[1m\u001b[36m  Phase 10: Completion\u001b[39m\u001b[22m\r\r\n"]
+[0.04,"o","\u001b[2m────────────────────────────────────────────────────────────────────────\u001b[22m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.1,"o","\u001b[1m\u001b[37m  10. Writing forensic record\u001b[39m\u001b[22m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.04,"o","\u001b[2m════════════════════════════════════════════════════════════════════════\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[1m  Forensic Record Summary\u001b[22m\r\r\n"]
+[0.04,"o","\u001b[2m════════════════════════════════════════════════════════════════════════\u001b[22m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.1,"o","\u001b[2m     Record ID:      fr-1786289874893\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     Completeness:   complete\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     Outcome:        success\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     Duration:       4414ms\u001b[22m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.1,"o","\u001b[2m     Steps:          13 completed, 0 failed, 0 skipped (13 total)\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     Captures:       7 succeeded, 0 skipped (7 total)\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     Catalog match:  yes\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     Replans:        1\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[2m     Plans:          2\u001b[22m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.1,"o","\u001b[32m     Forensic record written to: output/forensic-record.json\u001b[39m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[0.04,"o","\u001b[2m════════════════════════════════════════════════════════════════════════\u001b[22m\r\r\n"]
+[0.1,"o","\u001b[1m\u001b[32m  Demo Complete\u001b[39m\u001b[22m\r\r\n"]
+[0.04,"o","\u001b[2m════════════════════════════════════════════════════════════════════════\u001b[22m\r\r\n"]
+[0.05,"o","\r\r\n"]
+[2.52,"x","0"]

From 11cde7e75bded137d2788582db49401f0478f06a Mon Sep 17 00:00:00 2001
From: trs-80 <109326+trs-80@users.noreply.github.com>
Date: Sun, 9 Aug 2026 12:01:30 -0400
Subject: [PATCH 05/17] feat(site): play the real demo and add a reproducible
 Cloudflare bundle
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- vendors asciinema-player v3.17.0 and plays site/assets/demo.cast inline,
  with the GIF kept only as a fallback (it is not fetched when the player
  works). Closes a hole where JS-on-but-player-missing rendered an empty box
  with no GIF at all.
- rewrites the demo alt text. It claimed 92% confidence, which is the
  rule-based fallback's fixed figure; the live-AI recording shows
  replication_lag_cascade at 78% with a primary-side WAL-generation root
  cause. It now also says the GIF is only the opening excerpt.
- discloses that playback is pace-adjusted and the real AI call took ~30-60s,
  rather than letting the capped idle gaps imply the tool is faster than it is
- player options re-checked against the new cast (314 events, 56.24s, max idle
  gap 4.0s; poster npt:0:03 still lands on the title card)

scripts/package-site.sh emits output/crisismode-site.zip for Cloudflare Pages
direct upload: index.html at the zip root plus blog/ and assets/, no .DS_Store,
no resource forks, byte-identical across runs.

Removes site/index.html.zip: committed 2026-07-20, 21KB, a stale index.html
predating the player and no assets/ at all — uploading it to Pages would
deploy a page whose player JS, CSS, cast and GIF all 404.

Verified by real browser render (headless Chromium against a local server):
all assets 200, player paints with the 78% diagnosis and plan table visible,
zero console errors, fallback swaps in correctly — repeated against the
extracted zip.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 scripts/package-site.sh             | 110 ++++
 site/assets/asciinema-player.css    | 762 ++++++++++++++++++++++++++++
 site/assets/asciinema-player.min.js |   3 +
 site/index.html                     | 192 +++----
 site/index.html.zip                 | Bin 21372 -> 0 bytes
 5 files changed, 977 insertions(+), 90 deletions(-)
 create mode 100755 scripts/package-site.sh
 create mode 100644 site/assets/asciinema-player.css
 create mode 100644 site/assets/asciinema-player.min.js
 delete mode 100644 site/index.html.zip

diff --git a/scripts/package-site.sh b/scripts/package-site.sh
new file mode 100755
index 0000000..078f0ef
--- /dev/null
+++ b/scripts/package-site.sh
@@ -0,0 +1,110 @@
+#!/usr/bin/env bash
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 CrisisMode Contributors
+#
+# Package site/ as a zip for Cloudflare Pages direct upload.
+#
+# Pages resolves the site from the ZIP ROOT, so index.html must be a top-level
+# entry — a zip containing `site/index.html` deploys to /site/index.html and the
+# landing page 404s. This script therefore zips from inside site/ with relative
+# paths, and asserts the root layout afterwards rather than trusting it.
+#
+# WHAT GOES IN: index.html, blog/, assets/. Nothing else — the zip is a publish
+# artifact, not a copy of the working tree.
+#
+# WHAT IS KEPT OUT, and why each one matters:
+#   - .DS_Store            Finder litter; site/.DS_Store exists today.
+#   - *.zip                a previously built bundle must never nest inside the
+#                          next one (site/index.html.zip is a stale committed
+#                          artifact that would otherwise ride along).
+#   - ._* / __MACOSX/      AppleDouble resource forks, which `zip -X` also
+#                          suppresses by not recording Apple extra fields.
+#
+# REPRODUCIBILITY: the entry set and entry order are deterministic — the file
+# list is built by find and LC_ALL=C sort, and passed to zip on stdin, so
+# directory iteration order cannot leak in. The output is removed before each
+# build so a rerun never appends to a stale archive. The archive is NOT
+# byte-identical across runs: Info-ZIP records each entry's filesystem mtime and
+# offers no way to override it, so re-recording an asset changes those bytes.
+# Same inputs, same tree -> same bytes; touched inputs -> new bytes.
+#
+# Usage: bash scripts/package-site.sh
+
+set -euo pipefail
+
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+SITE_DIR="$REPO_ROOT/site"
+OUT_DIR="$REPO_ROOT/output"
+ZIP="$OUT_DIR/crisismode-site.zip"
+
+for tool in zip unzip; do
+  command -v "$tool" >/dev/null 2>&1 || {
+    echo "error: '$tool' not found." >&2
+    exit 1
+  }
+done
+
+[ -f "$SITE_DIR/index.html" ] || {
+  echo "error: $SITE_DIR/index.html is missing; nothing to publish." >&2
+  exit 1
+}
+
+cd "$SITE_DIR"
+
+# Every local asset the page references must be present. This is the exact
+# failure the stale site/index.html.zip demonstrates: it carries index.html and
+# blog/ but no assets/, so the deployed page loads with a dead player and a dead
+# GIF. Catch that here instead of in production.
+#
+# Match any quoted assets//blog/ path, not just src=/href= attributes: the cast
+# is loaded from script (AsciinemaPlayer.create('assets/demo.cast', ...)), and an
+# attribute-only scan would happily ship a bundle with no recording in it.
+missing=0
+while IFS= read -r ref; do
+  [ -z "$ref" ] && continue
+  [ -e "$ref" ] || {
+    echo "error: index.html references '$ref', which does not exist in site/" >&2
+    missing=1
+  }
+done <<EOF
+$(grep -oE "[\"'](assets|blog)/[^\"'?#]+" index.html \
+    | sed -E "s/^[\"']//" \
+    | LC_ALL=C sort -u)
+EOF
+[ "$missing" -eq 0 ] || exit 1
+
+mkdir -p "$OUT_DIR"
+rm -f "$ZIP"
+
+# -X   omit extra file attributes (uid/gid, Apple extra fields / resource forks)
+# -q   quiet; the listing below is the report
+# -@   read the entry list from stdin, so ordering is ours and not the FS's
+echo "==> packaging site/ -> $ZIP"
+find index.html blog assets \
+     -type f \
+     ! -name '.DS_Store' \
+     ! -name '*.zip' \
+     ! -name '._*' \
+     -print \
+  | LC_ALL=C sort \
+  | zip -q -X -@ "$ZIP" -x '.DS_Store' '*/.DS_Store' '*.zip' '._*' '*/._*' '__MACOSX/*'
+
+# Assert the layout Pages needs rather than asking the reader to eyeball it.
+unzip -Z1 "$ZIP" | grep -qx 'index.html' || {
+  echo "error: index.html is not at the zip root; Pages would 404 on /." >&2
+  exit 1
+}
+if unzip -Z1 "$ZIP" | grep -qE '(^|/)(\.DS_Store|\._|__MACOSX/)|\.zip$'; then
+  echo "error: excluded files leaked into the archive:" >&2
+  unzip -Z1 "$ZIP" | grep -E '(^|/)(\.DS_Store|\._|__MACOSX/)|\.zip$' >&2
+  exit 1
+fi
+
+ZIP_BYTES="$(wc -c < "$ZIP" | tr -d ' ')"
+
+echo
+unzip -l "$ZIP"
+echo
+echo "done: $ZIP"
+echo "      $((ZIP_BYTES / 1024)) KiB ($ZIP_BYTES bytes), $(unzip -Z1 "$ZIP" | wc -l | tr -d ' ') entries"
+echo "      upload this file to Cloudflare Pages (Create project -> Direct Upload)."
diff --git a/site/assets/asciinema-player.css b/site/assets/asciinema-player.css
new file mode 100644
index 0000000..1857794
--- /dev/null
+++ b/site/assets/asciinema-player.css
@@ -0,0 +1,762 @@
+.ap-default-term-ff {
+  --term-font-family: "Cascadia Code", "Source Code Pro", Menlo, Consolas, "DejaVu Sans Mono", monospace, "Symbols Nerd Font";
+}
+div.ap-wrapper {
+  outline: none;
+  height: 100%;
+  display: flex;
+  justify-content: center;
+}
+div.ap-wrapper .title-bar {
+  display: none;
+  top: -78px;
+  transition: top 0.15s linear;
+  position: absolute;
+  left: 0;
+  right: 0;
+  box-sizing: content-box;
+  font-size: 20px;
+  line-height: 1em;
+  padding: 15px;
+  font-family: sans-serif;
+  color: white;
+  background-color: rgba(0, 0, 0, 0.8);
+}
+div.ap-wrapper .title-bar img {
+  vertical-align: middle;
+  height: 48px;
+  margin-right: 16px;
+}
+div.ap-wrapper .title-bar a {
+  color: white;
+  text-decoration: underline;
+}
+div.ap-wrapper .title-bar a:hover {
+  text-decoration: none;
+}
+div.ap-wrapper:fullscreen {
+  background-color: #000;
+  width: 100%;
+  align-items: center;
+}
+div.ap-wrapper:fullscreen .title-bar {
+  display: initial;
+}
+div.ap-wrapper:fullscreen.hud .title-bar {
+  top: 0;
+}
+div.ap-wrapper div.ap-player {
+  text-align: left;
+  display: inline-block;
+  padding: 0px;
+  position: relative;
+  box-sizing: content-box;
+  overflow: hidden;
+  max-width: 100%;
+  border-radius: 4px;
+  font-size: 15px;
+  background-color: var(--term-color-background);
+}
+.ap-player {
+  --term-color-foreground: #ffffff;
+  --term-color-background: #000000;
+  --term-color-0: var(--term-color-foreground);
+  --term-color-1: var(--term-color-foreground);
+  --term-color-2: var(--term-color-foreground);
+  --term-color-3: var(--term-color-foreground);
+  --term-color-4: var(--term-color-foreground);
+  --term-color-5: var(--term-color-foreground);
+  --term-color-6: var(--term-color-foreground);
+  --term-color-7: var(--term-color-foreground);
+  --term-color-8: var(--term-color-0);
+  --term-color-9: var(--term-color-1);
+  --term-color-10: var(--term-color-2);
+  --term-color-11: var(--term-color-3);
+  --term-color-12: var(--term-color-4);
+  --term-color-13: var(--term-color-5);
+  --term-color-14: var(--term-color-6);
+  --term-color-15: var(--term-color-7);
+}
+div.ap-term {
+  position: relative;
+  font-family: var(--term-font-family);
+  border-width: 0.75em;
+  border-radius: 0;
+  border-style: solid;
+  border-color: var(--term-color-background);
+  box-sizing: content-box;
+}
+div.ap-term canvas {
+  position: absolute;
+  inset: 0;
+  display: block;
+  width: 100%;
+  height: 100%;
+}
+div.ap-term svg.ap-term-symbols {
+  position: absolute;
+  inset: 0;
+  display: block;
+  width: 100%;
+  height: 100%;
+  overflow: hidden;
+  pointer-events: none;
+}
+div.ap-term svg.ap-term-symbols use {
+  color: var(--term-color-foreground);
+}
+div.ap-term svg.ap-term-symbols:not(.ap-blink) .ap-blink {
+  opacity: 0;
+}
+div.ap-term pre.ap-term-text {
+  position: absolute;
+  inset: 0;
+  box-sizing: content-box;
+  overflow: hidden;
+  padding: 0;
+  margin: 0px;
+  display: block;
+  white-space: pre;
+  word-wrap: normal;
+  word-break: normal;
+  cursor: text;
+  color: var(--term-color-foreground);
+  outline: none;
+  line-height: var(--term-line-height);
+  font-family: inherit;
+  font-size: inherit;
+  font-variant-ligatures: none;
+  border: 0;
+  border-radius: 0;
+  background-color: transparent !important;
+}
+pre.ap-term-text .ap-line {
+  display: block;
+  width: 100%;
+  height: var(--term-line-height);
+  position: absolute;
+  top: calc(100% * var(--row) / var(--term-rows));
+  letter-spacing: normal;
+  overflow: hidden;
+}
+pre.ap-term-text .ap-line span {
+  position: absolute;
+  left: calc(100% * var(--offset) / var(--term-cols));
+  padding: 0;
+  display: inline-block;
+  height: 100%;
+}
+pre.ap-term-text:not(.ap-blink) .ap-line .ap-blink {
+  color: transparent;
+  border-color: transparent;
+}
+pre.ap-term-text .ap-bold {
+  font-weight: bold;
+}
+pre.ap-term-text .ap-faint {
+  opacity: 0.5;
+}
+pre.ap-term-text .ap-underline {
+  text-decoration: underline;
+}
+pre.ap-term-text .ap-italic {
+  font-style: italic;
+}
+pre.ap-term-text .ap-strike {
+  text-decoration: line-through;
+}
+.ap-line span {
+  color: var(--term-color-foreground);
+}
+div.ap-player div.ap-control-bar {
+  width: 100%;
+  height: 32px;
+  display: flex;
+  justify-content: space-between;
+  align-items: stretch;
+  color: var(--term-color-foreground);
+  box-sizing: content-box;
+  line-height: 1;
+  position: absolute;
+  bottom: 0;
+  left: 0;
+  opacity: 0;
+  transition: opacity 0.15s linear;
+  user-select: none;
+  border-top: 2px solid color-mix(in oklab, var(--term-color-background) 80%, var(--term-color-foreground));
+  z-index: 30;
+}
+div.ap-player div.ap-control-bar * {
+  box-sizing: inherit;
+}
+div.ap-control-bar svg.ap-icon path {
+  fill: var(--term-color-foreground);
+}
+div.ap-control-bar button.ap-button {
+  display: flex;
+  flex: 0 0 auto;
+  cursor: pointer;
+  appearance: none;
+  -webkit-appearance: none;
+  background: transparent;
+  border: 0;
+  margin: 0;
+  padding: 0;
+  color: inherit;
+  font: inherit;
+  line-height: inherit;
+}
+div.ap-control-bar button.ap-playback-button {
+  width: 12px;
+  height: 12px;
+  padding: 10px;
+  margin: 0 0 0 2px;
+}
+div.ap-control-bar button.ap-playback-button svg {
+  height: 12px;
+  width: 12px;
+}
+div.ap-control-bar span.ap-timer {
+  display: flex;
+  flex: 0 0 auto;
+  min-width: 50px;
+  margin: 0 10px;
+  height: 100%;
+  text-align: center;
+  font-size: 13px;
+  line-height: 100%;
+  cursor: default;
+}
+div.ap-control-bar span.ap-timer span {
+  font-family: var(--term-font-family);
+  font-size: inherit;
+  font-weight: 600;
+  margin: auto;
+}
+div.ap-control-bar span.ap-timer .ap-time-remaining {
+  display: none;
+}
+div.ap-control-bar span.ap-timer:hover .ap-time-elapsed {
+  display: none;
+}
+div.ap-control-bar span.ap-timer:hover .ap-time-remaining {
+  display: flex;
+}
+div.ap-control-bar .ap-progressbar {
+  display: block;
+  flex: 1 1 auto;
+  height: 100%;
+  padding: 0 10px;
+}
+div.ap-control-bar .ap-progressbar .ap-bar {
+  display: block;
+  position: relative;
+  cursor: default;
+  height: 100%;
+  font-size: 0;
+}
+div.ap-control-bar .ap-progressbar .ap-bar .ap-gutter {
+  display: block;
+  position: absolute;
+  top: 15px;
+  left: 0;
+  right: 0;
+  height: 3px;
+}
+div.ap-control-bar .ap-progressbar .ap-bar .ap-gutter-empty {
+  background-color: color-mix(in oklab, var(--term-color-foreground) 20%, var(--term-color-background));
+}
+div.ap-control-bar .ap-progressbar .ap-bar .ap-gutter-full {
+  width: 100%;
+  transform-origin: left center;
+  background-color: var(--term-color-foreground);
+  border-radius: 3px;
+}
+div.ap-control-bar.ap-seekable .ap-progressbar .ap-bar {
+  cursor: pointer;
+}
+div.ap-control-bar button.ap-fullscreen-button {
+  width: 14px;
+  height: 14px;
+  padding: 9px;
+  margin: 0 2px 0 4px;
+}
+div.ap-control-bar button.ap-fullscreen-button svg {
+  width: 14px;
+  height: 14px;
+}
+div.ap-control-bar button.ap-fullscreen-button svg.ap-icon-fullscreen-on {
+  display: inline;
+}
+div.ap-control-bar button.ap-fullscreen-button svg.ap-icon-fullscreen-off {
+  display: none;
+}
+div.ap-control-bar button.ap-fullscreen-button .ap-tooltip {
+  right: 5px;
+  left: initial;
+  transform: none;
+}
+div.ap-control-bar button.ap-kbd-button {
+  height: 14px;
+  padding: 9px;
+  margin: 0 0 0 4px;
+}
+div.ap-control-bar button.ap-kbd-button svg {
+  width: 26px;
+  height: 14px;
+}
+div.ap-control-bar button.ap-kbd-button .ap-tooltip {
+  right: 5px;
+  left: initial;
+  transform: none;
+}
+div.ap-control-bar button.ap-speaker-button {
+  width: 19px;
+  padding: 6px 9px;
+  margin: 0 0 0 4px;
+  position: relative;
+}
+div.ap-control-bar button.ap-speaker-button svg {
+  width: 19px;
+}
+div.ap-control-bar button.ap-speaker-button .ap-tooltip {
+  left: -50%;
+  transform: none;
+}
+div.ap-wrapper.ap-hud .ap-control-bar {
+  opacity: 1;
+}
+div.ap-wrapper:fullscreen button.ap-fullscreen-button svg.ap-icon-fullscreen-on {
+  display: none;
+}
+div.ap-wrapper:fullscreen button.ap-fullscreen-button svg.ap-icon-fullscreen-off {
+  display: inline;
+}
+span.ap-progressbar span.ap-marker-container {
+  display: block;
+  top: 0;
+  bottom: 0;
+  width: 21px;
+  position: absolute;
+  margin-left: -10px;
+}
+span.ap-marker-container span.ap-marker {
+  display: block;
+  top: 13px;
+  bottom: 12px;
+  left: 7px;
+  right: 7px;
+  background-color: color-mix(in oklab, var(--term-color-foreground) 33%, var(--term-color-background));
+  position: absolute;
+  transition: top 0.1s, bottom 0.1s, left 0.1s, right 0.1s, background-color 0.1s;
+  border-radius: 50%;
+}
+span.ap-marker-container span.ap-marker.ap-marker-past {
+  background-color: var(--term-color-foreground);
+}
+span.ap-marker-container span.ap-marker:hover,
+span.ap-marker-container:hover span.ap-marker {
+  background-color: var(--term-color-foreground);
+  top: 11px;
+  bottom: 10px;
+  left: 5px;
+  right: 5px;
+}
+.ap-tooltip-container span.ap-tooltip {
+  visibility: hidden;
+  background-color: var(--term-color-foreground);
+  color: var(--term-color-background);
+  font-family: var(--term-font-family);
+  font-weight: bold;
+  text-align: center;
+  padding: 0 0.5em;
+  border-radius: 4px;
+  position: absolute;
+  z-index: 1;
+  white-space: nowrap;
+  /* Prevents the text from wrapping and makes sure the tooltip width adapts to the text length */
+  font-size: 13px;
+  line-height: 2em;
+  bottom: 100%;
+  left: 50%;
+  transform: translateX(-50%);
+}
+.ap-tooltip-container:hover span.ap-tooltip {
+  visibility: visible;
+}
+.ap-player .ap-overlay {
+  z-index: 10;
+  background-repeat: no-repeat;
+  background-position: center;
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+}
+.ap-player .ap-overlay-start {
+  cursor: pointer;
+}
+.ap-player .ap-overlay-start .ap-play-button {
+  font-size: 0px;
+  position: absolute;
+  left: 0;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  text-align: center;
+  color: white;
+  height: 80px;
+  max-height: 66%;
+  margin: auto;
+}
+.ap-player .ap-overlay-start .ap-play-button div {
+  height: 100%;
+}
+.ap-player .ap-overlay-start .ap-play-button div span {
+  height: 100%;
+  display: block;
+}
+.ap-player .ap-overlay-start .ap-play-button div span svg {
+  height: 100%;
+  display: inline-block;
+}
+.ap-player .ap-overlay-start .ap-play-button svg {
+  filter: drop-shadow(0px 0px 5px rgba(0, 0, 0, 0.4));
+}
+.ap-player .ap-overlay-loading .ap-loader {
+  width: 48px;
+  height: 48px;
+  border-radius: 50%;
+  display: inline-block;
+  position: relative;
+  border: 10px solid;
+  border-color: rgba(255, 255, 255, 0.3) rgba(255, 255, 255, 0.5) rgba(255, 255, 255, 0.7) #ffffff;
+  border-color: color-mix(in srgb, var(--term-color-foreground) 30%, var(--term-color-background)) color-mix(in srgb, var(--term-color-foreground) 50%, var(--term-color-background)) color-mix(in srgb, var(--term-color-foreground) 70%, var(--term-color-background)) color-mix(in srgb, var(--term-color-foreground) 100%, var(--term-color-background));
+  box-sizing: border-box;
+  animation: ap-loader-rotation 1s linear infinite;
+}
+.ap-player .ap-overlay-info {
+  background-color: var(--term-color-background);
+}
+.ap-player .ap-overlay-info span {
+  font-family: var(--term-font-family);
+  font-size: 2em;
+  font-weight: bold;
+  color: var(--term-color-background);
+  background-color: var(--term-color-foreground);
+  padding: 0.5em 0.75em;
+  text-transform: uppercase;
+}
+.ap-player .ap-overlay-keystrokes {
+  position: absolute;
+  top: auto;
+  left: auto;
+  right: 20px;
+  bottom: var(--ap-keystrokes-bottom);
+  z-index: 20;
+  width: auto;
+  height: auto;
+  font-size: 18px;
+  text-align: right;
+  padding: 0;
+  display: flex;
+  justify-content: flex-end;
+  align-items: center;
+  gap: 0.35em;
+  pointer-events: none;
+}
+.ap-player .ap-overlay-keystrokes .ap-keystroke-pill {
+  font-family: var(--term-font-family);
+  font-size: inherit;
+  opacity: 1;
+  transition: opacity 80ms ease;
+}
+.ap-player .ap-overlay-keystrokes .ap-keystroke-pill kbd {
+  display: inline-flex;
+  justify-content: center;
+  min-width: 1.2em;
+  color: var(--term-color-background);
+  background-color: var(--term-color-foreground);
+  padding: 0.3em 0.5em;
+  border-radius: 0.2em;
+  font-family: inherit;
+  font-size: 0.85em;
+  font-weight: 600;
+  border: none;
+  margin: 0;
+}
+.ap-player .ap-overlay-keystrokes .ap-keystroke-pill.fading {
+  opacity: 0;
+  transition: opacity 700ms ease;
+}
+.ap-player .ap-overlay-help {
+  background-color: rgba(0, 0, 0, 0.8);
+  container-type: inline-size;
+}
+.ap-player .ap-overlay-help > div {
+  font-family: var(--term-font-family);
+  max-width: 85%;
+  max-height: 85%;
+  font-size: 18px;
+  color: var(--term-color-foreground);
+  box-sizing: border-box;
+  margin-bottom: 32px;
+}
+.ap-player .ap-overlay-help > div div {
+  padding: calc(min(4cqw, 40px));
+  font-size: calc(min(1.9cqw, 18px));
+  background-color: var(--term-color-background);
+  border: 1px solid color-mix(in oklab, var(--term-color-background) 90%, var(--term-color-foreground));
+  border-radius: 6px;
+}
+.ap-player .ap-overlay-help > div div p {
+  font-weight: bold;
+  margin: 0 0 2em 0;
+}
+.ap-player .ap-overlay-help > div div ul {
+  list-style: none;
+  padding: 0;
+}
+.ap-player .ap-overlay-help > div div ul li {
+  margin: 0 0 0.75em 0;
+}
+.ap-player .ap-overlay-help > div div kbd {
+  color: var(--term-color-background);
+  background-color: var(--term-color-foreground);
+  padding: 0.2em 0.5em;
+  border-radius: 0.2em;
+  font-family: inherit;
+  font-size: 0.85em;
+  border: none;
+  margin: 0;
+}
+.ap-player .ap-overlay-error span {
+  font-size: 8em;
+}
+.ap-player .slide-enter-active {
+  transition: opacity 0.2s;
+}
+.ap-player .slide-enter-active.ap-was-playing {
+  transition: top 0.2s ease-out, opacity 0.2s;
+}
+.ap-player .slide-exit-active {
+  transition: top 0.2s ease-in, opacity 0.2s;
+}
+.ap-player .slide-enter {
+  top: -50%;
+  opacity: 0;
+}
+.ap-player .slide-enter-to {
+  top: 0%;
+}
+.ap-player .slide-enter,
+.ap-player .slide-enter-to,
+.ap-player .slide-exit,
+.ap-player .slide-exit-to {
+  bottom: auto;
+  height: 100%;
+}
+.ap-player .slide-exit {
+  top: 0%;
+}
+.ap-player .slide-exit-to {
+  top: -50%;
+  opacity: 0;
+}
+@keyframes ap-loader-rotation {
+  0% {
+    transform: rotate(0deg);
+  }
+  100% {
+    transform: rotate(360deg);
+  }
+}
+.asciinema-player-theme-asciinema {
+  --term-color-foreground: #cccccc;
+  --term-color-background: #121314;
+  --term-color-0: #000000;
+  --term-color-1: #dd3c69;
+  --term-color-2: #4ebf22;
+  --term-color-3: #ddaf3c;
+  --term-color-4: #26b0d7;
+  --term-color-5: #b954e1;
+  --term-color-6: #54e1b9;
+  --term-color-7: #d9d9d9;
+  --term-color-8: #4d4d4d;
+  --term-color-9: #dd3c69;
+  --term-color-10: #4ebf22;
+  --term-color-11: #ddaf3c;
+  --term-color-12: #26b0d7;
+  --term-color-13: #b954e1;
+  --term-color-14: #54e1b9;
+  --term-color-15: #ffffff;
+}
+/*
+  Based on Dracula: https://draculatheme.com
+ */
+.asciinema-player-theme-dracula {
+  --term-color-foreground: #f8f8f2;
+  --term-color-background: #282a36;
+  --term-color-0: #21222c;
+  --term-color-1: #ff5555;
+  --term-color-2: #50fa7b;
+  --term-color-3: #f1fa8c;
+  --term-color-4: #bd93f9;
+  --term-color-5: #ff79c6;
+  --term-color-6: #8be9fd;
+  --term-color-7: #f8f8f2;
+  --term-color-8: #6272a4;
+  --term-color-9: #ff6e6e;
+  --term-color-10: #69ff94;
+  --term-color-11: #ffffa5;
+  --term-color-12: #d6acff;
+  --term-color-13: #ff92df;
+  --term-color-14: #a4ffff;
+  --term-color-15: #ffffff;
+}
+/* Based on Monokai from base16 collection - https://github.com/chriskempson/base16 */
+.asciinema-player-theme-monokai {
+  --term-color-foreground: #f8f8f2;
+  --term-color-background: #272822;
+  --term-color-0: #272822;
+  --term-color-1: #f92672;
+  --term-color-2: #a6e22e;
+  --term-color-3: #f4bf75;
+  --term-color-4: #66d9ef;
+  --term-color-5: #ae81ff;
+  --term-color-6: #a1efe4;
+  --term-color-7: #f8f8f2;
+  --term-color-8: #75715e;
+  --term-color-15: #f9f8f5;
+}
+/*
+  Based on Nord: https://github.com/arcticicestudio/nord
+  Via: https://github.com/neilotoole/asciinema-theme-nord
+ */
+.asciinema-player-theme-nord {
+  --term-color-foreground: #eceff4;
+  --term-color-background: #2e3440;
+  --term-color-0: #3b4252;
+  --term-color-1: #bf616a;
+  --term-color-2: #a3be8c;
+  --term-color-3: #ebcb8b;
+  --term-color-4: #81a1c1;
+  --term-color-5: #b48ead;
+  --term-color-6: #88c0d0;
+  --term-color-7: #eceff4;
+}
+.asciinema-player-theme-seti {
+  --term-color-foreground: #cacecd;
+  --term-color-background: #111213;
+  --term-color-0: #323232;
+  --term-color-1: #c22832;
+  --term-color-2: #8ec43d;
+  --term-color-3: #e0c64f;
+  --term-color-4: #43a5d5;
+  --term-color-5: #8b57b5;
+  --term-color-6: #8ec43d;
+  --term-color-7: #eeeeee;
+  --term-color-15: #ffffff;
+}
+/*
+  Based on Solarized Dark: https://ethanschoonover.com/solarized/
+ */
+.asciinema-player-theme-solarized-dark {
+  --term-color-foreground: #839496;
+  --term-color-background: #002b36;
+  --term-color-0: #073642;
+  --term-color-1: #dc322f;
+  --term-color-2: #859900;
+  --term-color-3: #b58900;
+  --term-color-4: #268bd2;
+  --term-color-5: #d33682;
+  --term-color-6: #2aa198;
+  --term-color-7: #eee8d5;
+  --term-color-8: #002b36;
+  --term-color-9: #cb4b16;
+  --term-color-10: #586e75;
+  --term-color-11: #657b83;
+  --term-color-12: #839496;
+  --term-color-13: #6c71c4;
+  --term-color-14: #93a1a1;
+  --term-color-15: #fdf6e3;
+}
+/*
+  Based on Solarized Light: https://ethanschoonover.com/solarized/
+ */
+.asciinema-player-theme-solarized-light {
+  --term-color-foreground: #657b83;
+  --term-color-background: #fdf6e3;
+  --term-color-0: #073642;
+  --term-color-1: #dc322f;
+  --term-color-2: #859900;
+  --term-color-3: #b58900;
+  --term-color-4: #268bd2;
+  --term-color-5: #d33682;
+  --term-color-6: #2aa198;
+  --term-color-7: #eee8d5;
+  --term-color-8: #002b36;
+  --term-color-9: #cb4b16;
+  --term-color-10: #586e75;
+  --term-color-11: #657c83;
+  --term-color-12: #839496;
+  --term-color-13: #6c71c4;
+  --term-color-14: #93a1a1;
+  --term-color-15: #fdf6e3;
+}
+.asciinema-player-theme-solarized-light .ap-overlay-start .ap-play-button svg .ap-play-btn-fill {
+  fill: var(--term-color-1);
+}
+.asciinema-player-theme-solarized-light .ap-overlay-start .ap-play-button svg .ap-play-btn-stroke {
+  stroke: var(--term-color-1);
+}
+/*
+  Based on Tango: https://en.wikipedia.org/wiki/Tango_Desktop_Project
+ */
+.asciinema-player-theme-tango {
+  --term-color-foreground: #cccccc;
+  --term-color-background: #121314;
+  --term-color-0: #000000;
+  --term-color-1: #cc0000;
+  --term-color-2: #4e9a06;
+  --term-color-3: #c4a000;
+  --term-color-4: #3465a4;
+  --term-color-5: #75507b;
+  --term-color-6: #06989a;
+  --term-color-7: #d3d7cf;
+  --term-color-8: #555753;
+  --term-color-9: #ef2929;
+  --term-color-10: #8ae234;
+  --term-color-11: #fce94f;
+  --term-color-12: #729fcf;
+  --term-color-13: #ad7fa8;
+  --term-color-14: #34e2e2;
+  --term-color-15: #eeeeec;
+}
+/*
+  Based on gruvbox: https://github.com/morhetz/gruvbox
+ */
+.asciinema-player-theme-gruvbox-dark {
+  --term-color-foreground: #fbf1c7;
+  --term-color-background: #282828;
+  --term-color-0: #282828;
+  --term-color-1: #cc241d;
+  --term-color-2: #98971a;
+  --term-color-3: #d79921;
+  --term-color-4: #458588;
+  --term-color-5: #b16286;
+  --term-color-6: #689d6a;
+  --term-color-7: #a89984;
+  --term-color-8: #7c6f65;
+  --term-color-9: #fb4934;
+  --term-color-10: #b8bb26;
+  --term-color-11: #fabd2f;
+  --term-color-12: #83a598;
+  --term-color-13: #d3869b;
+  --term-color-14: #8ec07c;
+  --term-color-15: #fbf1c7;
+}
diff --git a/site/assets/asciinema-player.min.js b/site/assets/asciinema-player.min.js
new file mode 100644
index 0000000..2d14ba0
--- /dev/null
+++ b/site/assets/asciinema-player.min.js
@@ -0,0 +1,3 @@
+/* @license magnet:?xt=urn:btih:8e4f440f4c65981c5bf93c76d35135ba5064d8b7&dn=apache-2.0.txt Apache-2.0 */
+var AsciinemaPlayer=function(A){"use strict";function e(A){return"number"==typeof A?A:"string"==typeof A?A.split(":").reverse().map(parseFloat).reduce(((A,e,t)=>A+e*Math.pow(60,t))):void 0}function t(A){return{name:"string"==typeof A?.name?A.name:"Error",message:"string"==typeof A?.message?A.message:String(A)}}const V=/^#[0-9a-f]{6}$/,g=/^#[0-9a-f]{3}$/;function n(A,e=void 0){if("string"!=typeof A)return e;const t=A.trim().toLowerCase();return V.test(t)?t:g.test(t)?`#${t[1]}${t[1]}${t[2]}${t[2]}${t[3]}${t[3]}`:e}function r(A,e,t){return[e[0]+A*(t[0]-e[0]),e[1]+A*(t[1]-e[1]),e[2]+A*(t[2]-e[2])]}function i(A){const[e,t,V]=function(A){return[Number.parseInt(A.slice(1,3),16)/255,Number.parseInt(A.slice(3,5),16)/255,Number.parseInt(A.slice(5,7),16)/255]}(A).map(Q),g=.4122214708*e+.5363325363*t+.0514459929*V,n=.2119034982*e+.6806995451*t+.1073969566*V,r=.0883024619*e+.2817188376*t+.6299787005*V,i=Math.cbrt(g),o=Math.cbrt(n),I=Math.cbrt(r);return[.2104542553*i+.793617785*o-.0040720468*I,1.9779984951*i-2.428592205*o+.4505937099*I,.0259040371*i+.7827717662*o-.808675766*I]}function o(A){const e=I(A);if(E(e))return C(e);const[t,V,g]=function([A,e,t]){return[A,Math.hypot(e,t),Math.atan2(t,e)]}(A);let n=0,r=V,i=[t,0,g];for(let A=0;A<24;A+=1){const A=(n+r)/2,e=[t,A,g];E(I(B(e)))?(n=A,i=e):r=A}return C(I(B(i)))}function I(A){const e=c(A[0],0,1),t=A[1],V=A[2],g=(e+.3963377774*t+.2158037573*V)**3,n=(e-.1055613458*t-.0638541728*V)**3,r=(e-.0894841775*t-1.291485548*V)**3,i=-1.2684380046*g+2.6097574011*n-.3413193965*r,o=-.0041960863*g-.7034186147*n+1.707614701*r;return[a(4.0767416621*g-3.3077115913*n+.2309699292*r),a(i),a(o)]}function B([A,e,t]){return[A,e*Math.cos(t),e*Math.sin(t)]}function s(A,e,t){return`#${l(A)}${l(e)}${l(t)}`}function C(A){return s(255*A[0],255*A[1],255*A[2])}function Q(A){return A<=.04045?A/12.92:((A+.055)/1.055)**2.4}function a(A){return A<=.0031308?12.92*A:1.055*A**(1/2.4)-.055}function E([A,e,t]){return A>=0&&A<=1&&e>=0&&e<=1&&t>=0&&t<=1}function c(A,e,t){return Math.max(e,Math.min(t,A))}function l(A){return Math.round(c(A,0,255)).toString(16).padStart(2,"0")}class u{log(...A){}debug(...A){}info(...A){}warn(...A){}error(...A){}}class d{constructor(A,e){this.logger=A,this.prefix=e}log(A,...e){this.logger.log(`${this.prefix}${A}`,...e)}debug(A,...e){this.logger.debug(`${this.prefix}${A}`,...e)}info(A,...e){this.logger.info(`${this.prefix}${A}`,...e)}warn(A,...e){this.logger.warn(`${this.prefix}${A}`,...e)}error(A,...e){this.logger.error(`${this.prefix}${A}`,...e)}}class f{constructor(A=1){this.speed=A,this.startTime=performance.now()}getTime(){return this.speed*(performance.now()-this.startTime)}setTime(A){this.startTime=performance.now()-A/this.speed}}class w{constructor(){}getTime(A){}setTime(A){}}class h{constructor(A,e){this.input="function"==typeof A.next?A:A[Symbol.iterator](),this.xfs=e??[]}map(A){return this.transform(function(A){return e=>t=>{e(A(t))}}(A))}flatMap(A){return this.transform(function(A){return e=>t=>{A(t).forEach(e)}}(A))}filter(A){return this.transform(function(A){return e=>t=>{A(t)&&e(t)}}(A))}take(A){return this.transform(function(A){let e=0;return t=>V=>{e<A&&t(V),e+=1}}(A))}drop(A){return this.transform(function(A){let e=0;return t=>V=>{e+=1,e>A&&t(V)}}(A))}transform(A){return new h(this.input,this.xfs.concat([A]))}multiplex(A,e){return new h(new y(this[Symbol.iterator](),A[Symbol.iterator](),e))}toArray(){return Array.from(this)}[Symbol.iterator](){let A=0,e=[],t=!1;const V=(g=this.xfs,n=A=>e.push(A),g.reverse().reduce(((A,e)=>{const t=D(e(A.step));return{step:t.step,flush:()=>{t.flush(),A.flush()}}}),D(n)));var g,n;return{next:()=>{for(A===e.length&&(e=[],A=0);0===e.length;){const A=this.input.next();if(A.done)break;V.step(A.value)}return 0!==e.length||t||(V.flush(),t=!0),e.length>0?{done:!1,value:e[A++]}:{done:!0}}}}}function D(A){return"function"==typeof A?{step:A,flush:()=>{}}:A}class y{constructor(A,e,t){this.left=A,this.right=e,this.comparator=t}[Symbol.iterator](){let A,e;return{next:()=>{if(void 0===A&&void 0!==this.left){const e=this.left.next();e.done?this.left=void 0:A=e.value}if(void 0===e&&void 0!==this.right){const A=this.right.next();A.done?this.right=void 0:e=A.value}if(void 0===A&&void 0===e)return{done:!0};if(void 0===A){const A=e;return e=void 0,{done:!1,value:A}}if(void 0===e){const e=A;return A=void 0,{done:!1,value:e}}if(this.comparator(A,e)){const e=A;return A=void 0,{done:!1,value:e}}{const A=e;return e=void 0,{done:!1,value:A}}}}}}async function p(A,e){return function(A){const e={start:0},t=A.events.filter((A=>"m"===A[1])).map((A=>[A[0],A[2].label]));return{cols:A.cols,rows:A.rows,theme:A.theme,duration:A.duration,effectiveStartAt:A.effectiveStartAt,markers:t,segments:[e],async loadSegment(e){if(0!==e)throw new Error("unknown recording segment");return{snapshot:{cols:A.cols,rows:A.rows,init:""},events:A.events}}}}(function(A,{startAt:e=0,idleTimeLimit:t,inputOffset:V,markers:g}){let{events:n}=A;n instanceof h||(n=new h(n));e*=1e3,t=t??A.idleTimeLimit,t=void 0!==t?1e3*t:1/0,V=void 0!==V?1e3*V:void 0;const r={offset:0};n=n.map(function(A,e,t){let V=0,g=0;return function(n){const r=n[0]-V-A;return V=n[0],r>0&&(g+=r,n[0]<e&&(t.offset+=r)),[n[0]-g,n[1],n[2]]}}(t,e,r)),void 0!==g&&(g=new h(g).map(m),n=n.filter((A=>"m"!==A[1])).multiplex(g,((A,e)=>A[0]<e[0])));n=n.map(function(){let A=0;return function(e){return"m"===e[1]?[e[0],e[1],{index:A++,time:e[0],label:e[2]}]:e}}()),n=n.toArray(),void 0!==V&&(n=n.map((A=>"i"===A[1]?[A[0]+V,A[1],A[2]]:A)),n.sort(((A,e)=>A[0]-e[0])));if(0===n.length)throw new Error("recording is missing events");const i=n[n.length-1][0],o=e-r.offset;return{...A,events:n,duration:i,effectiveStartAt:o}}(await async function(A){const{parser:e,encoding:t="utf-8"}=A,V=await async function({url:A,data:e,fetchOpts:t={}}){if("string"==typeof A)return await k(A,t);if(Array.isArray(A))return await Promise.all(A.map((A=>k(A,t))));if(void 0!==e){"function"==typeof e&&(e=e()),e instanceof Promise||(e=Promise.resolve(e));const A=await e;return"string"==typeof A||A instanceof ArrayBuffer?new Response(A):A}throw new Error("failed fetching recording file: url/data missing in src")}(A);return await e(V,{encoding:t})}(A),e))}async function k(A,e){const t=await fetch(A,e);if(!t.ok)throw new Error(`failed fetching recording from ${A}: ${t.status} ${t.statusText}`);return t}function m(A){return"number"==typeof A?[1e3*A,"m",""]:[1e3*A[0],"m",A[1]]}function q(A){const e=n(A.foreground),t=n(A.background),V=A.palette;if(void 0===V)return;if(!e||!t||V.length<8)return;const g=[],r=Math.min(V.length,16);for(let A=0;A<r;A+=1){const e=n(V[A]);if(!e)return;g.push(e)}for(let A=g.length;A<16;A+=1)g.push(g[A-8]);return{foreground:e,background:t,palette:g}}function L(A,e={}){return function(A,{idleTimeLimit:e,markers:t}){if("string"!=typeof A.url)throw new Error("segmented recording source requires a URL");const V=[];void 0!==e&&V.push("idleTimeLimit");void 0!==t&&V.push("markers");for(const e of["inputOffset","parser","encoding"])Object.hasOwn(A,e)&&V.push(e);if(V.length>0)throw new Error(`segmented recordings do not support option: ${V.join(", ")}`)}(A,e),async function(A,{startAt:e=0}){const t=await F(A.url,A.fetchOpts??{});let V;try{V=await t.json()}catch(e){throw new Error(`failed parsing segmented recording index from ${A.url}: ${e.message}`)}!function(A){if(1!==A?.version)throw new Error(`unsupported segmented recording version: ${JSON.stringify(A?.version)}`);if(M(A.duration,"recording duration"),R(A.term,"recording terminal"),!Array.isArray(A.segments)||0===A.segments.length)throw new Error("segmented recording index is missing segments");let e=-1;if(A.segments.forEach(((t,V)=>{if(M(t?.start,`segment ${V} start`),"string"!=typeof t?.url||0===t.url.length)throw new Error(`segment ${V} is missing its URL`);if(0===V&&0!==t.start)throw new Error("first segment must start at 0");if(V>0&&(t.start<=e||t.start>=A.duration))throw new Error(`segment ${V} start must be strictly increasing and before duration`);e=t.start})),void 0!==A.markers&&!Array.isArray(A.markers))throw new Error("segmented recording markers must be an array");let t=-1;for(const[e,V]of(A.markers??[]).entries()){if(!Array.isArray(V)||2!==V.length||"string"!=typeof V[1])throw new Error(`invalid marker ${e} in segmented recording index`);if(M(V[0],`marker ${e} time`),V[0]<t||V[0]>A.duration)throw new Error(`marker ${e} time is out of order or range`);t=V[0]}}(V);const g=1e3*V.duration,n=(V.markers??[]).map((([A,e])=>[1e3*A,e])),r=V.segments.map((e=>({start:1e3*e.start,url:v(e.url,t.url||A.url)}))),i={cols:V.term.cols,rows:V.term.rows,theme:N(V.term.theme),duration:g,effectiveStartAt:Math.min(Math.max(1e3*e,0),g),markers:n,segments:r,async loadSegment(e){if(!Number.isInteger(e)||e<0||e>=r.length)throw new Error("unknown recording segment");const t=r[e],V=await F(t.url,A.fetchOpts??{});let g;try{g=await V.json()}catch(A){throw new Error(`failed parsing recording segment from ${t.url}: ${A.message}`)}return function(A,e,t){const V=t?.snapshot;if(R(V,`segment ${e} snapshot`),"string"!=typeof V.init)throw new Error(`segment ${e} snapshot init must be a string`);if(!Array.isArray(t.events)||0===t.events.length)throw new Error(`segment ${e} is missing events`);const g=A.segments[e].start,n=A.segments[e+1]?.start??A.duration;let r=-1,i=A.markers.findIndex((([A])=>A>=g));-1===i&&(i=A.markers.length);const o=t.events.map(((t,V)=>{if(!Array.isArray(t)||3!==t.length||"string"!=typeof t[1])throw new Error(`invalid event ${V} in segment ${e}`);const o=1e3*t[0];if(M(o,`event ${V} time in segment ${e}`,!0),o<r||o<g||(e+1<A.segments.length?o>=n:o>n))throw new Error(`event ${V} time is out of range in segment ${e}`);if(r=o,"m"===t[1]){if("string"!=typeof t[2])throw new Error(`marker event ${V} in segment ${e} must have a string label`);return[o,"m",{index:i++,time:o,label:t[2]}]}return[o,t[1],t[2]]}));if(e>0&&o[0][0]!==g)throw new Error(`segment ${e} first event must match its start`);if(e===A.segments.length-1&&o[o.length-1][0]!==A.duration)throw new Error("final segment event must match recording duration");return{snapshot:{cols:V.cols,rows:V.rows,init:V.init},events:o}}(i,e,g)}};return i}(A,e)}async function F(A,e){const t=await fetch(A,e);if(!t.ok)throw new Error(`failed fetching recording from ${A}: ${t.status} ${t.statusText}`);return t}function M(A,e,t=!1){if(!Number.isFinite(A)||A<0)throw new Error(`${e} must be a finite non-negative ${t?"millisecond":"second"} value`)}function R(A,e){if(!Number.isInteger(A?.cols)||A.cols<=0||!Number.isInteger(A?.rows)||A.rows<=0)throw new Error(`${e} must have positive integer cols and rows`)}function N(A){return q({foreground:A?.fg,background:A?.bg,palette:"string"==typeof A?.palette?A.palette.split(":"):void 0})}function v(A,e){return new URL(A,new URL(e,globalThis.location?.href??"http://localhost/")).href}function b(A,e){let t=0,V=A.segments.length;for(;t+1<V;){const g=Math.floor((t+V)/2);A.segments[g].start<=e?t=g:V=g}return t}async function G(A){if(A instanceof Response){const e=await A.text(),t=function(A){const e=A.split("\n");let t;try{t=JSON.parse(e[0])}catch(A){return}const V=new h(e).drop(1).filter((A=>"["===A[0])).map(JSON.parse);return{header:t,events:V}}(e);if(void 0!==t){const{header:A,events:e}=t;if(2===A.version)return S(A,e);if(3===A.version)return J(A,e);throw new Error(`asciicast v${A.version} format not supported`)}{const A=JSON.parse(e);if(1===A.version)return U(A)}}else{if("object"==typeof A&&1===A.version)return U(A);if(Array.isArray(A)){const e=A[0];if(2===e.version){return S(e,A.slice(1,A.length))}if(3===e.version){return J(e,A.slice(1,A.length))}throw new Error(`asciicast v${e.version} format not supported`)}}throw new Error("invalid data")}function U(A){let e=0;const t=new h(A.stdout).map((A=>(e+=1e3*A[0],[e,"o",A[1]])));return{cols:0===A.width?80:A.width,rows:0===A.height?24:A.height,events:t}}function S(A,e){return e instanceof h||(e=new h(e)),e=e.map((A=>[1e3*A[0],A[1],A[2]])),{cols:0===A.width?80:A.width,rows:0===A.height?24:A.height,theme:Y(A.theme),events:e,idleTimeLimit:A.idle_time_limit}}function J(A,e){e instanceof h||(e=new h(e));let t=0;return e=e.map((A=>(t+=1e3*A[0],[t,A[1],A[2]]))),{cols:0===A.term.cols?80:A.term.cols,rows:0===A.term.rows?24:A.term.rows,theme:Y(A.term?.theme),events:e,idleTimeLimit:A.idle_time_limit}}function Y(A){const e="string"==typeof A?.palette?A.palette.split(":"):void 0;return q({foreground:A?.fg,background:A?.bg,palette:e})}function T(A,e,t,V,g,n){const r=function(A){return function(e,t){"o"===e?A("output",t):"i"===e?A("input",{data:t}):"r"===e?A("resize",t):"m"===e&&A("marker",t)}}(e);if(0===A)return n.debug("using no buffer"),function(A){return{pushEvent(e){A(e[1],e[2])},pushText(e){A("o",e)},stop(){}}}(r);{let e;return"number"==typeof(A=A??{})?(n.debug(`using fixed time buffer (${A} ms)`),e=e=>A):"function"==typeof A?(n.debug("using custom dynamic buffer"),e=A({logger:n})):(n.debug("using adaptive buffer",A),e=function({logger:A}={},{minBufferTime:e=50,bufferLevelStep:t=100,maxBufferLevel:V=50,transitionDuration:g=500,peakHalfLifeUp:n=100,peakHalfLifeDown:r=1e4,floorHalfLifeUp:i=5e3,floorHalfLifeDown:o=100,idealHalfLifeUp:I=1e3,idealHalfLifeDown:B=5e3,safetyMultiplier:s=1.2,minImprovementDuration:C=3e3}={}){function Q(A){return 0===A?e:t*A}let a=1,E=Q(a),c=performance.now(),l=null,u=null,d=null,f=null,w=null,h=null;return function(D){const y=performance.now(),p=Math.max(0,y-c);if(c=y,null===l)l=D;else if(D>l){const A=1-Math.pow(2,-p/n);l+=A*(D-l)}else{const A=1-Math.pow(2,-p/r);l+=A*(D-l)}if(l=Math.max(l,0),null===u)u=D;else if(D>u){const A=1-Math.pow(2,-p/i);u+=A*(D-u)}else{const A=1-Math.pow(2,-p/o);u+=A*(D-u)}u=Math.max(u,0);const k=s*(l+(l-u));if(null===d)d=k;else if(k>d){const A=1-Math.pow(2,-p/I);d+=+A*(k-d)}else{const A=1-Math.pow(2,-p/B);d+=+A*(k-d)}let m;var q,L,F;return d<=e?m=0:(q=Math.ceil(d/t),L=1,F=V,m=Math.min(F,Math.max(L,q))),D>E&&A.debug("buffer underrun",{latency:D,bufferTime:E}),m>a?(D>E?a=Math.min(m,a+3):a+=1,w=Q(a),h=(w-E)/g,f=null,A.debug("raising buffer",{latency:D,bufferTime:E,targetBufferTime:w})):m<a?(null==f&&(f=y),y-f>=C&&(a-=1,w=Q(a),h=(w-E)/g,f=y,A.debug("lowering buffer",{latency:D,bufferTime:E,targetBufferTime:w}))):f=null,null!==w&&(E+=h*p,(h>=0&&E>w||h<0&&E<w)&&(E=w,w=null)),E}}({logger:n},A)),function(A,e,t,V,g,n=1/60){const r=1e3*n;let i,o=performance.now()-g,I=A(0),B=[],s=-r,C=!1;function Q(){return performance.now()-o}function a(A){B.push(A),void 0!==i&&(i(E()),i=void 0)}function E(){if(B.length>0){const A=B;return B=[],A}return new Promise((A=>{i=A}))}async function c(){for(;!C;){const A=await E();if(C)return;let e=0;for(;e<A.length;)e=await l(A,e)}}async function l(A,V){const g=A[V],n=g[3];if(n-s>=r){const e=n-Q();if(e>0&&(await(i=e,new Promise((A=>{setTimeout(A,i)}))),C))return A.length;t(g[0]),s=n}var i;return"o"===g[1]?u(A,V):(e(g[1],g[2]),V+1)}function u(A,t){const V=A[t],g=V[0]+r,n=[];let i=V;for(;void 0!==i&&"o"===i[1]&&i[0]<g;)n.push(i[2]),i=A[++t];return e("o",n),t}return queueMicrotask(c),{pushEvent(e){let t=Q()-e[0];t<0&&(V.debug(`correcting epoch by ${t} ms`),o+=t,t=0),I=A(t),a([e[0],e[1],e[2],e[0]+I])},pushText(A){const e=Q();a([e,"o",A,e+I])},stop(){C=!0,void 0!==i&&(i([]),i=void 0)}}}(e,r,t,n,V??0,g)}}const K=1e3,H=1e6;function O(A){const e=new TextDecoder,t=new TextDecoder;let V,g=function(A){const e=(new TextDecoder).decode(A);if("ALiS
"!==e)throw new Error("not an ALiS v1 live stream");g=r},n=0;function r(A){const e=new $(new DataView(A)),t=e.getUint8();if(1!==t)throw new Error(`expected reset (0x01) frame, got ${t}`);return i(e,A)}function i(A,t){A.decodeVarUint();let r=A.decodeVarUint();V=r,r/=K,n=0;const i=A.decodeVarUint(),I=A.decodeVarUint(),B=A.getUint8();let s;if(8===B){const e=30;s=x(new Uint8Array(t,A.offset,e)),A.forward(e)}else if(16===B){const e=54;s=x(new Uint8Array(t,A.offset,e)),A.forward(e)}else if(0!==B)throw new Error(`alis: invalid theme format (${B})`);const C=A.decodeVarUint();let Q;return C>0&&(Q=e.decode(new Uint8Array(t,A.offset,C))),g=o,{time:r,term:{size:{cols:i,rows:I},theme:s,init:Q}}}function o(o){const I=new $(new DataView(o)),B=I.getUint8();return 1===B?i(I,o):111===B?function(A,t){A.decodeVarUint();const g=A.decodeVarUint();V+=g;const n=A.decodeVarUint(),r=e.decode(new Uint8Array(t,A.offset,n));return[V/K,"o",r]}(I,o):105===B?function(A,e){A.decodeVarUint();const g=A.decodeVarUint();V+=g;const n=A.decodeVarUint(),r=t.decode(new Uint8Array(e,A.offset,n));return[V/K,"i",r]}(I,o):114===B?function(A){A.decodeVarUint();const e=A.decodeVarUint();V+=e;const t=A.decodeVarUint(),g=A.decodeVarUint();return[V/K,"r",{cols:t,rows:g}]}(I):109===B?function(A,e){A.decodeVarUint();const t=A.decodeVarUint();V+=t;const g=A.decodeVarUint(),r=new TextDecoder,i=n++,o=V/K,I=V/H,B=r.decode(new Uint8Array(e,A.offset,g));return[o,"m",{index:i,time:I,label:B}]}(I,o):120===B?function(A){A.decodeVarUint();const e=A.decodeVarUint();V+=e;const t=A.decodeVarUint();return[V/K,"x",{status:t}]}(I):4===B?(g=r,!1):void A.debug(`alis: unknown frame type: ${B}`)}return function(A){return g(A)}}function x(A){const e=A.length/3,t=Z(A[0],A[1],A[2]),V=Z(A[3],A[4],A[5]),g=[];for(let t=2;t<e;t++)g.push(Z(A[3*t],A[3*t+1],A[3*t+2]));return q({foreground:t,background:V,palette:g})}function Z(A,e,t){return`#${W(A)}${W(e)}${W(t)}`}function W(A){return A.toString(16).padStart(2,"0")}class ${constructor(A,e=0){this.inner=A,this.offset=e}forward(A){this.offset+=A}getUint8(){const A=this.inner.getUint8(this.offset);return this.offset+=1,A}decodeVarUint(){let A=BigInt(0),e=BigInt(0),t=this.getUint8();for(;t>127;)t&=127,A+=BigInt(t)<<e,e+=BigInt(7),t=this.getUint8();return A+=BigInt(t)<<e,Number(A)}}function j(){const A=new TextDecoder;let e=function(V){const g=A.decode(V,{stream:!0}),[n,r]=function(A){const e=A.match(/\x1b\[8;(\d+);(\d+)t/);if(null!==e)return[parseInt(e[2],10),parseInt(e[1],10)]}(g)??function(A){const e=A.match(/\[.*COLUMNS="(\d{1,3})" LINES="(\d{1,3})".*\]/);if(null!==e)return[parseInt(e[1],10),parseInt(e[2],10)]}(g)??[80,24];return e=t,{time:0,term:{size:{cols:n,rows:r},init:g}}};function t(e){return A.decode(e,{stream:!0})}return function(A){return e(A)}}function z(A){const e=Math.min(500*Math.pow(2,A),1e4);return Math.random()*e}function X(A){if(A.length<13)return;const e=function(A){const e=P(A.subarray(0,4)),t=P(A.subarray(4,8));return e+t/1e6}(A.subarray(0,8)),t=P(A.subarray(8,12));return{time:e,data:A.subarray(12,12+t),len:t+12}}function P(A){return A[0]+256*A[1]+256*A[2]*256+256*A[3]*256*256}class _{constructor(A,t){this.logger=t.logger,this.driverFactory=function(A){if("function"==typeof A)return A;"string"==typeof A&&(A="ws://"==A.substring(0,5)||"wss://"==A.substring(0,6)?{driver:"websocket",url:A}:"clock:"==A.substring(0,6)?{driver:"clock"}:"random:"==A.substring(0,7)?{driver:"random"}:"benchmark:"==A.substring(0,10)?{driver:"benchmark",url:A.substring(10)}:{driver:"recording",url:A});void 0===A.driver&&(A.driver="recording");if("recording"==A.driver&&("segmented"!==A.format&&void 0===A.parser&&(A.parser="asciicast"),"string"==typeof A.parser)){if(!eA.has(A.parser))throw new Error(`unknown parser: ${A.parser}`);A.parser=eA.get(A.parser)}if(AA.has(A.driver)){const e=AA.get(A.driver);return(t,V)=>e(A,t,V)}throw new Error(`unsupported driver: ${JSON.stringify(A)}`)}(A),this.driver=null,this.cols=t.cols,this.rows=t.rows,this.speed=t.speed,this.loop=t.loop,this.autoPlay=t.autoPlay,this.idleTimeLimit=t.idleTimeLimit,this.preload=t.preload,this.startAt=e(t.startAt),this.poster=this._parsePoster(t.poster),this.markers=t.markers,this.pauseOnMarkers=t.pauseOnMarkers,this.audioUrl=t.audioUrl,this.initPromise=null,this.commandQueue=Promise.resolve(),this.startupPromise=new Promise((A=>{this.resolveStartup=A})),this.eventHandlers=new Map([["ended",[]],["error",[]],["input",[]],["loading",[]],["marker",[]],["metadata",[]],["muted",[]],["offline",[]],["output",[]],["pause",[]],["play",[]],["playing",[]],["reset",[]],["resize",[]],["ready",[]],["seeked",[]]])}init(){return null===this.initPromise&&(this.initPromise=this._init()),this.initPromise}terminalReady(){this.resolveStartup()}async _init(){await this.startupPromise,this.driver=this.driverFactory({dispatch:this._dispatchEvent.bind(this),logger:this.logger},{cols:this.cols,rows:this.rows,speed:this.speed,idleTimeLimit:this.idleTimeLimit,startAt:this.startAt,preload:this.preload,loop:this.loop,poster:this.autoPlay?void 0:this.poster,markers:this.markers,pauseOnMarkers:this.pauseOnMarkers,audioUrl:this.audioUrl});const A={isPausable:!!this.driver.pause,isSeekable:!!this.driver.seek};this._installDriverDefaults(),this.driver.init&&await this.driver.init(),this.autoPlay&&await this.driver.play(),this._dispatchEvent("ready",A)}_installDriverDefaults(){if(void 0===this.driver.stop&&(this.driver.stop=()=>{}),void 0===this.driver.pause&&(this.driver.pause=()=>{}),void 0===this.driver.seek&&(this.driver.seek=A=>!1),void 0===this.driver.step&&(this.driver.step=A=>{}),void 0===this.driver.mute&&(this.driver.mute=()=>{}),void 0===this.driver.unmute&&(this.driver.unmute=()=>{}),void 0===this.driver.getDuration&&(this.driver.getDuration=()=>{}),void 0===this.driver.getCurrentTime){const A=this.driver.play;let e=new w;this.driver.play=()=>(e=new f(this.speed),A()),this.driver.getCurrentTime=()=>{const A=e.getTime();return"number"==typeof A?A/1e3:A}}}_enqueue(A){const e=async()=>(await this.init(),A.call(this)),t=this.commandQueue.then(e,e);return this.commandQueue=t.catch((()=>{})),t}play(){return this._enqueue((function(){return this.driver.play()}))}pause(){return this._enqueue((function(){return this.driver.pause()}))}seek(A){return this._enqueue((function(){return this.driver.seek(A)}))}step(A){return this._enqueue((function(){return this.driver.step(A)}))}stop(){return this._enqueue((function(){return this.driver.stop()}))}mute(){return this._enqueue((function(){return this.driver.mute()}))}unmute(){return this._enqueue((function(){return this.driver.unmute()}))}getCurrentTime(){return this.driver?this.driver.getCurrentTime():0}getRemainingTime(){const A=this.getDuration();if("number"==typeof A)return A-Math.min(this.getCurrentTime(),A)}getProgress(){const A=this.getDuration();if("number"==typeof A)return Math.min(this.getCurrentTime(),A)/A}getDuration(){if(this.driver)return this.driver.getDuration()}addEventListener(A,e){this.eventHandlers.get(A).push(e)}removeEventListener(A,e){const t=this.eventHandlers.get(A);if(!t)return;const V=t.indexOf(e);-1!==V&&t.splice(V,1)}_dispatchEvent(A,e={}){for(const t of[...this.eventHandlers.get(A)])try{t(e)}catch(e){this.logger.error(`event handler for "${A}" failed`,e),"function"==typeof globalThis.reportError?globalThis.reportError(e):setTimeout((()=>{throw e}),0)}}_parsePoster(A){if("string"==typeof A)return"data:text/plain,"==A.substring(0,16)?{type:"text",value:A.substring(16)}:"npt:"==A.substring(0,4)?{type:"npt",value:e(A.substring(4))}:void 0}}const AA=new Map([["benchmark",function({url:A,iterations:e=10},{dispatch:t}){let V,g=0;return{async init(){const e=await G(await fetch(A)),{cols:n,rows:r,events:i}=e;V=Array.from(i).filter((([A,e,t])=>"o"===e)).map((([A,e,t])=>[A,t]));for(const[A,e]of V)g+=new Blob([e]).size;t("reset",{size:{cols:n,rows:r}})},play(){const A=performance.now();for(let A=0;A<e;A++){for(const[A,e]of V)t("output",e);t("output","c")}const n=(performance.now()-A)/1e3,r=g*e/n,i=g/1048576*e/n;return console.info("benchmark: result",{byteCount:g,iterations:e,duration:n,throughput:r,throughputMbs:i}),setTimeout((()=>{t("ended")}),0),!0}}}],["clock",function({hourColor:A=3,minuteColor:e=4,separatorColor:t=9},{dispatch:V},{cols:g=5,rows:n=1}){const r=Math.floor(n/2),i=Math.floor(g/2)-2,o=`[?25l[${r}B`;let I;const B=()=>{(()=>{const V=new Date,g=V.getHours(),n=V.getMinutes(),r=[];r.push("\r");for(let A=0;A<i;A++)r.push(" ");return r.push(`[3${A}m`),g<10&&r.push("0"),r.push(`${g}`),r.push(`[3${t};5m:`),r.push(`[3${e}m`),n<10&&r.push("0"),r.push(`${n}`),r})().forEach((A=>{V("output",A)}))};return{init:()=>{V("reset",{size:{cols:g,rows:n}}),V("output",o),B()},play:()=>(void 0!==I||(V("play"),V("playing"),V("output",o),B(),I=setInterval(B,1e3)),!0),stop:()=>{clearInterval(I)},getCurrentTime:()=>{const A=new Date;return 60*A.getHours()+A.getMinutes()}}}],["eventsource",function({url:A,bufferTime:e,minFrameTime:t},{dispatch:V,logger:g}){let n,r;g=new d(g,"eventsource: ");let i=new w;function o(A){void 0!==r&&r.stop(),r=T(e,V,(A=>i.setTime(A)),A,t,g)}return{play:()=>(n||(V("play"),n=new EventSource(A),n.addEventListener("open",(()=>{g.info("opened"),o()})),n.addEventListener("error",(A=>{g.info("errored"),g.debug({e:A}),V("loading")})),n.addEventListener("message",(A=>{const e=JSON.parse(A.data);if(Array.isArray(e))r.pushEvent([1e3*e[0],e[1],e[2]]);else if(void 0!==e.cols||void 0!==e.width){const A=e.cols??e.width,t=e.rows??e.height,n="number"==typeof e.time?1e3*e.time:void 0;g.debug(`vt reset (${A}x${t})`),o(n),V("reset",{size:{cols:A,rows:t},init:e.init??void 0}),i=new f,void 0!==n&&i.setTime(n),V("playing")}else"offline"===e.state&&(g.info("stream offline"),V("offline",{message:"Stream offline"}),i=new w)})),n.addEventListener("done",(()=>{g.info("closed"),n.close(),V("ended",{message:"Stream ended"})}))),!0),stop:()=>{void 0!==r&&r.stop(),void 0!==n&&n.close()},getCurrentTime:()=>{const A=i.getTime();return"number"==typeof A?A/1e3:A}}}],["random",function(A,{dispatch:e},{speed:t}){const V=" ".charCodeAt(0),g="~".charCodeAt(0)-V;let n;const r=()=>{const A=Math.pow(5,4*Math.random());n=setTimeout(i,A/t)},i=()=>{r();const A=String.fromCharCode(V+Math.floor(Math.random()*g));e("output",A)};return{play(){if(void 0!==n)return!0;e("play"),e("playing"),r()},stop(){clearInterval(n)}}}],["recording",function(A,{dispatch:e,logger:V},{speed:g,idleTimeLimit:n,startAt:r,preload:i,loop:o,poster:I,markers:B,pauseOnMarkers:s,cols:C,rows:Q,audioUrl:a}){const E="cold",c="loading",l="ready.initial",u="ready.paused",d="ready.starting",f="ready.playing",w="ready.buffering.whilePaused",h="ready.buffering.toResume",D="ready.ended",y="failed",k="stopped",m="initRequested",q="playRequested",F="deferredPlayReady",M="pauseRequested",R="seekRequested",N="stepRequested",v="stopRequested",G="loadSucceeded",U="loadFailed",S="playbackStartConfirmed",J="playbackStartRejected",Y="playbackEnded",T="audioWaiting",K="audioPlaying",H="segmentWaiting",O="segmentReady",x="markerReached",Z="play",W="seek",$=1e3*(A.minFrameTime??1/60);let j=()=>performance.now()*g,z=E,X=[],P=!1;const _={recording:void 0,segmentIndex:void 0,segment:void 0,segmentCache:new Map,positionGeneration:0,markers:void 0,duration:void 0,effectiveStartAt:void 0,recordingEventTimeoutId:void 0,nextEventIndex:0,lastEventTime:0,startTime:void 0,pauseElapsedTime:void 0,playCount:0,waitingTimeout:void 0,loadingTimeout:void 0,audioCtx:void 0,audioElement:void 0,audioSeekable:!1,loaded:void 0,posterVisible:!1,posterRenderableAfterLoad:void 0!==I,failureError:null,segmentWaiting:!1};function AA(A=z){return A===w||A===h}function eA(){return!0===o||"number"==typeof o&&_.playCount<o}function tA(t){return void 0===_.loaded&&(_.loaded=async function(t){const g=_.positionGeneration;_.loadingTimeout=setTimeout((()=>{e("loading")}),3e3);try{const e=function(A,e){if("segmented"===A.format)return L(A,e);return p(A,e)}(A,{idleTimeLimit:n,startAt:r,markers:B,inputOffset:A.inputOffset}),i=async function(A){if(!A)return!1;_.audioElement=await async function(A){const e=new Audio;let t,V;e.preload="metadata",e.loop=!1,e.crossOrigin="anonymous";const g=new Promise(((A,e)=>{t=A,V=e}));function n(){e.removeEventListener("canplay",r),e.removeEventListener("error",i),e.removeEventListener("abort",o)}function r(){n(),t()}function i(){n(),V(new Error(`failed loading audio from ${A}`))}function o(){n(),V(new Error(`audio loading aborted for ${A}`))}return e.addEventListener("canplay",r),e.addEventListener("error",i),e.addEventListener("abort",o),e.src=A,e.load(),await g,e}(A),_.audioSeekable=!Number.isNaN(_.audioElement.duration)&&_.audioElement.duration!==1/0&&_.audioElement.seekable.length>0&&_.audioElement.seekable.end(_.audioElement.seekable.length-1)===_.audioElement.duration,_.audioSeekable?(_.audioElement.addEventListener("playing",vA),_.audioElement.addEventListener("waiting",NA)):V.warn(`audio is not seekable - you must enable range request support on the server providing ${_.audioElement.src} for audio seeking to work`);return!0}(a).catch((A=>(V.warn(`audio load failed: ${A.message}`),!1))),o=await e;if(g!==_.positionGeneration)return!1;_.recording=o,_.duration=o.duration,_.effectiveStartAt=o.effectiveStartAt,_.markers=o.markers;const s=b(o,t??("npt"===I?.type?1e3*I.value:_.effectiveStartAt)??0),C=await aA(s,!0);if(g!==_.positionGeneration)return!1;QA(s,C);const Q=await i;if(g!==_.positionGeneration)return!1;IA(G,{hasAudio:Q})}catch(A){throw BA(U,{error:A}),A}finally{WA()}}(t),_.loaded.catch((()=>{}))),_.loaded}function VA(A,n,r={}){switch(n){case m:if(A===E){if(i||"npt"==I?.type)return{nextState:c,action:()=>tA()};if("text"==I?.type)return{nextState:A,action:()=>(sA(),void(_.posterRenderableAfterLoad=!1))}}return{nextState:A};case G:return A!==c?{nextState:A}:{nextState:l,action:()=>{e("metadata",{duration:_.duration/1e3,markers:_.markers.map((([A,e])=>[A/1e3,e])),hasAudio:r.hasAudio}),YA(_.segment),sA()}};case U:return A!==c?{nextState:A}:{nextState:y,action:()=>{_.failureError=r.error,e("error",t(r.error))}};case q:return A===E?{nextState:c,action:()=>(CA(),e("play"),tA().then((()=>IA(F))))}:A===l||A===u||A===D?{nextState:d,action:()=>(e("play"),CA(),HA(Z))}:A===w?{nextState:h,action:()=>(e("play"),!!_.segmentWaiting||(!_.audioElement||_.audioElement.play().catch((A=>{throw IA(J),A}))))}:A===h||A===f?{nextState:A,action:()=>(e("play"),!0)}:{nextState:A};case F:return A===l?{nextState:d,action:()=>(CA(),HA(Z))}:{nextState:A};case S:return A!==d?{nextState:A}:{nextState:f,action:()=>(qA(),r.reason===W?e("seeked"):e("playing"),!0)};case J:return A===d?{nextState:u}:A===h?{nextState:w}:{nextState:A};case Y:return A!==f?{nextState:A}:eA()?{nextState:f,action:jA}:{nextState:D,action:zA};case T:return A===f?{nextState:h,action:()=>{V.debug("pausing session playback"),kA(),xA()}}:A===w||A===h?{nextState:A,action:xA}:{nextState:A};case K:return _.segmentWaiting?{nextState:A}:A===h?{nextState:f,action:()=>{V.debug("resuming session playback"),ZA(),qA(),e("playing")}}:A===w?{nextState:u,action:()=>{ZA()}}:{nextState:A};case H:return A===f?{nextState:h,action:()=>{var A;_.segmentWaiting=!0,A=r.time,yA(),_.pauseElapsedTime=A,xA(),_.audioElement&&_.audioElement.pause()}}:{nextState:A};case O:return _.segmentWaiting=!1,A===h?{nextState:A,action:dA}:A===w?{nextState:u,action:ZA}:{nextState:A};case M:return A===f?{nextState:u,action:OA}:A===h?{nextState:w,action:()=>(_.audioElement&&_.audioElement.pause(),!0)}:{nextState:A,action:()=>!0};case R:{if(A===E)return{nextState:c,action:()=>tA("number"==typeof r.where?1e3*r.where:void 0).then((()=>LA(r.where)))};if(AA(A)&&!_.segmentWaiting)return{nextState:A,action:()=>!1};if(A!==l&&A!==u&&A!==D&&A!==f&&A!==w&&A!==h)return{nextState:A};const t=r.seekOperation;return t.noOp?{nextState:A,action:()=>!1}:{nextState:t.reachedEnd?D:A===f||A===h?d:u,action:()=>(CA(),async function(A,t){const V=t===f||t===h,g=++_.positionGeneration;t===f&&kA();_.segmentWaiting=!1,ZA(),_.audioElement&&_.audioElement.pause();if(!await KA(A.targetTime,g))return!1;if(g!==_.positionGeneration)return!1;if(A.reachedEnd)return e("seeked"),e("ended"),!0;if(V)return await HA(W);return e("seeked"),!0}(t,A))}}case N:return A===E?{nextState:c,action:()=>tA().then((()=>oA(N,r)))}:A===f||AA(A)||A!==l&&A!==u&&A!==D?{nextState:A}:{nextState:A,action:()=>async function(A=1){const t=++_.positionGeneration,V=await async function(A,e){let t,V=Math.abs(A),g=_.segmentIndex,n=A>0?_.nextEventIndex:_.nextEventIndex-2;for(;g>=0&&g<_.recording.segments.length;){if(e!==_.positionGeneration)return;cA([g-1,g,g+1]);const r=await EA(g,e);if(e!==_.positionGeneration)return;if(A>0){for(let A=Math.max(n,0);A<r.events.length;A++)if("o"===r.events[A][1]&&0===--V){t={time:r.events[A][0]};break}if(t)break;g++,n=0}else{for(let A=Math.min(n,r.events.length-1);A>=0;A--)if("o"===r.events[A][1]&&0===--V){t={time:r.events[A][0]};break}if(t)break;g--,n=Number.MAX_SAFE_INTEGER}}t&&(t.reachedEnd=t.time>=_.duration);return t}(A,t);if(void 0===V||t!==_.positionGeneration)return;if(CA(),!await KA(V.time,t,A<0))return;_.audioElement&&_.audioSeekable&&(_.audioElement.currentTime=V.time/1e3/g);V.reachedEnd?(z=D,e("ended")):z=u}(r.n)};case x:return A!==f?{nextState:A}:s?{nextState:u,action:()=>(GA(r.data),OA(r.time))}:{nextState:A,action:()=>GA(r.data)};case v:return{nextState:k,action:XA};default:return{nextState:A}}}function gA(A,e={}){X.push({event:A,payload:e})}function nA(A,e={}){const t=z,{nextState:V,action:g}=VA(t,A,e);return V!==z&&(z=V),g?.()}function rA(A){_.failureError||z===k||(X.length=0,_.segmentWaiting=!1,$A(),_.audioElement&&_.audioElement.pause(),_.failureError=A,z=y,e("error",t(A)))}function iA(){if(_.failureError)throw _.failureError;if(z===k)throw new Error("driver has been stopped")}function oA(A,e={}){return iA(),IA(A,e)}function IA(A,e={}){if(!_.failureError&&z!==k){if(P)throw new Error("re-entrant sendDriverEvent() is not allowed during queue processing");P=!0;try{const t=nA(A,e);for(;X.length>0;){const A=X.shift();nA(A.event,A.payload)}return t}catch(A){throw rA(A),A}finally{P=!1,X.length=0}}}function BA(A,e={}){return P?(gA(A,e),!0):IA(A,e)}function sA(){_.posterRenderableAfterLoad&&("npt"==I.type?TA(1e3*I.value,!1,!1):"text"==I.type&&bA(I.value),_.posterVisible=!0)}function CA(){_.posterVisible&&bA("c"),_.posterVisible=!1,_.posterRenderableAfterLoad=!1}function QA(A,e){_.segmentIndex=A,_.segment=e,_.nextEventIndex=0,_.lastEventTime=_.recording.segments[A].start}function aA(A,e=!1){let t=_.segmentCache.get(A);return void 0===t&&(t={},t.promise=_.recording.loadSegment(A).then((e=>(_.segmentCache.get(A)===t&&(t.data=e),e)),(g=>{throw _.segmentCache.get(A)===t&&_.segmentCache.delete(A),e||V.warn(`segment prefetch failed: ${g.message}`),g})),_.segmentCache.set(A,t),e||t.promise.catch((()=>{}))),t.promise}async function EA(A,e,t){void 0===_.segmentCache.get(A)?.data&&t?.();try{return await aA(A,!0)}catch(A){throw e===_.positionGeneration&&z!==k&&rA(A),A}}function cA(A){const e=new Set(A.filter((A=>A>=0)));for(const A of _.segmentCache.keys())e.has(A)||_.segmentCache.delete(A)}function lA(){const A=_.recording.segments.length-1,e=_.segmentIndex<A?_.segmentIndex+1:eA()?0:void 0;cA([_.segmentIndex-1,_.segmentIndex,e]),void 0!==e&&aA(e)}async function uA(){const A=_.segmentIndex+1,e=_.recording.segments[A].start,t=++_.positionGeneration;try{const V=await EA(A,t,(()=>{IA(H,{time:e})}));if(t!==_.positionGeneration||z===k)return;QA(A,V),lA(),z===h||z===w?await IA(O):z===f&&fA()}catch{}}function dA(){if(ZA(),_.audioElement)return _.audioElement.play().then((()=>IA(K)),(A=>(IA(J),V.warn(`audio resume failed: ${A.message}`),!1)));gA(K)}function fA(){const A=_.segment.events[_.nextEventIndex];if(A)_.recordingEventTimeoutId=wA(hA,A[0]);else if(_.segmentIndex<_.recording.segments.length-1){const A=_.recording.segments[_.segmentIndex+1].start;_.recordingEventTimeoutId=wA(uA,A)}else BA(Y)}function wA(A,e){let t=(e-(j()-_.startTime))/g;return t<0&&(t=0),setTimeout(A,t)}function hA(){for(;void 0!==_.segment.events[_.nextEventIndex];){if(DA())return;const A=_.segment.events[_.nextEventIndex];if(void 0===A)break;if(j()-_.startTime<=A[0])break}fA()}function DA(){const A=_.segment.events[_.nextEventIndex];return"o"===A[1]?(function(){const A=_.segment.events[_.nextEventIndex],e=A[0]+$,t=[];let V=A;for(;void 0!==V&&"o"===V[1]&&V[0]<e;)t.push(V[2]),_.lastEventTime=V[0],_.nextEventIndex++,V=_.segment.events[_.nextEventIndex];bA(t)}(),!1):(_.lastEventTime=A[0],_.nextEventIndex++,pA(A))}function yA(){clearTimeout(_.recordingEventTimeoutId),_.recordingEventTimeoutId=null}function pA(A){const[t,V,g]=A;if("o"===V)bA(g);else if("i"===V)e("input",{data:g});else if("r"===V){const[A,t]=g.split("x").map((A=>Number.parseInt(A,10)));e("resize",JA(A,t))}else if("m"===V)return!0===IA(x,{data:g,time:t});return!1}function kA(){yA(),_.pauseElapsedTime=j()-_.startTime}function mA(){_.audioElement&&!_.audioCtx&&function(){_.audioCtx=new AudioContext({latencyHint:"interactive"});const A=_.audioCtx.createMediaElementSource(_.audioElement);A.connect(_.audioCtx.destination),j=RA}()}function qA(){_.startTime=j()-_.pauseElapsedTime,_.pauseElapsedTime=null,fA()}function LA(A){return iA(),function(A){if("number"==typeof A){if(Number.isFinite(A))return}else if("string"==typeof A){if(function(A){return"<<"===A||">>"===A||"<<<"===A||">>>"===A}(A)||void 0!==UA(A))return}else if("object"==typeof A&&null!==A&&("prev"===A.marker||"next"===A.marker||Number.isInteger(A.marker)&&A.marker>=0))return;throw new Error(`invalid seek target: ${JSON.stringify(A)}`)}(A),IA(R,z===E?{where:A}:{seekOperation:SA(z,A)})}function FA(A){if(0==_.markers.length)return;let e,t=0,V=_.markers[t];for(;V&&V[0]<A;)e=V[0],V=_.markers[++t];return e}function MA(){return z===f?j()-_.startTime:_.pauseElapsedTime??0}function RA(){if(!_.audioCtx)throw new Error("audio context not started - can't tell time!");const{contextTime:A,performanceTime:e}=_.audioCtx.getOutputTimestamp();return 0===e?1e3*A:1e3*A+(performance.now()-e)}function NA(){V.debug("audio buffering"),IA(T)}function vA(){V.debug("audio resumed"),IA(K)}function bA(A){e("output",A)}function GA(A){e("marker",{...A,time:A.time/1e3})}function UA(A){if(!A.endsWith("%"))return;const e=Number(A.slice(0,-1));return Number.isFinite(e)?e:void 0}function SA(A,e){const t=MA(),V=A===f;let g=e;if("number"==typeof g)g*=1e3;else if("string"==typeof g)"<<"===g?g=t-5e3:">>"===g?g=t+5e3:"<<<"===g?g=t-.1*_.duration:">>>"===g?g=t+.1*_.duration:"%"===g[g.length-1]&&(g=UA(g)/100*_.duration);else if("object"==typeof g)if("prev"===g.marker)g=FA(t)??0,V&&t-g<1e3&&(g=FA(g)??0);else if("next"===g.marker)g=function(A){if(0==_.markers.length)return;let e,t=_.markers.length-1,V=_.markers[t];for(;V&&V[0]>A;)e=V[0],V=_.markers[--t];return e}(t)??_.duration;else if("number"==typeof g.marker){const A=_.markers[g.marker];if(void 0===A)throw new Error(`invalid marker index: ${g.marker}`);g=A[0]}const n=Math.min(Math.max(g,0),_.duration);return{targetTime:n,reachedEnd:n>=_.duration,noOp:n===_.pauseElapsedTime}}function JA(A,e){return{cols:C??A,rows:Q??e}}function YA(A,t=!1){t&&bA("c"),e("reset",{size:JA(A.snapshot.cols,A.snapshot.rows),init:A.snapshot.init,theme:_.recording.theme??null})}function TA(A,e=!0,t=!0){let V=_.segment.events[_.nextEventIndex],n=[];for(;V&&(t?V[0]<=A:V[0]<A);)"o"===V[1]?n.push(V[2]):"r"===V[1]&&(n.length>0&&(bA(n),n=[]),pA(V)),_.lastEventTime=V[0],V=_.segment.events[++_.nextEventIndex];n.length>0&&bA(n),_.pauseElapsedTime=A,e&&(_.effectiveStartAt=null),_.audioElement&&_.audioSeekable&&(_.audioElement.currentTime=A/1e3/g)}async function KA(A,e,t=!1){const V=b(_.recording,A);if(e!==_.positionGeneration)return!1;if(!t&&V===_.segmentIndex&&A>=_.lastEventTime)return TA(A),!0;cA([V-1,V,V+1]);const g=await EA(V,e);return e===_.positionGeneration&&(QA(V,g),YA(g,!0),TA(A),!0)}async function HA(A){const e=_.positionGeneration;if(_.segmentIndex===_.recording.segments.length-1&&void 0===_.segment.events[_.nextEventIndex]){if(!await KA(0,e,!0))return!1}else if(null!==_.effectiveStartAt&&!await KA(_.effectiveStartAt,e))return!1;if(e!==_.positionGeneration)return!1;if(lA(),mA(),_.audioElement)try{return await _.audioElement.play(),IA(S,{reason:A})}catch(A){throw IA(J),A}return BA(S,{reason:A})}function OA(A){return _.audioElement&&_.audioElement.pause(),kA(),void 0!==A&&(_.pauseElapsedTime=A),e("pause"),!0}function xA(){clearTimeout(_.waitingTimeout),_.waitingTimeout=setTimeout((()=>{e("loading")}),1e3)}function ZA(){clearTimeout(_.waitingTimeout),_.waitingTimeout=null}function WA(){clearTimeout(_.loadingTimeout),_.loadingTimeout=null}function $A(){WA(),ZA(),yA()}async function jA(){yA(),_.playCount++;const A=++_.positionGeneration;try{const e=await EA(0,A,(()=>{gA(H,{time:_.duration})}));if(A!==_.positionGeneration)return;QA(0,e),YA(e,!0),_.pauseElapsedTime=0,_.startTime=j(),lA(),_.audioElement&&_.audioSeekable&&(_.audioElement.currentTime=0),z===h||z===w?await IA(O):(_.pauseElapsedTime=null,fA())}catch{}}function zA(){yA(),_.playCount++,_.pauseElapsedTime=_.duration,_.audioElement&&_.audioElement.pause(),cA([_.segmentIndex-1,_.segmentIndex]),e("ended")}function XA(){return _.positionGeneration++,_.segmentCache.clear(),$A(),async function(){clearTimeout(_.waitingTimeout),_.audioElement&&(_.audioElement.removeEventListener("playing",vA),_.audioElement.removeEventListener("waiting",NA),_.audioElement.pause(),_.audioElement.src="",_.audioElement.load(),_.audioElement=void 0),_.audioCtx&&(await _.audioCtx.close(),_.audioCtx=void 0)}()}return{init:function(){return oA(m)},stop:function(){return oA(v)},getDuration:function(){return void 0===_.duration?void 0:_.duration/1e3},getCurrentTime:function(){return MA()/1e3},play:function(){return oA(q)},pause:function(){return oA(M)},seek:LA,step:function(A){return oA(N,{n:A})},mute:function(){if(_.audioElement)return _.audioElement.muted=!0,e("muted",!0),!0},unmute:function(){if(_.audioElement)return _.audioElement.muted=!1,e("muted",!1),!0}}}],["websocket",function({url:A,bufferTime:e,reconnectDelay:t=z,minFrameTime:V},{dispatch:g,logger:n},{audioUrl:r}){let i,o;n=new d(n,"websocket: ");let I,B,s,C=new w,Q=0,a=!1,E=!1,c=!1,l=!1;function u(){let e;i=new WebSocket(A,["v1.alis","v2.asciicast","v3.asciicast","raw"]),i.binaryType="arraybuffer",i.onopen=()=>{e=i.protocol||"raw",n.info("opened"),n.info(`activating ${e} protocol handler`),"v1.alis"===e?i.onmessage=h(O(n)):"v2.asciicast"===e?i.onmessage=h(function(){let A=function(t){const V=JSON.parse(t);if(2!==V.version)throw new Error("not an asciicast v2 stream");return A=e,{time:0,term:{size:{cols:V.width,rows:V.height}}}};function e(A){const e=JSON.parse(A),t=1e3*e[0];if("r"===e[1]){const[A,V]=e[2].split("x");return[t,"r",{cols:parseInt(A,10),rows:parseInt(V,10)}]}return[t,e[1],e[2]]}return function(e){return A(e)}}()):"v3.asciicast"===e?i.onmessage=h(function(){let A=function(e){const V=JSON.parse(e);if(3!==V.version)throw new Error("not an asciicast v3 stream");A=t;const g={size:{cols:V.term.cols,rows:V.term.rows}};if(V.term.theme){const A="string"==typeof V.term.theme.palette?V.term.theme.palette.split(":"):void 0,e=q({foreground:V.term.theme.fg,background:V.term.theme.bg,palette:A});e&&(g.theme=e)}return{time:0,term:g}},e=0;function t(A){const t=JSON.parse(A),[V,g,n]=t;if(e+=1e3*V,"r"===g){const[A,t]=n.split("x");return[e,"r",{cols:parseInt(A,10),rows:parseInt(t,10)}]}return[e,g,n]}return function(e){return A(e)}}()):"raw"===e&&(i.onmessage=h(j())),I=setTimeout((()=>{Q=0}),1e3)},i.onclose=A=>{if(clearTimeout(B),p(),a)return;let V=!1,r="Stream ended";if("v1.alis"===e?(l||A.code>=4e3&&A.code<=4100)&&(V=!0,r=A.reason||r):(c||1e3===A.code||1005===A.code)&&(V=!0),V)n.info("closed"),g("ended",{message:r});else if(1002===A.code)n.debug(`close reason: ${A.reason}`),g("ended",{message:"Err: Player not compatible with the server"});else{clearTimeout(I);const A=t(Q++);n.info(`unexpected close, reconnecting in ${A}...`),g("loading"),setTimeout(u,A)}},E=!1}function h(A){return B=setTimeout(y,5e3),function(e){try{const t=A(e.data);if(o)if(Array.isArray(t))o.pushEvent(t),"x"===t[1]&&(c=!0);else if("string"==typeof t)o.pushText(t);else if("object"!=typeof t||Array.isArray(t)){if(!1===t)y(),l=!0;else if(void 0!==t)throw new Error(`unexpected value from protocol handler: ${t}`)}else D(t);else if("object"!=typeof t||Array.isArray(t)){if(void 0!==t)throw clearTimeout(B),new Error(`unexpected value from protocol handler: ${t}`);clearTimeout(B),B=setTimeout(y,1e3)}else D(t),clearTimeout(B)}catch(A){throw i.close(),A}}}function D({time:A,term:t}){const{size:r,init:i,theme:I}=t,{cols:B,rows:s}=r;n.info(`stream reset (${B}x${s} @${A})`),p(),o=T(e,g,(A=>C.setTime(A)),A,V,n),g("reset",{size:{cols:B,rows:s},init:i,theme:I??null}),C=new f,E=!0,c=!1,l=!1,"number"==typeof A&&C.setTime(A),g("playing")}function y(){p(),E?(n.info("stream ended"),g("offline",{message:"Stream ended"})):(n.info("stream offline"),g("offline",{message:"Stream offline"})),C=new w}function p(){o&&o.stop(),o=null}return{init:()=>{g("metadata",{hasAudio:!!r})},play:()=>(i||(g("play"),u(),r&&(s=new Audio,s.preload="auto",s.crossOrigin="anonymous",s.src=r,s.play())),!0),stop:()=>{a=!0,p(),void 0!==i&&i.close(),s&&s.pause()},mute:function(){if(s)return s.muted=!0,!0},unmute:function(){if(s)return s.muted=!1,!0},getCurrentTime:()=>{const A=C.getTime();return"number"==typeof A?A/1e3:A}}}]]),eA=new Map([["asciicast",G],["typescript",async function(A,{encoding:e}){const t=new TextDecoder(e);let V,g,n=(await A[0].text()).split("\n").filter((A=>A.length>0)).map((A=>A.split(" ")));n[0].length<3&&(n=n.map((A=>["O",A[0],A[1]])));const r=await A[1].arrayBuffer(),i=new Uint8Array(r),o=i.findIndex((A=>10==A))+1,I=t.decode(i.subarray(0,o)).match(/COLUMNS="(\d+)" LINES="(\d+)"/);null!==I&&(V=parseInt(I[1],10),g=parseInt(I[2],10));const B={array:i,cursor:o};let s=B;if(void 0!==A[2]){const e=await A[2].arrayBuffer();s={array:new Uint8Array(e),cursor:o}}const C=[];let Q=0;for(const A of n)if(Q+=1e3*parseFloat(A[1]),"O"===A[0]){const e=parseInt(A[2],10),V=B.array.subarray(B.cursor,B.cursor+e),g=t.decode(V);C.push([Q,"o",g]),B.cursor+=e}else if("I"===A[0]){const e=parseInt(A[2],10),V=s.array.subarray(s.cursor,s.cursor+e),g=t.decode(V);C.push([Q,"i",g]),s.cursor+=e}else if("S"===A[0]&&"SIGWINCH"===A[2]){const e=parseInt(A[4].slice(5),10),t=parseInt(A[3].slice(5),10);C.push([Q,"r",`${e}x${t}`])}else"H"===A[0]&&"COLUMNS"===A[2]?V=parseInt(A[3],10):"H"===A[0]&&"LINES"===A[2]&&(g=parseInt(A[3],10));return V=V??80,g=g??24,{cols:V,rows:g,events:C}}],["ttyrec",async function(A,{encoding:e}){const t=new TextDecoder(e),V=await A.arrayBuffer(),g=new Uint8Array(V),n=X(g),r=n.time,i=t.decode(n.data).match(/\x1b\[8;(\d+);(\d+)t/),o=[];let I=80,B=24;null!==i&&(I=parseInt(i[2],10),B=parseInt(i[1],10));let s=0,C=X(g);for(;void 0!==C;){const A=1e3*(C.time-r),e=t.decode(C.data);o.push([A,"o",e]),s+=C.len,C=X(g.subarray(s))}return{cols:I,rows:B,events:o}}]]);const tA=Symbol("solid-track"),VA={equals:(A,e)=>A===e};let gA=RA;const nA=1,rA=2,iA={owned:null,cleanups:null,context:null,owner:null};var oA=null;let IA=null,BA=null,sA=null,CA=null,QA=0;function aA(A,e){const t=BA,V=oA,g=0===A.length,n=void 0===e?V:e,r=g?iA:{owned:null,cleanups:null,context:n?n.context:null,owner:n},i=g?A:()=>A((()=>fA((()=>GA(r)))));oA=r,BA=null;try{return MA(i,!0)}finally{BA=t,oA=V}}function EA(A,e){const t={value:A,observers:null,observerSlots:null,comparator:(e=e?Object.assign({},VA,e):VA).equals||void 0};return[kA.bind(t),A=>("function"==typeof A&&(A=A(t.value)),mA(t,A))]}function cA(A,e,t){qA(LA(A,e,!1,nA))}function lA(A,e,t){gA=NA;const V=LA(A,e,!1,nA);V.user=!0,CA?CA.push(V):qA(V)}function uA(A,e,t){t=t?Object.assign({},VA,t):VA;const V=LA(A,e,!0,0);return V.observers=null,V.observerSlots=null,V.comparator=t.equals||void 0,qA(V),kA.bind(V)}function dA(A){return MA(A,!1)}function fA(A){if(null===BA)return A();const e=BA;BA=null;try{return A()}finally{BA=e}}function wA(A){lA((()=>fA(A)))}function hA(A){return null===oA||(null===oA.cleanups?oA.cleanups=[A]:oA.cleanups.push(A)),A}function DA(A){const e=BA,t=oA;return Promise.resolve().then((()=>{BA=e,oA=t,MA(A,!1),BA=oA=null}))}const[yA]=EA(!1);function pA(A){const e=uA(A),t=uA((()=>SA(e())));return t.toArray=()=>{const A=t();return Array.isArray(A)?A:null!=A?[A]:[]},t}function kA(){if(this.sources&&this.state)if(this.state===nA)qA(this);else{const A=sA;sA=null,MA((()=>vA(this)),!1),sA=A}if(BA){const A=this.observers?this.observers.length:0;BA.sources?(BA.sources.push(this),BA.sourceSlots.push(A)):(BA.sources=[this],BA.sourceSlots=[A]),this.observers?(this.observers.push(BA),this.observerSlots.push(BA.sources.length-1)):(this.observers=[BA],this.observerSlots=[BA.sources.length-1])}return this.value}function mA(A,e,t){let V=A.value;return A.comparator&&A.comparator(V,e)||(A.value=e,A.observers&&A.observers.length&&MA((()=>{for(let e=0;e<A.observers.length;e+=1){const t=A.observers[e],V=IA&&IA.running;V&&IA.disposed.has(t),(V?t.tState:t.state)||(t.pure?sA.push(t):CA.push(t),t.observers&&bA(t)),V||(t.state=nA)}if(sA.length>1e6)throw sA=[],new Error}),!1)),e}function qA(A){if(!A.fn)return;GA(A);const e=QA;!function(A,e,t){let V;const g=oA,n=BA;BA=oA=A;try{V=A.fn(e)}catch(e){return A.pure&&(A.state=nA,A.owned&&A.owned.forEach(GA),A.owned=null),A.updatedAt=t+1,UA(e)}finally{BA=n,oA=g}(!A.updatedAt||A.updatedAt<=t)&&(null!=A.updatedAt&&"observers"in A?mA(A,V):A.value=V,A.updatedAt=t)}(A,A.value,e)}function LA(A,e,t,V=nA,g){const n={fn:A,state:V,updatedAt:null,owned:null,sources:null,sourceSlots:null,cleanups:null,value:e,owner:oA,context:oA?oA.context:null,pure:t};return null===oA||oA!==iA&&(oA.owned?oA.owned.push(n):oA.owned=[n]),n}function FA(A){if(0===A.state)return;if(A.state===rA)return vA(A);if(A.suspense&&fA(A.suspense.inFallback))return A.suspense.effects.push(A);const e=[A];for(;(A=A.owner)&&(!A.updatedAt||A.updatedAt<QA);)A.state&&e.push(A);for(let t=e.length-1;t>=0;t--)if((A=e[t]).state===nA)qA(A);else if(A.state===rA){const t=sA;sA=null,MA((()=>vA(A,e[0])),!1),sA=t}}function MA(A,e){if(sA)return A();let t=!1;e||(sA=[]),CA?t=!0:CA=[],QA++;try{const e=A();return function(A){sA&&(RA(sA),sA=null);if(A)return;const e=CA;CA=null,e.length&&MA((()=>gA(e)),!1)}(t),e}catch(A){t||(CA=null),sA=null,UA(A)}}function RA(A){for(let e=0;e<A.length;e++)FA(A[e])}function NA(A){let e,t=0;for(e=0;e<A.length;e++){const V=A[e];V.user?A[t++]=V:FA(V)}for(e=0;e<t;e++)FA(A[e])}function vA(A,e){A.state=0;for(let t=0;t<A.sources.length;t+=1){const V=A.sources[t];if(V.sources){const A=V.state;A===nA?V!==e&&(!V.updatedAt||V.updatedAt<QA)&&FA(V):A===rA&&vA(V,e)}}}function bA(A){for(let e=0;e<A.observers.length;e+=1){const t=A.observers[e];t.state||(t.state=rA,t.pure?sA.push(t):CA.push(t),t.observers&&bA(t))}}function GA(A){let e;if(A.sources)for(;A.sources.length;){const e=A.sources.pop(),t=A.sourceSlots.pop(),V=e.observers;if(V&&V.length){const A=V.pop(),g=e.observerSlots.pop();t<V.length&&(A.sourceSlots[g]=t,V[t]=A,e.observerSlots[t]=g)}}if(A.tOwned){for(e=A.tOwned.length-1;e>=0;e--)GA(A.tOwned[e]);delete A.tOwned}if(A.owned){for(e=A.owned.length-1;e>=0;e--)GA(A.owned[e]);A.owned=null}if(A.cleanups){for(e=A.cleanups.length-1;e>=0;e--)A.cleanups[e]();A.cleanups=null}A.state=0}function UA(A,e=oA){const t=function(A){return A instanceof Error?A:new Error("string"==typeof A?A:"Unknown error",{cause:A})}(A);throw t}function SA(A){if("function"==typeof A&&!A.length)return SA(A());if(Array.isArray(A)){const e=[];for(let t=0;t<A.length;t++){const V=SA(A[t]);Array.isArray(V)?e.push.apply(e,V):e.push(V)}return e}return A}const JA=Symbol("fallback");function YA(A){for(let e=0;e<A.length;e++)A[e]()}function TA(A,e){return fA((()=>A(e||{})))}const KA=A=>`Stale read from <${A}>.`;function HA(A){const e="fallback"in A&&{fallback:()=>A.fallback};return uA(function(A,e,t={}){let V=[],g=[],n=[],r=0,i=e.length>1?[]:null;return hA((()=>YA(n))),()=>{let o,I,B=A()||[],s=B.length;return B[tA],fA((()=>{let A,e,Q,a,E,c,l,u,d;if(0===s)0!==r&&(YA(n),n=[],V=[],g=[],r=0,i&&(i=[])),t.fallback&&(V=[JA],g[0]=aA((A=>(n[0]=A,t.fallback()))),r=1);else if(0===r){for(g=new Array(s),I=0;I<s;I++)V[I]=B[I],g[I]=aA(C);r=s}else{for(Q=new Array(s),a=new Array(s),i&&(E=new Array(s)),c=0,l=Math.min(r,s);c<l&&V[c]===B[c];c++);for(l=r-1,u=s-1;l>=c&&u>=c&&V[l]===B[u];l--,u--)Q[u]=g[l],a[u]=n[l],i&&(E[u]=i[l]);for(A=new Map,e=new Array(u+1),I=u;I>=c;I--)d=B[I],o=A.get(d),e[I]=void 0===o?-1:o,A.set(d,I);for(o=c;o<=l;o++)d=V[o],I=A.get(d),void 0!==I&&-1!==I?(Q[I]=g[o],a[I]=n[o],i&&(E[I]=i[o]),I=e[I],A.set(d,I)):n[o]();for(I=c;I<s;I++)I in Q?(g[I]=Q[I],n[I]=a[I],i&&(i[I]=E[I],i[I](I))):g[I]=aA(C);g=g.slice(0,r=s),V=B.slice(0)}return g}));function C(A){if(n[I]=A,i){const[A,t]=EA(I);return i[I]=t,e(B[I],A)}return e(B[I])}}}((()=>A.each),A.children,e||void 0))}function OA(A){const e=A.keyed,t=uA((()=>A.when),void 0,void 0),V=e?t:uA(t,void 0,{equals:(A,e)=>!A==!e});return uA((()=>{const g=V();if(g){const n=A.children;return"function"==typeof n&&n.length>0?fA((()=>n(e?g:()=>{if(!fA(V))throw KA("Show");return t()}))):n}return A.fallback}),void 0,void 0)}function xA(A){const e=pA((()=>A.children)),t=uA((()=>{const A=e(),t=Array.isArray(A)?A:[A];let V=()=>{};for(let A=0;A<t.length;A++){const e=A,g=t[A],n=V,r=uA((()=>n()?void 0:g.when),void 0,void 0),i=g.keyed?r:uA(r,void 0,{equals:(A,e)=>!A==!e});V=()=>n()||(i()?[e,r,g]:void 0)}return V}));return uA((()=>{const e=t()();if(!e)return A.fallback;const[V,g,n]=e,r=n.children;return"function"==typeof r&&r.length>0?fA((()=>r(n.keyed?g():()=>{if(fA(t)()?.[0]!==V)throw KA("Match");return g()}))):r}),void 0,void 0)}function ZA(A){return A}const WA="_$DX_DELEGATE";function $A(A,e,t,V){let g;const n=()=>{const e=document.createElement("template");return e.innerHTML=A,e.content.firstChild},r=e?()=>fA((()=>document.importNode(g||(g=n()),!0))):()=>(g||(g=n())).cloneNode(!0);return r.cloneNode=r,r}function jA(A,e=window.document){const t=e[WA]||(e[WA]=new Set);for(let V=0,g=A.length;V<g;V++){const g=A[V];t.has(g)||(t.add(g),e.addEventListener(g,te))}}function zA(A,e,t){null==t?A.removeAttribute(e):A.setAttribute(e,t)}function XA(A,e){null==e?A.removeAttribute("class"):A.className=e}function PA(A,e,t,V){Array.isArray(t)?(A[`$$${e}`]=t[0],A[`$$${e}Data`]=t[1]):A[`$$${e}`]=t}function _A(A,e,t){if(!e)return t?zA(A,"style"):e;const V=A.style;if("string"==typeof e)return V.cssText=e;let g,n;for(n in"string"==typeof t&&(V.cssText=t=void 0),t||(t={}),e||(e={}),t)null==e[n]&&V.removeProperty(n),delete t[n];for(n in e)g=e[n],g!==t[n]&&(V.setProperty(n,g),t[n]=g);return t}function Ae(A,e,t){return fA((()=>A(e,t)))}function ee(A,e,t,V){if(void 0===t||V||(V=[]),"function"!=typeof e)return Ve(A,e,V,t);cA((V=>Ve(A,e(),V,t)),V)}function te(A){let e=A.target;const t=`$$${A.type}`,V=A.target,g=A.currentTarget,n=e=>Object.defineProperty(A,"target",{configurable:!0,value:e}),r=()=>{const V=e[t];if(V&&!e.disabled){const g=e[`${t}Data`];if(void 0!==g?V.call(e,g,A):V.call(e,A),A.cancelBubble)return}return e.host&&"string"!=typeof e.host&&!e.host._$host&&e.contains(A.target)&&n(e.host),!0},i=()=>{for(;r()&&(e=e._$host||e.parentNode||e.host););};if(Object.defineProperty(A,"currentTarget",{configurable:!0,get:()=>e||document}),A.composedPath){const t=A.composedPath();n(t[0]);for(let A=0;A<t.length-2&&(e=t[A],r());A++){if(e._$host){e=e._$host,i();break}if(e.parentNode===g)break}}else i();n(V)}function Ve(A,e,t,V,g){for(;"function"==typeof t;)t=t();if(e===t)return t;const n=typeof e,r=void 0!==V;if(A=r&&t[0]&&t[0].parentNode||A,"string"===n||"number"===n){if("number"===n&&(e=e.toString())===t)return t;if(r){let g=t[0];g&&3===g.nodeType?g.data!==e&&(g.data=e):g=document.createTextNode(e),t=re(A,t,V,g)}else t=""!==t&&"string"==typeof t?A.firstChild.data=e:A.textContent=e}else if(null==e||"boolean"===n)t=re(A,t,V);else{if("function"===n)return cA((()=>{let g=e();for(;"function"==typeof g;)g=g();t=Ve(A,g,t,V)})),()=>t;if(Array.isArray(e)){const n=[],i=t&&Array.isArray(t);if(ge(n,e,t,g))return cA((()=>t=Ve(A,n,t,V,!0))),()=>t;if(0===n.length){if(t=re(A,t,V),r)return t}else i?0===t.length?ne(A,n,V):function(A,e,t){let V=t.length,g=e.length,n=V,r=0,i=0,o=e[g-1].nextSibling,I=null;for(;r<g||i<n;)if(e[r]!==t[i]){for(;e[g-1]===t[n-1];)g--,n--;if(g===r){const e=n<V?i?t[i-1].nextSibling:t[n-i]:o;for(;i<n;)A.insertBefore(t[i++],e)}else if(n===i)for(;r<g;)I&&I.has(e[r])||e[r].remove(),r++;else if(e[r]===t[n-1]&&t[i]===e[g-1]){const V=e[--g].nextSibling;A.insertBefore(t[i++],e[r++].nextSibling),A.insertBefore(t[--n],V),e[g]=t[n]}else{if(!I){I=new Map;let A=i;for(;A<n;)I.set(t[A],A++)}const V=I.get(e[r]);if(null!=V)if(i<V&&V<n){let o,B=r,s=1;for(;++B<g&&B<n&&null!=(o=I.get(e[B]))&&o===V+s;)s++;if(s>V-i){const g=e[r];for(;i<V;)A.insertBefore(t[i++],g)}else A.replaceChild(t[i++],e[r++])}else r++;else e[r++].remove()}}else r++,i++}(A,t,n):(t&&re(A),ne(A,n));t=n}else if(e.nodeType){if(Array.isArray(t)){if(r)return t=re(A,t,V,e);re(A,t,null,e)}else null!=t&&""!==t&&A.firstChild?A.replaceChild(e,A.firstChild):A.appendChild(e);t=e}}return t}function ge(A,e,t,V){let g=!1;for(let n=0,r=e.length;n<r;n++){let r,i=e[n],o=t&&t[A.length];if(null==i||!0===i||!1===i);else if("object"==(r=typeof i)&&i.nodeType)A.push(i);else if(Array.isArray(i))g=ge(A,i,o)||g;else if("function"===r)if(V){for(;"function"==typeof i;)i=i();g=ge(A,Array.isArray(i)?i:[i],Array.isArray(o)?o:[o])||g}else A.push(i),g=!0;else{const e=String(i);o&&3===o.nodeType&&o.data===e?A.push(o):A.push(document.createTextNode(e))}}return g}function ne(A,e,t=null){for(let V=0,g=e.length;V<g;V++)A.insertBefore(e[V],t)}function re(A,e,t,V){if(void 0===t)return A.textContent="";const g=V||document.createTextNode("");if(e.length){let V=!1;for(let n=e.length-1;n>=0;n--){const r=e[n];if(g!==r){const e=r.parentNode===A;V||n?e&&r.remove():e?A.replaceChild(g,r):A.insertBefore(g,t)}else V=!0}}else A.insertBefore(g,t);return[g]}const ie=()=>{},oe=(A,e)=>e();function Ie(A,e){const t=fA(A),V=t?[t]:[],{onEnter:g=oe,onExit:n=oe}=e,[r,i]=EA(e.appear?[]:V),[o]=[yA,DA];let I,B=!1;function s(A,e){if(!A)return e&&e();B=!0,n(A,(()=>{dA((()=>{B=!1,i((e=>e.filter((e=>e!==A)))),e&&e()}))}))}function C(A){const e=I;if(!e)return A&&A();I=void 0,i((A=>[e,...A])),g(e,A??ie)}const Q="out-in"===e.mode?A=>B||s(A,C):"in-out"===e.mode?A=>C((()=>s(A))):A=>{s(A),C()};var a,E;return a=e=>{const t=A();return fA(o)?(o(),e):(t!==e&&(I=t,dA((()=>fA((()=>Q(e)))))),t)},E=e.appear?void 0:t,qA(LA(a,E,!0,nA)),r}const Be=A=>A instanceof Element;function se(A,e){if(e(A))return A;if("function"==typeof A&&!A.length)return se(A(),e);if(Array.isArray(A))for(const t of A){const A=se(t,e);if(A)return A}return null}function Ce(A,e=Be,t=Be){const V=uA(A);return uA((()=>se(V(),e)))}function Qe(A){requestAnimationFrame((()=>requestAnimationFrame(A)))}var ae={inout:"in-out",outin:"out-in"},Ee=A=>{const e=function(A){return uA((()=>{const e=A.name||"s";return{enterActive:(A.enterActiveClass||e+"-enter-active").split(" "),enter:(A.enterClass||e+"-enter").split(" "),enterTo:(A.enterToClass||e+"-enter-to").split(" "),exitActive:(A.exitActiveClass||e+"-exit-active").split(" "),exit:(A.exitClass||e+"-exit").split(" "),exitTo:(A.exitToClass||e+"-exit-to").split(" "),move:(A.moveClass||e+"-move").split(" ")}}))}(A);return Ie(Ce((()=>A.children)),{mode:ae[A.mode],appear:A.appear,onEnter(t,V){!function(A,e,t,V){const{onBeforeEnter:g,onEnter:n,onAfterEnter:r}=e;function i(e){e&&e.target!==t||(V?.(),t.removeEventListener("transitionend",i),t.removeEventListener("animationend",i),t.classList.remove(...A.enterActive),t.classList.remove(...A.enterTo),r?.(t))}g?.(t),t.classList.add(...A.enter),t.classList.add(...A.enterActive),queueMicrotask((()=>{if(!t.parentNode)return V?.();n?.(t,(()=>i()))})),Qe((()=>{t.classList.remove(...A.enter),t.classList.add(...A.enterTo),(!n||n.length<2)&&(t.addEventListener("transitionend",i),t.addEventListener("animationend",i))}))}(e(),A,t,V)},onExit(t,V){!function(A,e,t,V){const{onBeforeExit:g,onExit:n,onAfterExit:r}=e;if(!t.parentNode)return V?.();function i(e){e&&e.target!==t||(V?.(),t.removeEventListener("transitionend",i),t.removeEventListener("animationend",i),t.classList.remove(...A.exitActive),t.classList.remove(...A.exitTo),r?.(t))}g?.(t),t.classList.add(...A.exit),t.classList.add(...A.exitActive),n?.(t,(()=>i())),Qe((()=>{t.classList.remove(...A.exit),t.classList.add(...A.exitTo),(!n||n.length<2)&&(t.addEventListener("transitionend",i),t.addEventListener("animationend",i))}))}(e(),A,t,V)}})};let ce;function le(A){qe===me.length&&me.push(me.length+1);const e=qe;return qe=me[e],me[e]=A,e}function ue(A){const e=typeof A;if("number"==e||"boolean"==e||null==A)return`${A}`;if("string"==e)return`"${A}"`;if("symbol"==e){const e=A.description;return null==e?"Symbol":`Symbol(${e})`}if("function"==e){const e=A.name;return"string"==typeof e&&e.length>0?`Function(${e})`:"Function"}if(Array.isArray(A)){const e=A.length;let t="[";e>0&&(t+=ue(A[0]));for(let V=1;V<e;V++)t+=", "+ue(A[V]);return t+="]",t}const t=/\[object ([^\]]+)\]/.exec(toString.call(A));let V;if(!(t&&t.length>1))return toString.call(A);if(V=t[1],"Object"==V)try{return"Object("+JSON.stringify(A)+")"}catch(A){return"Object"}return A instanceof Error?`${A.name}: ${A.message}\n${A.stack}`:V}function de(A,e){return A>>>=0,function(){null!==De&&0!==De.byteLength||(De=new Uint32Array(ce.memory.buffer));return De}().subarray(A/4,A/4+e)}let fe=null;function we(){return(null===fe||!0===fe.buffer.detached||void 0===fe.buffer.detached&&fe.buffer!==ce.memory.buffer)&&(fe=new DataView(ce.memory.buffer)),fe}function he(A,e){return function(A,e){Ne+=e,Ne>=Re&&(Me=new TextDecoder("utf-8",{ignoreBOM:!0,fatal:!0}),Me.decode(),Ne=e);return Me.decode(pe().subarray(A,A+e))}(A>>>=0,e)}let De=null;let ye=null;function pe(){return null!==ye&&0!==ye.byteLength||(ye=new Uint8Array(ce.memory.buffer)),ye}function ke(A){return me[A]}let me=new Array(128).fill(void 0);me.push(void 0,null,!0,!1);let qe=me.length;function Le(A,e,t){if(void 0===t){const t=ve.encode(A),V=e(t.length,1)>>>0;return pe().subarray(V,V+t.length).set(t),be=t.length,V}let V=A.length,g=e(V,1)>>>0;const n=pe();let r=0;for(;r<V;r++){const e=A.charCodeAt(r);if(e>127)break;n[g+r]=e}if(r!==V){0!==r&&(A=A.slice(r)),g=t(g,V,V=r+3*A.length,1)>>>0;const e=pe().subarray(g+r,g+V);r+=ve.encodeInto(A,e).written,g=t(g,V,r,1)>>>0}return be=r,g}function Fe(A){const e=ke(A);return function(A){A<132||(me[A]=qe,qe=A)}(A),e}let Me=new TextDecoder("utf-8",{ignoreBOM:!0,fatal:!0});Me.decode();const Re=2146435072;let Ne=0;const ve=new TextEncoder;"encodeInto"in ve||(ve.encodeInto=function(A,e){const t=ve.encode(A);return e.set(t),{read:A.length,written:t.length}});let be=0;const Ge="undefined"==typeof FinalizationRegistry?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry((A=>ce.__wbg_vt_free(A>>>0,1)));let Ue=class A{static __wrap(e){e>>>=0;const t=Object.create(A.prototype);return t.__wbg_ptr=e,Ge.register(t,t.__wbg_ptr,t),t}__destroy_into_raw(){const A=this.__wbg_ptr;return this.__wbg_ptr=0,Ge.unregister(this),A}free(){const A=this.__destroy_into_raw();ce.__wbg_vt_free(A,0)}feed(A){const e=Le(A,ce.__wbindgen_export,ce.__wbindgen_export2),t=be;return Fe(ce.vt_feed(this.__wbg_ptr,e,t))}resize(A,e){return Fe(ce.vt_resize(this.__wbg_ptr,A,e))}getSize(){try{const V=ce.__wbindgen_add_to_stack_pointer(-16);ce.vt_getSize(V,this.__wbg_ptr);var A=we().getInt32(V+0,!0),e=we().getInt32(V+4,!0),t=de(A,e).slice();return ce.__wbindgen_export3(A,4*e,4),t}finally{ce.__wbindgen_add_to_stack_pointer(16)}}getLine(A,e){return Fe(ce.vt_getLine(this.__wbg_ptr,A,e))}getCursor(){return Fe(ce.vt_getCursor(this.__wbg_ptr))}};Symbol.dispose&&(Ue.prototype[Symbol.dispose]=Ue.prototype.free);const Se=new Set(["basic","cors","default"]);function Je(){const A={wbg:{}};return A.wbg.__wbg___wbindgen_debug_string_adfb662ae34724b6=function(A,e){const t=Le(ue(ke(e)),ce.__wbindgen_export,ce.__wbindgen_export2),V=be;we().setInt32(A+4,V,!0),we().setInt32(A+0,t,!0)},A.wbg.__wbg___wbindgen_throw_dd24417ed36fc46e=function(A,e){throw new Error(he(A,e))},A.wbg.__wbg_new_13317ed16189158e=function(){return le(new Array)},A.wbg.__wbg_new_4ceb6a766bf78b04=function(){return le(new Object)},A.wbg.__wbg_set_3f1d0b984ed272ed=function(A,e,t){ke(A)[Fe(e)]=Fe(t)},A.wbg.__wbg_set_8b6a9a61e98a8881=function(A,e,t){ke(A)[e>>>0]=Fe(t)},A.wbg.__wbindgen_cast_2241b6af4c4b2941=function(A,e){return le(he(A,e))},A.wbg.__wbindgen_cast_4625c577ab2ec9ee=function(A){return le(BigInt.asUintN(64,A))},A.wbg.__wbindgen_cast_d6cd19b81560fd6e=function(A){return le(A)},A.wbg.__wbindgen_object_clone_ref=function(A){return le(ke(A))},A.wbg.__wbindgen_object_drop_ref=function(A){Fe(A)},A}function Ye(A,e){return ce=A.exports,Te.__wbindgen_wasm_module=e,fe=null,De=null,ye=null,ce}async function Te(A){if(void 0!==ce)return ce;void 0!==A&&(Object.getPrototypeOf(A)===Object.prototype?({module_or_path:A}=A):console.warn("using deprecated parameters for the initialization function; pass a single object instead"));const e=Je();("string"==typeof A||"function"==typeof Request&&A instanceof Request||"function"==typeof URL&&A instanceof URL)&&(A=fetch(A));const{instance:t,module:V}=await async function(A,e){if("function"==typeof Response&&A instanceof Response){if("function"==typeof WebAssembly.instantiateStreaming)try{return await WebAssembly.instantiateStreaming(A,e)}catch(e){if(!A.ok||!Se.has(A.type)||"application/wasm"===A.headers.get("Content-Type"))throw e;console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n",e)}const t=await A.arrayBuffer();return await WebAssembly.instantiate(t,e)}{const t=await WebAssembly.instantiate(A,e);return t instanceof WebAssembly.Instance?{instance:t,module:A}:t}}(await A,e);return Ye(t,V)}var Ke=Object.freeze({__proto__:null,Vt:Ue,create:function(A,e,t,V){const g=ce.create(A,e,t,V);return Ue.__wrap(g)},default:Te,initSync:function(A){if(void 0!==ce)return ce;void 0!==A&&(Object.getPrototypeOf(A)===Object.prototype?({module:A}=A):console.warn("using deprecated parameters for `initSync()`; pass a single object instead"));const e=Je();return A instanceof WebAssembly.Module||(A=new WebAssembly.Module(A)),Ye(new WebAssembly.Instance(A,e),A)}});const He=[62,0,0,0,63,52,53,54,55,56,57,58,59,60,61,0,0,0,0,0,0,0,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,0,0,0,0,0,0,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51];function Oe(A){return He[A-43]}var xe=function(A){let e,t=A.endsWith("==")?2:A.endsWith("=")?1:0,V=A.length,g=new Uint8Array(V/4*3);for(let t=0,n=0;t<V;t+=4,n+=3)e=Oe(A.charCodeAt(t))<<18|Oe(A.charCodeAt(t+1))<<12|Oe(A.charCodeAt(t+2))<<6|Oe(A.charCodeAt(t+3)),g[n]=e>>16,g[n+1]=e>>8&255,g[n+2]=255&e;return g.subarray(0,g.length-t)}("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");const Ze=async function(A){return await Te({module_or_path:await A.module,memory:A.memory}),Ke}({module:xe}),We=Ze.then((A=>A.default())).then((A=>A.memory));class $e{static async build(A,e,t,V){return new $e(await Ze,await We,V,A,e,t)}constructor(A,e,t,V,g,n){this.wasm=A,this.memory=e,this.logger=t,this.cols=V,this.rows=g,this.boldIsBright=n,this.vt=A.create(V,g,100,n)}feed(A){return this.vt.feed(A)}reset(A,e,t=void 0){return this.logger.debug(`vt: reset (${A}x${e})`),this.vt=this.wasm.create(A,e,100,this.boldIsBright),this.cols=A,this.rows=e,void 0!==t&&""!==t&&this.vt.feed(t),Array.from({length:e},((A,e)=>e))}resize(A,e){if(A===this.cols&&e===this.rows)return;this.logger.debug(`vt: resize (${A}x${e})`);const t=this.vt.resize(A,e);return this.cols=A,this.rows=e,t}getLine(A,e){return this.vt.getLine(A,e)}getDataView([A,e],t){return new DataView(this.memory.buffer,A,e*t)}getUint32Array([A,e]){return new Uint32Array(this.memory.buffer,A,e)}getCursor(){const A=this.vt.getCursor();return A?{col:A[0],row:A[1],visible:!0}:{col:0,row:0,visible:!1}}}const je=$A('<div class="ap-term"><canvas></canvas><svg class="ap-term-symbols" xmlns="http://www.w3.org/2000/svg" preserveAspectRatio="none" width="100%" height="100%" aria-hidden="true"><defs></defs><g></g></svg><pre class="ap-term-text" aria-live="off" tabindex="0"></pre></div>',12),ze="http://www.w3.org/2000/svg",Xe=24;var Pe=A=>{const e=A.core,t=[],V=[],g=[],r=new Set,i=new Map,o=new Map,I=$e.build(A.cols,A.rows,A.boldIsBright,A.logger);let B;const[s,C]=EA({cols:A.cols,rows:A.rows},{equals:(A,e)=>A.cols===e.cols&&A.rows===e.rows}),[Q,a]=EA(_e(it,A.adaptivePalette)),E=()=>A.lineHeight??1.3333333333,[c,l]=EA(!0),u=uA((()=>"hidden"!==A.cursorMode&&("steady"===A.cursorMode||(c()||R)))),d=uA((()=>({width:`${s().cols}ch`,height:E()*s().rows+"em","font-size":100*(A.scale||1)+"%","--term-line-height":`${E()}em`,"--term-cols":s().cols,"--term-rows":s().rows})));let f,w,h,D,y,p,k,m,q,L,F={col:0,row:0,visible:!1},M={size:void 0,theme:void 0,rows:new Set},R=!1;function N({size:A,theme:e,init:t}){G({size:A,theme:e,changedRows:B.reset(A.cols,A.rows,t)})}function v(A){const e=B.resize(A.cols,A.rows);void 0!==e&&G({size:A,changedRows:e})}function b(A){let e;if(Array.isArray(A)){e=new Set;for(const t of A)for(const A of B.feed(t))e.add(A)}else e=B.feed(A);G({changedRows:e})}function G({size:e,theme:t,changedRows:V}){let g=!1;if(void 0!==V)for(const A of V)M.rows.add(A),R=!0,g=!0;if(void 0!==t&&A.preferEmbeddedTheme){M.theme=t;for(let A=0;A<s().rows;A++)M.rows.add(A)}const n=B.getCursor();if(n.visible==F.visible&&n.col==F.col&&n.row==F.row||(F.visible&&M.rows.add(F.row),n.visible&&M.rows.add(n.row),F=n,R=!0,g=!0),void 0!==e){M.size=e;for(const A of M.rows)A>=e.rows&&M.rows.delete(A)}g&&F.visible&&M.rows.add(F.row),S()}function U(){l((A=>(A||(R=!1),!A)))}function S(){void 0===m&&(m=requestAnimationFrame(J))}function J(){m=void 0;const{size:e,theme:t,rows:V}=M;dA((function(){void 0!==e&&(!function({cols:A,rows:e}){w.width=8*A,w.height=e*Xe,h.imageSmoothingEnabled=!1}(e),H(e.rows),O(e.rows),C(e)),void 0!==t&&(a(_e(null===t?L:t,A.adaptivePalette)),i.clear());const g=Q(),n=u();for(const A of V)Y(A,g,n)})),M.size=void 0,M.theme=void 0,M.rows.clear(),A.stats.renders+=1}function Y(A,e,t){const V=B.getLine(A,t);!function(A){h.clearRect(0,A*Xe,8*s().cols,Xe)}(A),function(A,e,t){const V=B.getDataView(e,8),g=A*Xe;let n=0;for(;n<V.byteLength;){const A=V.getUint16(n+0,!0),e=V.getUint16(n+2,!0),r=K(V,n+4,t);n+=8,h.fillStyle=r,h.fillRect(8*A,g,8*e,Xe)}}(A,V.bg,e),function(A,e,t){const V=B.getDataView(e,12),g=A*Xe;let n=0;for(;n<V.byteLength;){const A=V.getUint16(n+0,!0),e=V.getUint32(n+4,!0),r=K(V,n+8,t)||t.fg;n+=12,h.fillStyle=r,tt(h,e,8*A,g)}}(A,V.raster_symbols,e),function(A,e,t){const V=B.getDataView(e,16),n=document.createDocumentFragment(),r=k.children[A];let i=0;for(;i<V.byteLength;){const A=V.getUint16(i+0,!0),e=V.getUint32(i+4,!0),g=K(V,i+8,t),r=V.getUint8(i+12);i+=16;const o=W(e,A,g,!!(32&r));o&&n.appendChild(o)}(function(A){for(;A.firstChild;){const e=A.firstChild;A.removeChild(e),g.push(e)}})(r),r.replaceChildren(n)}(A,V.vector_symbols,e),function(A,e,t,V){const g=B.getDataView(e,12),n=B.getUint32Array(t),r=document.createDocumentFragment();let i=0;for(;i<g.byteLength;){const A=g.getUint16(i+0,!0),e=g.getUint16(i+2,!0),t=g.getUint16(i+4,!0),o=K(g,i+6,V),I=g.getUint8(i+10),B=String.fromCodePoint(...n.subarray(e,e+t));i+=12;const s=document.createElement("span"),C=s.style;C.setProperty("--offset",A),s.textContent=B,o&&(C.color=o);const Q=T(I);null!==Q&&(s.className=Q),r.appendChild(s)}D.children[A].replaceChildren(r)}(A,V.text,V.codepoints,e)}function T(A){let e=o.get(A);return void 0===e&&(e=function(A){let e="";1&A?e+="ap-bold ":2&A&&(e+="ap-faint ");4&A&&(e+="ap-italic ");8&A&&(e+="ap-underline ");16&A&&(e+="ap-strike ");32&A&&(e+="ap-blink ");return""===e?null:e}(A),o.set(A,e)),e}function K(A,e,t){const V=A.getUint8(e);if(0===V)return null;if(1===V)return t.fg;if(2===V)return t.bg;if(3===V)return t.palette[A.getUint8(e+1)];if(4===V){const t=A.getUint32(e,!0);let V=i.get(t);if(void 0===V){V="rgb("+A.getUint8(e+1)+","+A.getUint8(e+2)+","+A.getUint8(e+3)+")",i.set(t,V)}return V}throw new Error(`invalid color tag: ${V}`)}function H(A){let e=D.children.length;if(e<A){const t=document.createDocumentFragment();for(;e<A;){const A=x();A.style.setProperty("--row",e),t.appendChild(A),e+=1}D.appendChild(t)}for(;D.children.length>A;){const A=D.lastElementChild;D.removeChild(A),t.push(A)}}function O(A){let e=k.children.length;if(e<A){const t=document.createDocumentFragment();for(;e<A;){const A=Z();A.setAttribute("transform",`translate(0 ${e})`),t.appendChild(A),e+=1}k.appendChild(t)}for(;k.children.length>A;){const A=k.lastElementChild;k.removeChild(A),V.push(A)}}function x(){let A=t.pop();return void 0===A&&(A=document.createElement("span"),A.className="ap-line"),A}function Z(){let A=V.pop();return void 0===A&&(A=document.createElementNS(ze,"g"),A.setAttribute("class","ap-symbol-line")),A}function W(A,e,t,V){if(!function(A){const e=function(A){const e=`stroke="currentColor" stroke-width="${Vt}" stroke-linejoin="miter" stroke-linecap="square"`,t=`stroke="currentColor" stroke-width="${Vt}" stroke-linejoin="miter" stroke-linecap="butt"`,V=A=>`<path d="${A}" fill="none" ${e}/>`,g=1/3,n=2/3;switch(A){case 9698:return'<path d="M1,1 L1,0 L0,1 Z" fill="currentColor"/>'+V("M1,1 L1,0 L0,1 Z");case 9699:return'<path d="M0,1 L0,0 L1,1 Z" fill="currentColor"/>'+V("M0,1 L0,0 L1,1 Z");case 9700:return'<path d="M0,0 L1,0 L0,1 Z" fill="currentColor"/>'+V("M0,0 L1,0 L0,1 Z");case 9701:return'<path d="M1,0 L1,1 L0,0 Z" fill="currentColor"/>'+V("M1,0 L1,1 L0,0 Z");case 9871:{const A=.17,e=.15/2,t=.2/2,V=A=>.5+A*gt,g=.5-e,n=.5+e,r=1.02,i=V(-t-A),o=V(-t),I=V(t),B=V(t+A),s=(A,e,t,V)=>`M${A},${t} L${e},${t} L${e},${V} L${A},${V} Z`;return`<path d="${s(0,g,i,o)} ${s(n,r,i,o)} ${s(0,g,I,B)} ${s(n,r,I,B)}" fill="currentColor"/>`}case 129852:return`<path d="M0,${n} L0,1 L0.5,1 Z" fill="currentColor"/>`+V(`M0,${n} L0,1 L0.5,1 Z`);case 129853:return`<path d="M0,${n} L0,1 L1,1 Z" fill="currentColor"/>`+V(`M0,${n} L0,1 L1,1 Z`);case 129854:return`<path d="M0,${g} L0.5,1 L0,1 Z" fill="currentColor"/>`+V(`M0,${g} L0.5,1 L0,1 Z`);case 129855:return`<path d="M0,${g} L1,1 L0,1 Z" fill="currentColor"/>`+V(`M0,${g} L1,1 L0,1 Z`);case 129856:return'<path d="M0,0 L0.5,1 L0,1 Z" fill="currentColor"/>'+V("M0,0 L0.5,1 L0,1 Z");case 129857:return`<path d="M0,${g} L0,1 L1,1 L1,0 L0.5,0 Z" fill="currentColor"/>`+V(`M0,${g} L0,1 L1,1 L1,0 L0.5,0 Z`);case 129858:return`<path d="M0,${g} L0,1 L1,1 L1,0 Z" fill="currentColor"/>`+V(`M0,${g} L0,1 L1,1 L1,0 Z`);case 129859:return`<path d="M0,${n} L0,1 L1,1 L1,0 L0.5,0 Z" fill="currentColor"/>`+V(`M0,${n} L0,1 L1,1 L1,0 L0.5,0 Z`);case 129860:return`<path d="M0,${n} L0,1 L1,1 L1,0 Z" fill="currentColor"/>`+V(`M0,${n} L0,1 L1,1 L1,0 Z`);case 129861:return'<path d="M0.5,0 L1,0 L1,1 L0,1 Z" fill="currentColor"/>'+V("M0.5,0 L1,0 L1,1 L0,1 Z");case 129862:return`<path d="M0,${n} L0,1 L1,1 L1,${g} Z" fill="currentColor"/>`+V(`M0,${n} L0,1 L1,1 L1,${g} Z`);case 129863:return`<path d="M0.5,1 L1,1 L1,${n} Z" fill="currentColor"/>`+V(`M0.5,1 L1,1 L1,${n} Z`);case 129864:return`<path d="M0,1 L1,1 L1,${n} Z" fill="currentColor"/>`+V(`M0,1 L1,1 L1,${n} Z`);case 129865:return`<path d="M0.5,1 L1,1 L1,${g} Z" fill="currentColor"/>`+V(`M0.5,1 L1,1 L1,${g} Z`);case 129866:return`<path d="M0,1 L1,1 L1,${g} Z" fill="currentColor"/>`+V(`M0,1 L1,1 L1,${g} Z`);case 129867:return'<path d="M0.5,1 L1,0 L1,1 Z" fill="currentColor"/>'+V("M0.5,1 L1,0 L1,1 Z");case 129868:return`<path d="M0,0 L0.5,0 L1,${g} L1,1 L0,1 Z" fill="currentColor"/>`+V(`M0,0 L0.5,0 L1,${g} L1,1 L0,1 Z`);case 129869:return`<path d="M0,0 L0,1 L1,1 L1,${g} Z" fill="currentColor"/>`+V(`M0,0 L0,1 L1,1 L1,${g} Z`);case 129870:return`<path d="M0,0 L0.5,0 L1,${n} L1,1 L0,1 Z" fill="currentColor"/>`+V(`M0,0 L0.5,0 L1,${n} L1,1 L0,1 Z`);case 129871:return`<path d="M0,0 L1,${n} L1,1 L0,1 Z" fill="currentColor"/>`+V(`M0,0 L1,${n} L1,1 L0,1 Z`);case 129872:return'<path d="M0,0 L0.5,0 L1,1 L0,1 Z" fill="currentColor"/>'+V("M0,0 L0.5,0 L1,1 L0,1 Z");case 129873:return`<path d="M0,${g} L1,${n} L1,1 L0,1 Z" fill="currentColor"/>`+V(`M0,${g} L1,${n} L1,1 L0,1 Z`);case 129874:return`<path d="M0,${n} L0,0 L1,0 L1,1 L0.5,1 Z" fill="currentColor"/>`+V(`M0,${n} L0,0 L1,0 L1,1 L0.5,1 Z`);case 129875:return`<path d="M0,${n} L0,0 L1,0 L1,1 Z" fill="currentColor"/>`+V(`M0,${n} L0,0 L1,0 L1,1 Z`);case 129876:return`<path d="M0,${g} L0,0 L1,0 L1,1 L0.5,1 Z" fill="currentColor"/>`+V(`M0,${g} L0,0 L1,0 L1,1 L0.5,1 Z`);case 129877:return`<path d="M0,${g} L0,0 L1,0 L1,1 Z" fill="currentColor"/>`+V(`M0,${g} L0,0 L1,0 L1,1 Z`);case 129878:return'<path d="M0,0 L1,0 L1,1 L0.5,1 Z" fill="currentColor"/>'+V("M0,0 L1,0 L1,1 L0.5,1 Z");case 129879:return`<path d="M0,${g} L0.5,0 L0,0 Z" fill="currentColor"/>`+V(`M0,${g} L0.5,0 L0,0 Z`);case 129880:return`<path d="M0,0 L1,0 L0,${g} Z" fill="currentColor"/>`+V(`M0,0 L1,0 L0,${g} Z`);case 129881:return`<path d="M0,0 L0.5,0 L0,${n} Z" fill="currentColor"/>`+V(`M0,0 L0.5,0 L0,${n} Z`);case 129882:return`<path d="M0,0 L1,0 L0,${n} Z" fill="currentColor"/>`+V(`M0,0 L1,0 L0,${n} Z`);case 129883:return'<path d="M0,0 L0.5,0 L0,1 Z" fill="currentColor"/>'+V("M0,0 L0.5,0 L0,1 Z");case 129884:return`<path d="M0,0 L1,0 L1,${g} L0,${n} Z" fill="currentColor"/>`+V(`M0,0 L1,0 L1,${g} L0,${n} Z`);case 129885:return`<path d="M0,0 L1,0 L1,${n} L0.5,1 L0,1 Z" fill="currentColor"/>`+V(`M0,0 L1,0 L1,${n} L0.5,1 L0,1 Z`);case 129886:return`<path d="M0,0 L1,0 L1,${n} L0,1 Z" fill="currentColor"/>`+V(`M0,0 L1,0 L1,${n} L0,1 Z`);case 129887:return`<path d="M0,0 L1,0 L1,${g} L0.5,1 L0,1 Z" fill="currentColor"/>`+V(`M0,0 L1,0 L1,${g} L0.5,1 L0,1 Z`);case 129888:return`<path d="M0,0 L1,0 L1,${g} L0,1 Z" fill="currentColor"/>`+V(`M0,0 L1,0 L1,${g} L0,1 Z`);case 129889:return'<path d="M0,0 L1,0 L0.5,1 L0,1 Z" fill="currentColor"/>'+V("M0,0 L1,0 L0.5,1 L0,1 Z");case 129890:return`<path d="M0.5,0 L1,0 L1,${g} Z" fill="currentColor"/>`+V(`M0.5,0 L1,0 L1,${g} Z`);case 129891:return`<path d="M0,0 L1,0 L1,${g} Z" fill="currentColor"/>`+V(`M0,0 L1,0 L1,${g} Z`);case 129892:return`<path d="M0.5,0 L1,0 L1,${n} Z" fill="currentColor"/>`+V(`M0.5,0 L1,0 L1,${n} Z`);case 129893:return`<path d="M0,0 L1,0 L1,${n} Z" fill="currentColor"/>`+V(`M0,0 L1,0 L1,${n} Z`);case 129894:return'<path d="M0.5,0 L1,0 L1,1 Z" fill="currentColor"/>'+V("M0.5,0 L1,0 L1,1 Z");case 129895:return`<path d="M0,${g} L0,0 L1,0 L1,${n} Z" fill="currentColor"/>`+V(`M0,${g} L0,0 L1,0 L1,${n} Z`);case 129896:return`<path fill-rule="evenodd" d="M0,0 L1,0 L1,1 L0,1 Z M0,0 L0,1 L0.5,0.5 Z" fill="currentColor"/><path d="M0,0 L1,0 M0,1 L1,1 M1,0 L1,1" fill="none" ${e}/><path d="M0,0 L0.5,0.5 M0,1 L0.5,0.5" fill="none" ${t}/>`;case 129897:return`<path fill-rule="evenodd" d="M0,0 L1,0 L1,1 L0,1 Z M0,0 L1,0 L0.5,0.5 Z" fill="currentColor"/><path d="M0,0 L0,1 M1,0 L1,1 M0,1 L1,1" fill="none" ${e}/><path d="M0,0 L0.5,0.5 M1,0 L0.5,0.5" fill="none" ${t}/>`;case 129898:return`<path fill-rule="evenodd" d="M0,0 L1,0 L1,1 L0,1 Z M1,0 L1,1 L0.5,0.5 Z" fill="currentColor"/><path d="M0,0 L1,0 M0,1 L1,1 M0,0 L0,1" fill="none" ${e}/><path d="M1,0 L0.5,0.5 M1,1 L0.5,0.5" fill="none" ${t}/>`;case 129899:return`<path fill-rule="evenodd" d="M0,0 L1,0 L1,1 L0,1 Z M0,1 L1,1 L0.5,0.5 Z" fill="currentColor"/><path d="M0,0 L1,0 M0,0 L0,1 M1,0 L1,1" fill="none" ${e}/><path d="M0,1 L0.5,0.5 M1,1 L0.5,0.5" fill="none" ${t}/>`;case 129900:return'<path d="M0,0 L0,1 L0.5,0.5 Z" fill="currentColor"/>'+V("M0,0 L0,1 L0.5,0.5 Z");case 57520:return'<path d="M0,0 L1,0.5 L0,1 Z" fill="currentColor"/>';case 57521:return'<path d="M0,0 L1,0.5 L0,1" fill="none" stroke="currentColor" stroke-width="0.07" stroke-linejoin="miter"/>';case 57522:return'<path d="M1,0 L0,0.5 L1,1 Z" fill="currentColor"/>';case 57523:return'<path d="M1,0 L0,0.5 L1,1" fill="none" stroke="currentColor" stroke-width="0.07" stroke-linejoin="miter"/>';case 57524:return'<path d="M0,0 A1,0.5 0 0 1 0,1 Z" fill="currentColor"/>';case 57525:return'<path d="M0,0 A1,0.5 0 0 1 0,1" fill="none" stroke="currentColor" stroke-width="0.07"/>';case 57526:return'<path d="M1,0 A1,0.5 0 0 0 1,1 Z" fill="currentColor"/>';case 57527:return'<path d="M1,0 A1,0.5 0 0 0 1,1" fill="none" stroke="currentColor" stroke-width="0.07"/>';case 57528:return'<path d="M0,1 L0,0 L1,1 Z" fill="currentColor"/>';case 57529:case 57535:return'<path d="M0,0 L1,1" fill="none" stroke="currentColor" stroke-width="0.07"/>';case 57530:return'<path d="M1,1 L1,0 L0,1 Z" fill="currentColor"/>';case 57531:case 57533:return'<path d="M0,1 L1,0" fill="none" stroke="currentColor" stroke-width="0.07"/>';case 57532:return'<path d="M0,0 L1,0 L0,1 Z" fill="currentColor"/>';case 57534:return'<path d="M1,0 L1,1 L0,0 Z" fill="currentColor"/>';default:return null}}(A);if(!e)return!1;if(r.has(A))return!0;const t=`sym-${A}`,V=document.createElementNS(ze,"symbol");return V.setAttribute("id",t),V.setAttribute("viewBox","0 0 1 1"),V.setAttribute("preserveAspectRatio","none"),V.setAttribute("overflow","visible"),V.innerHTML=e,p.appendChild(V),r.add(A),!0}(A))return null;const n=nt.has(A),i=n?e-rt:e,o=n?1+2*rt:1,I=function(){let A=g.pop();void 0===A&&(A=document.createElementNS(ze,"use"));return A}();return I.setAttribute("href",`#sym-${A}`),I.setAttribute("x",i),I.setAttribute("y",0),I.setAttribute("width",o),I.setAttribute("height","1"),t?I.style.setProperty("color",t):I.style.removeProperty("color"),V?I.classList.add("ap-blink"):I.classList.remove("ap-blink"),I}return wA((()=>{!function(){if(h=w.getContext("2d"),!h)throw new Error("2D ctx not available");const{cols:A,rows:e}=s();w.width=8*A,w.height=e*Xe,w.style.imageRendering="pixelated",h.imageSmoothingEnabled=!1}(),L=function(A){const e=getComputedStyle(A),t=n(e.getPropertyValue("--term-color-foreground"),it.foreground),V=n(e.getPropertyValue("--term-color-background"),it.background),g=[];for(let A=0;A<16;A++){const t=A>=8?g[A-8]:it.palette[A];g[A]=n(e.getPropertyValue(`--term-color-${A}`),t)}return{foreground:t,background:V,palette:g}}(f),M.theme=L,H(s().rows),O(s().rows),I.then((t=>{B=t,e.addEventListener("reset",N),e.addEventListener("resize",v),e.addEventListener("output",b),A.onReady?.()}))})),hA((()=>{e.removeEventListener("reset",N),e.removeEventListener("resize",v),e.removeEventListener("output",b),clearInterval(q),cancelAnimationFrame(m)})),lA((()=>{A.blinking&&void 0===q?q=setInterval(U,600):(clearInterval(q),q=void 0,l(!0))})),lA((()=>{u(),F.visible&&(M.rows.add(F.row),S())})),(()=>{const A=je.cloneNode(!0),e=A.firstChild,t=e.nextSibling,V=t.firstChild,g=V.nextSibling,n=t.nextSibling;"function"==typeof f?Ae(f,A):f=A;"function"==typeof w?Ae(w,e):w=e;"function"==typeof y?Ae(y,t):y=t;"function"==typeof p?Ae(p,V):p=V;"function"==typeof k?Ae(k,g):k=g;return"function"==typeof D?Ae(D,n):D=n,cA((e=>{const V=d(),g=`0 0 ${s().cols} ${s().rows}`,r=!!c(),i=!!c();return e._v$=_A(A,V,e._v$),g!==e._v$2&&zA(t,"viewBox",e._v$2=g),r!==e._v$3&&t.classList.toggle("ap-blink",e._v$3=r),i!==e._v$4&&n.classList.toggle("ap-blink",e._v$4=i),e}),{_v$:void 0,_v$2:void 0,_v$3:void 0,_v$4:void 0}),A})()};function _e(A,e=!1){return{fg:A.foreground,bg:A.background,palette:e?At(A.palette,A.background,A.foreground):et(A.palette)}}function At(A,e,t){const V=i(e),g=i(t),n=i(A[1]),I=i(A[2]),B=i(A[3]),s=i(A[4]),C=i(A[5]),Q=i(A[6]),a=[...A];for(let A=0;A<6;A+=1){const e=A/5,t=r(e,V,n),i=r(e,I,B),E=r(e,s,C),c=r(e,Q,g);for(let A=0;A<6;A+=1){const e=A/5,V=r(e,t,i),g=r(e,E,c);for(let A=0;A<6;A+=1){const e=r(A/5,V,g);a.push(o(e))}}}for(let A=0;A<24;A+=1){const e=(A+1)/25;a.push(o(r(e,V,g)))}return a}function et(A){const e=[...A],t=[0,95,135,175,215,255];for(let A=0;A<6;A+=1)for(let V=0;V<6;V+=1)for(let g=0;g<6;g+=1)e.push(s(t[A],t[V],t[g]));for(let A=0;A<24;A+=1){const t=8+10*A;e.push(s(t,t,t))}return e}function tt(A,e,t,V){const g=12;switch(e){case 9475:A.fillRect(t+3,V,2,Xe);break;case 9593:A.fillRect(t+3,V,2,g);break;case 9595:A.fillRect(t+3,V+g,2,g);break;case 9600:A.fillRect(t,V,8,g);break;case 9601:A.fillRect(t,V+21,8,3);break;case 9602:A.fillRect(t,V+18,8,6);break;case 9603:A.fillRect(t,V+15,8,9);break;case 9604:A.fillRect(t,V+g,8,g);break;case 9605:A.fillRect(t,V+9,8,15);break;case 9606:A.fillRect(t,V+6,8,18);break;case 9607:A.fillRect(t,V+3,8,21);break;case 9608:A.fillRect(t,V,8,Xe);break;case 9632:A.fillRect(t,V+6,8,12);break;case 9609:A.fillRect(t,V,7,Xe);break;case 9610:A.fillRect(t,V,6,Xe);break;case 9611:A.fillRect(t,V,5,Xe);break;case 9612:A.fillRect(t,V,4,Xe);break;case 9613:A.fillRect(t,V,3,Xe);break;case 9614:A.fillRect(t,V,2,Xe);break;case 9615:A.fillRect(t,V,1,Xe);break;case 9616:A.fillRect(t+4,V,4,Xe);break;case 9617:A.save(),A.globalAlpha=.25,A.fillRect(t,V,8,Xe),A.restore();break;case 9618:A.save(),A.globalAlpha=.5,A.fillRect(t,V,8,Xe),A.restore();break;case 9619:A.save(),A.globalAlpha=.75,A.fillRect(t,V,8,Xe),A.restore();break;case 9620:A.fillRect(t,V,8,3);break;case 9621:A.fillRect(t+7,V,1,Xe);break;case 9622:A.fillRect(t,V+g,4,g);break;case 9623:A.fillRect(t+4,V+g,4,g);break;case 9624:A.fillRect(t,V,4,g);break;case 9625:A.fillRect(t,V,4,Xe),A.fillRect(t+4,V+g,4,g);break;case 9626:A.fillRect(t,V,4,g),A.fillRect(t+4,V+g,4,g);break;case 9627:A.fillRect(t,V,8,g),A.fillRect(t,V+g,4,g);break;case 9628:A.fillRect(t,V,8,g),A.fillRect(t+4,V+g,4,g);break;case 9629:A.fillRect(t+4,V,4,g);break;case 9630:A.fillRect(t+4,V,4,g),A.fillRect(t,V+g,4,g);break;case 9631:A.fillRect(t+4,V,4,Xe),A.fillRect(t,V+g,4,g);break;case 129792:A.fillRect(t,V,4,8);break;case 129793:A.fillRect(t+4,V,4,8);break;case 129794:A.fillRect(t,V,8,8);break;case 129795:A.fillRect(t,V+8,4,8);break;case 129796:A.fillRect(t,V,4,8),A.fillRect(t,V+8,4,8);break;case 129797:A.fillRect(t+4,V,4,8),A.fillRect(t,V+8,4,8);break;case 129798:A.fillRect(t,V,8,8),A.fillRect(t,V+8,4,8);break;case 129799:A.fillRect(t+4,V+8,4,8);break;case 129800:A.fillRect(t,V,4,8),A.fillRect(t+4,V+8,4,8);break;case 129801:A.fillRect(t+4,V,4,8),A.fillRect(t+4,V+8,4,8);break;case 129802:A.fillRect(t,V,8,8),A.fillRect(t+4,V+8,4,8);break;case 129803:A.fillRect(t,V+8,8,8);break;case 129804:A.fillRect(t,V,4,8),A.fillRect(t,V+8,8,8);break;case 129805:A.fillRect(t+4,V,4,8),A.fillRect(t,V+8,8,8);break;case 129806:A.fillRect(t,V,8,8),A.fillRect(t,V+8,8,8);break;case 129807:A.fillRect(t,V+16,4,8);break;case 129808:A.fillRect(t,V,4,8),A.fillRect(t,V+16,4,8);break;case 129809:A.fillRect(t+4,V,4,8),A.fillRect(t,V+16,4,8);break;case 129810:A.fillRect(t,V,8,8),A.fillRect(t,V+16,4,8);break;case 129811:A.fillRect(t,V+8,4,16);break;case 129812:A.fillRect(t+4,V,4,8),A.fillRect(t,V+8,4,16);break;case 129813:A.fillRect(t,V,8,8),A.fillRect(t,V+8,4,16);break;case 129814:A.fillRect(t+4,V+8,4,8),A.fillRect(t,V+16,4,8);break;case 129815:A.fillRect(t,V,4,8),A.fillRect(t+4,V+8,4,8),A.fillRect(t,V+16,4,8);break;case 129816:A.fillRect(t+4,V,4,16),A.fillRect(t,V+16,4,8);break;case 129817:A.fillRect(t,V,8,8),A.fillRect(t+4,V+8,4,8),A.fillRect(t,V+16,4,8);break;case 129818:A.fillRect(t,V+8,8,8),A.fillRect(t,V+16,4,8);break;case 129819:A.fillRect(t,V,4,24),A.fillRect(t+4,V+8,4,8);break;case 129820:A.fillRect(t+4,V,4,8),A.fillRect(t,V+8,8,8),A.fillRect(t,V+16,4,8);break;case 129821:A.fillRect(t,V,8,16),A.fillRect(t,V+16,4,8);break;case 129822:A.fillRect(t+4,V+16,4,8);break;case 129823:A.fillRect(t,V,4,8),A.fillRect(t+4,V+16,4,8);break;case 129824:A.fillRect(t+4,V,4,8),A.fillRect(t+4,V+16,4,8);break;case 129825:A.fillRect(t,V,8,8),A.fillRect(t+4,V+16,4,8);break;case 129826:A.fillRect(t,V+8,4,8),A.fillRect(t+4,V+16,4,8);break;case 129827:A.fillRect(t,V,4,16),A.fillRect(t+4,V+16,4,8);break;case 129828:A.fillRect(t+4,V,4,8),A.fillRect(t,V+8,4,8),A.fillRect(t+4,V+16,4,8);break;case 129829:A.fillRect(t,V,8,8),A.fillRect(t,V+8,4,8),A.fillRect(t+4,V+16,4,8);break;case 129830:A.fillRect(t+4,V+8,4,16);break;case 129831:A.fillRect(t,V,4,8),A.fillRect(t+4,V+8,4,16);break;case 129832:A.fillRect(t,V,8,8),A.fillRect(t+4,V+8,4,16);break;case 129833:A.fillRect(t,V+8,8,8),A.fillRect(t+4,V+16,4,8);break;case 129834:A.fillRect(t,V,4,16),A.fillRect(t+4,V+8,4,16);break;case 129835:A.fillRect(t+4,V,4,8),A.fillRect(t,V+8,8,8),A.fillRect(t+4,V+16,4,8);break;case 129836:A.fillRect(t,V,8,16),A.fillRect(t+4,V+16,4,8);break;case 129837:A.fillRect(t,V+16,8,8);break;case 129838:A.fillRect(t,V,4,8),A.fillRect(t,V+16,8,8);break;case 129839:A.fillRect(t+4,V,4,8),A.fillRect(t,V+16,8,8);break;case 129840:A.fillRect(t,V,8,8),A.fillRect(t,V+16,8,8);break;case 129841:A.fillRect(t,V+8,4,8),A.fillRect(t,V+16,8,8);break;case 129842:A.fillRect(t,V,4,16),A.fillRect(t,V+16,8,8);break;case 129843:A.fillRect(t+4,V,4,8),A.fillRect(t,V+8,4,8),A.fillRect(t,V+16,8,8);break;case 129844:A.fillRect(t,V,8,8),A.fillRect(t,V+8,4,8),A.fillRect(t,V+16,8,8);break;case 129845:A.fillRect(t+4,V+8,4,8),A.fillRect(t,V+16,8,8);break;case 129846:A.fillRect(t,V,4,8),A.fillRect(t+4,V+8,4,8),A.fillRect(t,V+16,8,8);break;case 129847:A.fillRect(t+4,V,4,16),A.fillRect(t,V+16,8,8);break;case 129848:A.fillRect(t,V,8,8),A.fillRect(t+4,V+8,4,8),A.fillRect(t,V+16,8,8);break;case 129849:A.fillRect(t,V+8,8,16);break;case 129850:A.fillRect(t,V,4,24),A.fillRect(t+4,V+8,4,8),A.fillRect(t+4,V+16,4,8);break;case 129851:A.fillRect(t+4,V,4,8),A.fillRect(t,V+8,8,16)}}const Vt=.05,gt=9.0375/20;const nt=new Set([57520,57521,57522,57523,57524,57525,57526,57527,57528,57529,57530,57531,57532,57533,57534,57535]),rt=.02,it={foreground:"#000000",background:"#000000",palette:["#000000","#000000","#000000","#000000","#000000","#000000","#000000","#000000","#000000","#000000","#000000","#000000","#000000","#000000","#000000","#000000"]},ot=$A('<svg version="1.1" viewBox="0 0 12 12" class="ap-icon ap-icon-fullscreen-off" aria-hidden="true"><path d="M7,5 L7,0 L9,2 L11,0 L12,1 L10,3 L12,5 Z"></path><path d="M5,7 L0,7 L2,9 L0,11 L1,12 L3,10 L5,12 Z"></path></svg>',6);var It=A=>ot.cloneNode(!0);const Bt=$A('<svg version="1.1" viewBox="6 8 14 16" class="ap-icon" aria-hidden="true"><path d="M0.938 8.313h22.125c0.5 0 0.938 0.438 0.938 0.938v13.5c0 0.5-0.438 0.938-0.938 0.938h-22.125c-0.5 0-0.938-0.438-0.938-0.938v-13.5c0-0.5 0.438-0.938 0.938-0.938zM1.594 22.063h20.813v-12.156h-20.813v12.156zM3.844 11.188h1.906v1.938h-1.906v-1.938zM7.469 11.188h1.906v1.938h-1.906v-1.938zM11.031 11.188h1.938v1.938h-1.938v-1.938zM14.656 11.188h1.875v1.938h-1.875v-1.938zM18.25 11.188h1.906v1.938h-1.906v-1.938zM5.656 15.031h1.938v1.938h-1.938v-1.938zM9.281 16.969v-1.938h1.906v1.938h-1.906zM12.875 16.969v-1.938h1.906v1.938h-1.906zM18.406 16.969h-1.938v-1.938h1.938v1.938zM16.531 20.781h-9.063v-1.906h9.063v1.906z"></path></svg>',4);var st=A=>Bt.cloneNode(!0);const Ct=$A('<svg version="1.1" viewBox="0 0 12 12" class="ap-icon" aria-hidden="true"><path d="M1,0 L4,0 L4,12 L1,12 Z"></path><path d="M8,0 L11,0 L11,12 L8,12 Z"></path></svg>',6);var Qt=A=>Ct.cloneNode(!0);const at=$A('<svg version="1.1" viewBox="0 0 12 12" class="ap-icon" aria-hidden="true"><path d="M1,0 L11,6 L1,12 Z"></path></svg>',4);var Et=A=>at.cloneNode(!0);const ct=$A('<svg version="1.1" viewBox="0 0 12 12" class="ap-icon ap-icon-fullscreen-on" aria-hidden="true"><path d="M12,0 L7,0 L9,2 L7,4 L8,5 L10,3 L12,5 Z"></path><path d="M0,12 L0,7 L2,9 L4,7 L5,8 L3,10 L5,12 Z"></path></svg>',6);var lt=A=>ct.cloneNode(!0);const ut=$A('<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" fill="currentColor" aria-hidden="true"><path d="M10.5 3.75a.75.75 0 0 0-1.264-.546L5.203 7H2.667a.75.75 0 0 0-.7.48A6.985 6.985 0 0 0 1.5 10c0 .887.165 1.737.468 2.52.111.29.39.48.7.48h2.535l4.033 3.796a.75.75 0 0 0 1.264-.546V3.75ZM16.45 5.05a.75.75 0 0 0-1.06 1.061 5.5 5.5 0 0 1 0 7.778.75.75 0 0 0 1.06 1.06 7 7 0 0 0 0-9.899Z"></path><path d="M14.329 7.172a.75.75 0 0 0-1.061 1.06 2.5 2.5 0 0 1 0 3.536.75.75 0 0 0 1.06 1.06 4 4 0 0 0 0-5.656Z"></path></svg>',6);var dt=A=>ut.cloneNode(!0);const ft=$A('<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" fill="currentColor" class="size-5" aria-hidden="true"><path d="M10.047 3.062a.75.75 0 0 1 .453.688v12.5a.75.75 0 0 1-1.264.546L5.203 13H2.667a.75.75 0 0 1-.7-.48A6.985 6.985 0 0 1 1.5 10c0-.887.165-1.737.468-2.52a.75.75 0 0 1 .7-.48h2.535l4.033-3.796a.75.75 0 0 1 .811-.142ZM13.78 7.22a.75.75 0 1 0-1.06 1.06L14.44 10l-1.72 1.72a.75.75 0 0 0 1.06 1.06l1.72-1.72 1.72 1.72a.75.75 0 1 0 1.06-1.06L16.56 10l1.72-1.72a.75.75 0 0 0-1.06-1.06L15.5 8.94l-1.72-1.72Z"></path></svg>',4);var wt=A=>ft.cloneNode(!0);const ht=$A('<button class="ap-button ap-playback-button" type="button"></button>',2),Dt=$A('<span class="ap-bar"><span class="ap-gutter ap-gutter-empty"></span><span class="ap-gutter ap-gutter-full"></span></span>',6),yt=$A('<span class="ap-tooltip">Unmute (m)</span>',2),pt=$A('<span class="ap-tooltip">Mute (m)</span>',2),kt=$A('<button class="ap-button ap-speaker-button ap-tooltip-container" type="button" aria-label="Mute / unmute"></button>',2),mt=$A('<div class="ap-control-bar"><span class="ap-timer"><span class="ap-time-elapsed"></span><span class="ap-time-remaining"></span></span><span class="ap-progressbar"></span><button class="ap-button ap-kbd-button ap-tooltip-container" type="button" aria-label="Show keyboard shortcuts"><span class="ap-tooltip">Keyboard shortcuts (?)</span></button><button class="ap-button ap-fullscreen-button ap-tooltip-container" type="button" aria-label="Toggle fullscreen mode"><span class="ap-tooltip">Fullscreen (f)</span></button></div>',18),qt=$A('<span class="ap-marker-container ap-tooltip-container"><span class="ap-marker"></span><span class="ap-tooltip"></span></span>',6);function Lt(A){let e=Math.floor(A);const t=Math.floor(e/86400);e%=86400;const V=Math.floor(e/3600);e%=3600;const g=Math.floor(e/60);return e%=60,t>0?`${Ft(t)}:${Ft(V)}:${Ft(g)}:${Ft(e)}`:V>0?`${Ft(V)}:${Ft(g)}:${Ft(e)}`:`${Ft(g)}:${Ft(e)}`}function Ft(A){return A<10?`0${A}`:A.toString()}var Mt=A=>{const e=A=>e=>{e.preventDefault(),A(e)},t=()=>"number"==typeof A.currentTime?Lt(A.currentTime):"--:--",V=()=>"number"==typeof A.remainingTime?"-"+Lt(A.remainingTime):t(),g=uA((()=>"number"==typeof A.duration?A.markers.filter((e=>e[0]<A.duration)):[])),n=A=>{const e=A.currentTarget.offsetWidth,t=A.currentTarget.getBoundingClientRect(),V=A.clientX-t.left;return 100*Math.max(0,V/e)+"%"},[r,i]=EA(!1),o=function(A,e){let t=!0;return function(...V){t&&(t=!1,A.apply(this,V),setTimeout((()=>t=!0),e))}}(A.onSeekClick,50),I=e=>{e._marker||e.altKey||e.shiftKey||e.metaKey||e.ctrlKey||0!==e.button||(i(!0),A.onSeekClick(n(e)))},B=A=>{A.altKey||A.shiftKey||A.metaKey||A.ctrlKey||r()&&o(n(A))},s=()=>{i(!1)};return document.addEventListener("mouseup",s),hA((()=>{document.removeEventListener("mouseup",s)})),(()=>{const n=mt.cloneNode(!0),r=n.firstChild,i=r.firstChild,o=i.nextSibling,s=r.nextSibling,C=s.nextSibling,Q=C.firstChild,a=C.nextSibling,E=a.firstChild,c=A.ref;return"function"==typeof c?Ae(c,n):A.ref=n,ee(n,TA(OA,{get when(){return A.isPausable},get children(){const t=ht.cloneNode(!0);return PA(t,"click",e(A.onPlayClick)),ee(t,TA(xA,{get children(){return[TA(ZA,{get when(){return A.isPlaying},get children(){return TA(Qt,{})}}),TA(ZA,{when:!0,get children(){return TA(Et,{})}})]}})),cA((()=>zA(t,"aria-label",A.isPlaying?"Pause":"Play"))),t}}),r),ee(i,t),ee(o,V),ee(s,TA(OA,{get when(){return"number"==typeof A.progress||A.isSeekable},get children(){const t=Dt.cloneNode(!0),V=t.firstChild.nextSibling;return t.$$mousemove=B,t.$$mousedown=I,ee(t,TA(HA,{get each(){return g()},children:(t,V)=>(()=>{const g=qt.cloneNode(!0),n=g.firstChild,r=n.nextSibling;var i;return g.$$mousedown=A=>{A._marker=!0},PA(g,"click",(i=V(),e((()=>{A.onSeekClick({marker:i})})))),ee(r,(()=>(A=>""===A[1]?Lt(A[0]):`${Lt(A[0])} - ${A[1]}`)(t))),cA((e=>{const V=(e=>e[0]/A.duration*100+"%")(t),r=!!(e=>"number"==typeof A.currentTime&&e[0]<=A.currentTime)(t);return V!==e._v$&&g.style.setProperty("left",e._v$=V),r!==e._v$2&&n.classList.toggle("ap-marker-past",e._v$2=r),e}),{_v$:void 0,_v$2:void 0}),g})()}),null),cA((e=>_A(V,{transform:`scaleX(${A.progress||0}`},e))),t}})),ee(n,TA(OA,{get when(){return void 0!==A.isMuted},get children(){const t=kt.cloneNode(!0);return PA(t,"click",e(A.onMuteClick)),ee(t,TA(xA,{get children(){return[TA(ZA,{get when(){return!0===A.isMuted},get children(){return[TA(wt,{}),yt.cloneNode(!0)]}}),TA(ZA,{get when(){return!1===A.isMuted},get children(){return[TA(dt,{}),pt.cloneNode(!0)]}})]}})),t}}),C),PA(C,"click",e(A.onHelpClick)),ee(C,TA(st,{}),Q),PA(a,"click",e(A.onFullscreenClick)),ee(a,TA(lt,{}),E),ee(a,TA(It,{}),E),cA((()=>n.classList.toggle("ap-seekable",!!A.isSeekable))),n})()};jA(["click","mousedown","mousemove"]);const Rt=$A('<div class="ap-overlay ap-overlay-error"><span>💥</span></div>',4);var Nt=A=>Rt.cloneNode(!0);const vt=$A('<div class="ap-overlay ap-overlay-loading"><span class="ap-loader"></span></div>',4);var bt=A=>vt.cloneNode(!0);const Gt=$A('<div class="ap-overlay ap-overlay-info"><span></span></div>',4);var Ut=A=>(()=>{const e=Gt.cloneNode(!0);return ee(e.firstChild,(()=>A.message)),cA((()=>e.classList.toggle("ap-was-playing",!!A.wasPlaying))),e})();const St=$A('<div class="ap-overlay ap-overlay-start"><div class="ap-play-button"><div><span><svg version="1.1" viewBox="0 0 1000.0 1000.0" class="ap-icon"><defs><mask id="small-triangle-mask"><rect width="100%" height="100%" fill="white"></rect><polygon points="700.0 500.0, 400.00000000000006 326.7949192431122, 399.9999999999999 673.2050807568877" fill="black"></polygon></mask></defs><polygon points="1000.0 500.0, 250.0000000000001 66.98729810778059, 249.99999999999977 933.0127018922192" mask="url(#small-triangle-mask)" fill="white" class="ap-play-btn-fill"></polygon><polyline points="673.2050807568878 400.0, 326.7949192431123 600.0" stroke="white" stroke-width="90" class="ap-play-btn-stroke"></polyline></svg></span></div></div></div>',22);var Jt=A=>(()=>{const e=St.cloneNode(!0);var t;return PA(e,"click",(t=A.onClick,A=>{A.preventDefault(),t(A)})),e})();jA(["click"]);const Yt=$A("<li><kbd>space</kbd> - pause / resume</li>",4),Tt=$A("<li><kbd>←</kbd> / <kbd>→</kbd> - rewind / fast-forward by 5 seconds</li>",6),Kt=$A("<li><kbd>Shift</kbd> + <kbd>←</kbd> / <kbd>→</kbd> - rewind / fast-forward by 10%</li>",8),Ht=$A("<li><kbd>[</kbd> / <kbd>]</kbd> - jump to the previous / next marker</li>",6),Ot=$A("<li><kbd>0</kbd>, <kbd>1</kbd>, <kbd>2</kbd> ... <kbd>9</kbd> - jump to 0%, 10%, 20% ... 90%</li>",10),xt=$A("<li><kbd>,</kbd> / <kbd>.</kbd> - step back / forward, a frame at a time (when paused)</li>",6),Zt=$A("<li><kbd>m</kbd> - mute / unmute audio</li>",4),Wt=$A('<div class="ap-overlay ap-overlay-help"><div><div><p>Keyboard shortcuts</p><ul><li><kbd>f</kbd> - toggle fullscreen mode</li><li><kbd>k</kbd> - toggle keystroke overlay</li><li><kbd>?</kbd> - show this help popup</li></ul></div></div></div>',22);var $t=A=>(()=>{const e=Wt.cloneNode(!0),t=e.firstChild,V=t.firstChild.firstChild.nextSibling,g=V.firstChild,n=g.nextSibling.nextSibling;var r;return PA(e,"click",(r=A.onClose,A=>{A.preventDefault(),r(A)})),t.$$click=A=>{A.stopPropagation()},ee(V,TA(OA,{get when(){return A.isPausable},get children(){return Yt.cloneNode(!0)}}),g),ee(V,TA(OA,{get when(){return A.isSeekable},get children(){return[Tt.cloneNode(!0),Kt.cloneNode(!0),Ht.cloneNode(!0),Ot.cloneNode(!0),xt.cloneNode(!0)]}}),g),ee(V,TA(OA,{get when(){return A.hasAudio},get children(){return Zt.cloneNode(!0)}}),n),e})();jA(["click"]);const jt=$A("<div><kbd></kbd></div>",4),zt=$A('<div class="ap-overlay ap-overlay-keystrokes"></div>',2);function Xt(A){const[e,t]=EA(!1);return lA((()=>{const{id:e}=A.keystroke;A.keystroke.rev(),t(!1);const V=setTimeout((function(){t(!0)}),2e3),g=setTimeout((function(){A.onExpired(e)}),2700);hA((()=>{clearTimeout(V),clearTimeout(g)}))})),(()=>{const t=jt.cloneNode(!0);return ee(t.firstChild,(()=>A.keystroke.label())),cA((()=>XA(t,e()?"ap-keystroke-pill fading":"ap-keystroke-pill"))),t})()}var Pt=A=>(()=>{const e=zt.cloneNode(!0);return ee(e,TA(HA,{get each(){return A.keystrokes},children:e=>TA(Xt,{keystroke:e,get onExpired(){return A.onExpired}})})),cA((()=>e.style.setProperty("--ap-keystrokes-bottom",`${(A.bottomOffset??0)+12}px`))),e})();const _t={...Object.fromEntries(Array.from({length:26},((A,e)=>[String.fromCharCode(e+1),`C-${String.fromCharCode(97+e)}`]))),"\b":"Back","\r":"Ret","\t":"Tab","":"Esc","":"Back"},AV={" ":"Spc"},eV={57358:"Caps",57359:"Scroll",57360:"Num",57361:"Print",57362:"Pause",57363:"Menu",57414:"Enter",57421:"PgUp",57422:"PgDn"},tV={A:"↑",B:"↓",C:"→",D:"←",F:"End",H:"Home",P:"F1",Q:"F2",R:"F3",S:"F4"},VV={2:"Ins",3:"Del",5:"PgUp",6:"PgDn",15:"F5",17:"F6",18:"F7",19:"F8",20:"F9",21:"F10",23:"F11",24:"F12"};function gV(A,e){const t=Number.parseInt(e.split(":")[0],10);if(!Number.isFinite(t)||t<=1)return A;const V=t-1,g=[];return 4&V&&g.push("C"),2&V&&g.push("A"),1&V&&g.push("S"),0===g.length?A:`${g.join("-")}-${A}`}function nV(A){if(A in eV)return eV[A];const e=String.fromCodePoint(A);return e in _t?_t[e]:e in AV?AV[e]:e}function rV(A){const e=A.match(/^(\d+);;(\d+)u$/);if(null!==e)return`A-${nV(Number.parseInt(e[2],10))}`;const t=A.match(/^(\d+)(?:;([\d:]+))?u$/);if(null!==t){const A=nV(Number.parseInt(t[1],10));return void 0===t[2]?A:gV(A,t[2])}const V=A.match(/^O?([A-Z])$/);if(null!==V&&V[1]in tV)return tV[V[1]];const g=A.match(/^(\d+)~$/);if(null!==g&&g[1]in VV)return VV[g[1]];const n=A.match(/^27;([\d:]+);(\d+)~$/);if(null!==n){return gV(nV(Number.parseInt(n[2],10)),n[1])}const r=A.match(/^(?:1;)?([\d:]+)([A-Z])$/);if(null!==r&&r[2]in tV)return gV(tV[r[2]],r[1]);const i=A.match(/^(\d+);([\d:]+)~$/);return null!==i&&i[1]in VV?gV(VV[i[1]],i[2]):""}function iV(A){if(A in _t)return{kind:"special",label:_t[A]};if(1===A.length)return A in AV?{kind:"special",label:AV[A]}:{kind:"text",label:A};if(A.startsWith("")){const e=function(A){const e=A.slice(1);return 1===e.length?e in _t?"A-"+_t[e]:e in AV?"A-"+AV[e]:"A-"+e:e.startsWith("[")?rV(e.slice(1)):e.startsWith("O")?rV(e):""}(A);if(""!==e)return{kind:"special",label:e}}return null}const oV=$A('<div class="ap-wrapper" tabindex="-1"><div></div></div>',4);var IV=A=>{const e=A.logger,t=A.core,V=A.autoPlay,g=A.charW,n=A.charH,r=A.bordersW,i=A.bordersH,o=A.theme??"auto/asciinema",I="auto/"===o.slice(0,5),B=I?o.slice(5):o,[s,C]=(Q=A.cols,a=A.rows,EA({cols:Q,rows:a},{equals:(A,e)=>A.cols===e.cols&&A.rows===e.rows}));var Q,a;const[E,c]=EA({width:0,height:0},{equals:(A,e)=>A.width===e.width&&A.height===e.height}),[l,u]=EA(!0),[d,f]=EA(!0),[w,h]=EA(!1),[D,y]=EA(null),[p,k]=EA(null),[m,q]=EA(null),[L,F]=EA(!1),[M,R]=EA(void 0),[N,v]=EA(!1),[b,G]=EA(V?null:"start"),[U,S]=EA(null),[J,Y]=EA(!1),[T,K]=EA(null),[H,O]=EA([]),[x,Z]=EA(!1),[W,$]=EA(!1),[j,z]=EA(null),X=uA((()=>s().cols||80)),P=uA((()=>s().rows||24)),_=()=>!1===A.controls?0:32,[AA,eA]=EA(!1!==A.keystrokeOverlay),[tA,VA]=EA([]);let gA,nA,rA,iA,oA,IA,BA=1;function sA(){Y(!1),jA(),zA()}const CA=({isPausable:A,isSeekable:e})=>{dA((()=>{u(A),f(e)}))},QA=A=>{dA((()=>{void 0!==A.duration&&(K(A.duration),y(0),k(A.duration),q(0)),void 0!==A.markers&&O(A.markers),void 0!==A.hasAudio&&R(!A.hasAudio&&void 0)}))},aA=({size:A,theme:e})=>{dA((()=>{C(A),void 0!==e&&z(e)}))},lA=A=>{C(A)},fA=()=>{G(null)},DA=()=>{dA((()=>{F(!0),v(!0),G(null),Y(!0),$A()}))},yA=()=>{dA((()=>{F(!1),sA()}))},pA=()=>{dA((()=>{F(!1),sA(),G("loader"),NA()}))},kA=({message:A})=>{dA((()=>{F(!1),sA(),NA(),void 0!==A&&(S(A),G("info"))}))},mA=A=>{R(A)},qA={renders:0},LA=({message:A})=>{dA((()=>{F(!1),sA(),void 0!==A&&(S(A),G("info"))})),e.debug("stats",qA)},FA=()=>{NA(),G("error")},MA=({data:A})=>{if(!AA())return;const e=iV(A);if(null===e)return;const t=tA(),V=t[t.length-1];"text"!==V?.kind||"text"!==e.kind?"special"!==V?.kind||"special"!==e.kind||V.key!==e.label?VA([...t,bA(e)].slice(-4)):V.increment():V.append(e.label)},RA=()=>{zA(),NA()},NA=()=>{VA([])},vA=A=>{VA((e=>e.filter((e=>e.id!==A))))},bA=({kind:A,label:e})=>{const[t,V]=EA(e),[g,n]=EA(1),[r,i]=EA(0);return{id:BA++,kind:A,key:e,label:()=>1===g()?t():`${t()} × ${g()}`,rev:r,append:A=>{V((e=>(e+A).slice(-10))),i((A=>A+1))},increment:()=>{n((A=>A+1)),i((A=>A+1))}}};t.addEventListener("ready",CA),t.addEventListener("metadata",QA),t.addEventListener("play",fA),t.addEventListener("playing",DA),t.addEventListener("pause",yA),t.addEventListener("loading",pA),t.addEventListener("offline",kA),t.addEventListener("muted",mA),t.addEventListener("ended",LA),t.addEventListener("error",FA),t.addEventListener("input",MA),t.addEventListener("seeked",RA),t.addEventListener("reset",aA),t.addEventListener("resize",lA);const GA=()=>{IA=new ResizeObserver(function(A,e){let t;return function(...V){clearTimeout(t),t=setTimeout((()=>A.apply(this,V)),e)}}((A=>{c({width:rA.offsetWidth,height:rA.offsetHeight}),rA.dispatchEvent(new CustomEvent("resize",{detail:{el:iA}}))}),10)),IA.observe(rA)};wA((async()=>{e.info("view: mounted"),e.debug("view: font measurements",{charW:g,charH:n}),GA(),c({width:rA.offsetWidth,height:rA.offsetHeight})})),hA((()=>{t.removeEventListener("ready",CA),t.removeEventListener("metadata",QA),t.removeEventListener("play",fA),t.removeEventListener("playing",DA),t.removeEventListener("pause",yA),t.removeEventListener("loading",pA),t.removeEventListener("offline",kA),t.removeEventListener("muted",mA),t.removeEventListener("ended",LA),t.removeEventListener("error",FA),t.removeEventListener("input",MA),t.removeEventListener("seeked",RA),t.removeEventListener("reset",aA),t.removeEventListener("resize",lA),t.stop(),jA(),IA.disconnect()}));const UA=uA((()=>{const e=g*X()+r,t=n*P()+i;let V=A.fit??"width";const o=E();if("both"===V||w()){V=o.width/(o.height-_())>e/t?"height":"width"}if(!1===V||"none"===V)return{};if("width"===V){const A=o.width/e;return{scale:A,width:o.width,height:t*A+_()}}if("height"===V){const A=(o.height-_())/t;return{scale:A,width:e*A,height:o.height}}throw new Error(`unsupported fit mode: ${V}`)})),SA=()=>{h(document.fullscreenElement??document.webkitFullscreenElement)},JA=()=>{w()?(document.exitFullscreen??document.webkitExitFullscreen??(()=>{})).apply(document):(rA.requestFullscreen??rA.webkitRequestFullscreen??(()=>{})).apply(rA)},YA=()=>{W()?$(!1):(t.pause(),$(!0))},KA=A=>{if(!(A.altKey||A.metaKey||A.ctrlKey||(" "==A.key||"Enter"==A.key)&&A.target instanceof HTMLButtonElement)){if(" "==A.key)ge();else if(","==A.key)t.step(-1).then(zA);else if("."==A.key)t.step().then(zA);else if("f"==A.key)JA();else if("m"==A.key)ne();else if("["==A.key)t.seek({marker:"prev"});else if("]"==A.key)t.seek({marker:"next"});else if(A.key.charCodeAt(0)>=48&&A.key.charCodeAt(0)<=57){const e=(A.key.charCodeAt(0)-48)/10;t.seek(100*e+"%")}else if("?"==A.key)YA();else if("k"==A.key)AA()?(NA(),eA(!1)):eA(!0);else if("ArrowLeft"==A.key)A.shiftKey?t.seek("<<<"):t.seek("<<");else if("ArrowRight"==A.key)A.shiftKey?t.seek(">>>"):t.seek(">>");else{if("Escape"!=A.key)return;$(!1)}A.stopPropagation(),A.preventDefault()}},HA=()=>{w()&&PA(!0)},WA=()=>{w()||PA(!1)},$A=()=>{clearInterval(nA),nA=setInterval(zA,100)},jA=()=>{clearInterval(nA)},zA=async()=>{const A=await t.getCurrentTime(),e=await t.getRemainingTime(),V=await t.getProgress();dA((()=>{y(A),k(e),q(V)}))},PA=A=>{clearTimeout(gA),A&&(gA=setTimeout((()=>PA(!1)),2e3)),Z(A)},te=uA((()=>I?j():null)),Ve=()=>{t.play()},ge=()=>{L()?t.pause():t.play()},ne=()=>{!0===M()?t.unmute():t.mute()},re=A=>{t.seek(A)},ie=(()=>{const V=oV.cloneNode(!0),g=V.firstChild;"function"==typeof rA?Ae(rA,V):rA=V,V.addEventListener("webkitfullscreenchange",SA),V.addEventListener("fullscreenchange",SA),V.$$mousemove=HA,V.$$keydown=KA;return"function"==typeof iA?Ae(iA,g):iA=g,g.$$mousemove=()=>PA(!0),g.addEventListener("mouseleave",WA),ee(g,TA(Pe,{get cols(){return X()},get rows(){return P()},get scale(){return UA()?.scale},get blinking(){return J()},get cursorMode(){return A.cursorMode},get boldIsBright(){return A.boldIsBright},get adaptivePalette(){return A.adaptivePalette},get lineHeight(){return A.terminalLineHeight},preferEmbeddedTheme:I,core:t,logger:e,get onReady(){return A.onTerminalReady},get stats(){return qA}}),null),ee(g,TA(OA,{get when(){return!1!==A.controls},get children(){return TA(Mt,{get duration(){return T()},get currentTime(){return D()},get remainingTime(){return p()},get progress(){return m()},get markers(){return H()},get isPlaying(){return L()||"loader"==b()},get isPausable(){return l()},get isSeekable(){return d()},get isMuted(){return M()},onPlayClick:ge,onFullscreenClick:JA,onHelpClick:YA,onSeekClick:re,onMuteClick:ne,ref(A){"function"==typeof oA?oA(A):oA=A}})}}),null),ee(g,TA(OA,{get when(){return tA().length>0},get children(){return TA(Pt,{get bottomOffset(){return _()},get keystrokes(){return tA()},onExpired:vA})}}),null),ee(g,TA(xA,{get children(){return[TA(ZA,{get when(){return"start"==b()},get children(){return TA(Jt,{onClick:Ve})}}),TA(ZA,{get when(){return"loader"==b()},get children(){return TA(bt,{})}}),TA(ZA,{get when(){return"error"==b()},get children(){return TA(Nt,{})}})]}}),null),ee(g,TA(Ee,{name:"slide",get children(){return TA(OA,{get when(){return"info"==b()},get children(){return TA(Ut,{get message(){return U()},get wasPlaying(){return N()}})}})}}),null),ee(g,TA(OA,{get when(){return W()},get children(){return TA($t,{onClose:()=>$(!1),get isPausable(){return l()},get isSeekable(){return d()},get hasAudio(){return void 0!==M()}})}}),null),cA((e=>{const t=!!(!0===A.controls||"auto"===A.controls&&x()),n=`ap-player ap-default-term-ff asciinema-player-theme-${B}`,r=(()=>{const e={};!1!==A.fit&&"none"!==A.fit||void 0===A.terminalFontSize||("small"===A.terminalFontSize?e["font-size"]="12px":"medium"===A.terminalFontSize?e["font-size"]="18px":"big"===A.terminalFontSize?e["font-size"]="24px":e["font-size"]=A.terminalFontSize);const t=UA();void 0!==t.width&&(e.width=`${t.width}px`,e.height=`${t.height}px`),void 0!==A.terminalFontFamily&&(e["--term-font-family"]=A.terminalFontFamily);const V=te();return V&&(e["--term-color-foreground"]=V.foreground,e["--term-color-background"]=V.background),e})();return t!==e._v$&&V.classList.toggle("ap-hud",e._v$=t),n!==e._v$2&&XA(g,e._v$2=n),e._v$3=_A(g,r,e._v$3),e}),{_v$:void 0,_v$2:void 0,_v$3:void 0}),V})();return ie};function BV(A,e,t={}){const V=function(A,e){const t=80,V=24,g=document.createElement("div");g.className="ap-default-term-ff",g.style.height="0px",g.style.overflow="hidden",g.style.fontSize="15px",void 0!==A&&g.style.setProperty("--term-font-family",A);const n=document.createElement("div");n.className="ap-term",n.style.width=`${t}ch`,n.style.height=V*(e??1.3333333333)+"em",n.style.fontSize="100%",g.appendChild(n),document.body.appendChild(g);const r={charW:n.clientWidth/t,charH:n.clientHeight/V,bordersW:n.offsetWidth-n.clientWidth,bordersH:n.offsetHeight-n.clientHeight};return document.body.removeChild(g),r}(t.terminalFontFamily,t.terminalLineHeight),g={core:A,logger:t.logger,cols:t.cols,rows:t.rows,fit:t.fit,controls:t.controls,cursorMode:t.cursorMode,keystrokeOverlay:t.keystrokeOverlay,autoPlay:t.autoPlay,boldIsBright:t.boldIsBright,adaptivePalette:t.adaptivePalette,terminalFontSize:t.terminalFontSize,terminalFontFamily:t.terminalFontFamily,terminalLineHeight:t.terminalLineHeight,theme:t.theme,onTerminalReady:t.onTerminalReady,...V};let n;const r=function(A,e,t,V={}){let g;return aA((V=>{g=V,e===document?A():ee(e,A(),e.firstChild?null:void 0,t)}),V.owner),()=>{g(),e.textContent=""}}((()=>(n=TA(IV,g),n)),e);return{el:n,dispose:r}}jA(["keydown","mousemove"]);const sV=["audioUrl","autoPlay","autoplay","cols","idleTimeLimit","loop","markers","pauseOnMarkers","poster","preload","rows","speed","startAt"],CV=["autoPlay","autoplay","boldIsBright","cols","adaptivePalette","controls","cursorMode","fit","keystrokeOverlay","rows","terminalFontFamily","terminalFontSize","terminalLineHeight","theme"];return A.create=function(A,e,t={}){const V=t.logger??new u,g=new _(A,function(A,e={}){const t=Object.fromEntries(Object.entries(A).filter((([A])=>sV.includes(A))));return t.autoPlay??=t.autoplay,t.speed??=1,{...t,...e}}(t,{logger:V})),{el:n,dispose:r}=BV(g,e,function(A,e={}){const t=Object.fromEntries(Object.entries(A).filter((([A])=>CV.includes(A))));if(t.autoPlay??=t.autoplay,t.adaptivePalette??=!1,t.controls??="auto",t.cursorMode??="blinking",t.keystrokeOverlay??=!1,!["blinking","steady","hidden"].includes(t.cursorMode))throw new Error(`unsupported cursor mode: ${t.cursorMode}`);if("boolean"!=typeof t.keystrokeOverlay)throw new Error(`unsupported keystroke overlay option: ${t.keystrokeOverlay}`);return{...t,...e}}(t,{logger:V,onTerminalReady:()=>g.terminalReady()}));g.init().catch((()=>{}));const i={el:n,dispose:r,getCurrentTime:()=>g.getCurrentTime(),getDuration:()=>g.getDuration(),play:()=>g.play(),pause:()=>g.pause(),seek:A=>g.seek(A),addEventListener:(A,e)=>g.addEventListener(A,e.bind(i))};return i},A}({});
+/* @license-end */
diff --git a/site/index.html b/site/index.html
index 799ecc5..ea1b65d 100644
--- a/site/index.html
+++ b/site/index.html
@@ -8,6 +8,7 @@
   <link rel="preconnect" href="https://fonts.googleapis.com">
   <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
   <link href="https://fonts.googleapis.com/css2?family=DM+Mono:ital,wght@0,300;0,400;0,500;1,300;1,400;1,500&family=DM+Sans:ital,opsz,wght@0,9..40,300;0,9..40,400;0,9..40,500;0,9..40,600;0,9..40,700;1,9..40,300;1,9..40,400&display=swap" rel="stylesheet">
+  <link rel="stylesheet" href="assets/asciinema-player.css">
   <style>
     *, *::before, *::after { margin: 0; padding: 0; box-sizing: border-box; }
 
@@ -311,14 +312,47 @@
       overflow: hidden;
     }
 
-    .terminal-line {
-      opacity: 0;
-      transform: translateY(4px);
-      animation: line-appear 0.3s ease forwards;
+    /* asciinema player mount — the player supplies its own padding and sizing. */
+    .terminal-body.terminal-player {
+      padding: 0;
+      min-height: 0;
+      line-height: normal;
+    }
+
+    /* Terminal palette for the player, matched to this page's colors. */
+    .asciinema-player-theme-crisismode {
+      --term-color-background: var(--bg-secondary);
+      --term-color-foreground: var(--text-primary);
+      --term-color-0: #27272a;
+      --term-color-1: var(--red);
+      --term-color-2: var(--green);
+      --term-color-3: var(--amber);
+      --term-color-4: #3b82f6;
+      --term-color-5: #ec4899;
+      --term-color-6: var(--cyan);
+      --term-color-7: var(--text-primary);
+      --term-color-8: #52525b;
+      --term-color-9: #f87171;
+      --term-color-10: #4ade80;
+      --term-color-11: #fbbf24;
+      --term-color-12: #60a5fa;
+      --term-color-13: #f472b6;
+      --term-color-14: #22d3ee;
+      --term-color-15: #fafafa;
+    }
+
+    .terminal-caption {
+      max-width: 860px;
+      margin: 1rem auto 0;
+      font-size: 0.8125rem;
+      line-height: 1.6;
+      color: var(--text-tertiary);
+      text-align: center;
     }
 
-    @keyframes line-appear {
-      to { opacity: 1; transform: translateY(0); }
+    .terminal-caption code {
+      font-family: var(--font-mono);
+      color: var(--text-secondary);
     }
 
     .t-dim { color: var(--text-muted); }
@@ -330,21 +364,6 @@
     .t-secondary { color: var(--text-secondary); }
     .t-bold { font-weight: 500; }
 
-    .cursor-blink {
-      display: inline-block;
-      width: 8px;
-      height: 14px;
-      background: var(--amber);
-      margin-left: 2px;
-      vertical-align: middle;
-      animation: blink 1s step-end infinite;
-    }
-
-    @keyframes blink {
-      0%, 100% { opacity: 1; }
-      50% { opacity: 0; }
-    }
-
     /* ── SECTIONS ── */
     section {
       padding: 6rem 2rem;
@@ -905,8 +924,26 @@ <h1>
           <div class="terminal-dot green"></div>
           <span class="terminal-title">crisismode — demo mode (simulator, no infrastructure required)</span>
         </div>
-        <div class="terminal-body" id="terminal-body"></div>
+        <!-- Real recording of `crisismode demo`. Regenerate with scripts/record-demo.sh.
+             Phase 5 of the demo is a live Claude API call, so every re-recording
+             changes the root-cause wording and the confidence figure. When the
+             assets change, update the alt text below to match what the new GIF
+             actually shows — it is both an accessibility surface and a claim
+             about the product. -->
+        <div class="terminal-body terminal-player" id="terminal-player"></div>
+        <!-- Fallback when JavaScript is off. The script below reuses this same
+             markup if the player cannot start, so the GIF lives in exactly one
+             place and is never fetched alongside a working player. -->
+        <noscript id="terminal-fallback">
+          <img src="assets/demo.gif" alt="Opening excerpt of a terminal recording of `crisismode demo`: a Prometheus PostgresReplicationLagCritical alert selects the postgresql-replication-recovery agent, a live AI diagnosis identifies the scenario as replication_lag_cascade at 78% confidence — a primary-side WAL generation spike putting all three replicas behind the same sent_lsn, worst on 10.0.1.52 — and the agent builds a 10-step recovery plan with per-step risk, blast radius and undo notes, which the framework then begins validating. The excerpt ends at plan validation; the full recording continues through a human approval gate into dry-run execution." style="display: block; width: 100%;">
+        </noscript>
       </div>
+      <p class="terminal-caption">
+        An unedited recording of <code>crisismode demo</code> — the simulated PostgreSQL
+        replication-lag cascade. Line timing is paced for readability; the step durations
+        shown are the real measured values. The diagnosis is a real model call, so its
+        reasoning and confidence differ from run to run.
+      </p>
     </div>
   </section>
 
@@ -1341,6 +1378,7 @@ <h2 class="section-title reveal">Recovery is too important to improvise</h2>
     <p>CrisisMode v0.8.0 &mdash; Recovery Agent Contract Specification v0.3.0-draft &mdash; Apache 2.0</p>
   </footer>
 
+  <script src="assets/asciinema-player.min.js"></script>
   <script>
     // ── Scroll Reveal ──
     const observer = new IntersectionObserver(
@@ -1356,81 +1394,55 @@ <h2 class="section-title reveal">Recovery is too important to improvise</h2>
 
     document.querySelectorAll('.reveal').forEach((el) => observer.observe(el));
 
-    // ── Terminal Animation ──
-    const terminalLines = [
-      { text: '$ crisismode demo', classes: 't-white t-bold' },
-      { text: '', classes: '' },
-      { text: '════════════════════════════════════════════════════════════', classes: 't-dim' },
-      { text: '  ⚠  CRISISMODE — Recovery Agent Framework', classes: 't-amber t-bold' },
-      { text: '  PostgreSQL Replication Lag Cascade Recovery', classes: 't-dim' },
-      { text: '════════════════════════════════════════════════════════════', classes: 't-dim' },
-      { text: '', classes: '' },
-      { text: '  Phase 1: Trigger', classes: 't-cyan t-bold' },
-      { text: '  ALERT FIRED  alertname=PostgresReplicationLagCritical', classes: 't-amber' },
-      { text: '', classes: '' },
-      { text: '  Phase 5: Diagnosis', classes: 't-cyan t-bold' },
-      { text: '  [CRITICAL] 3 replicas found, 1 severely lagging (342s)', classes: 't-red' },
-      { text: '  ✓ Identified: replication_lag_cascade (92% confidence)', classes: 't-green' },
-      { text: '', classes: '' },
-      { text: '  Phase 9: Execution', classes: 't-cyan t-bold' },
-      { text: '  Step step-004 [system_action]', classes: 't-white t-bold' },
-      { text: '  ◆ Capture: replication_state_snapshot — captured', classes: 't-dim' },
-      { text: '  ✓ Precondition: Replica is connected and streaming', classes: 't-green' },
-      { text: '  ✓ Success: WAL sender terminated', classes: 't-green' },
-      { text: '  ● SUCCESS (1ms)', classes: 't-green' },
-      { text: '', classes: '' },
-      { text: '  Step step-006 [replanning_checkpoint]', classes: 't-white t-bold' },
-      { text: '  ↻ Agent discovered invalid replication slot', classes: 't-cyan' },
-      { text: '  ↻ Revised plan: drop + recreate slot. Fast replan: approved', classes: 't-cyan' },
-      { text: '', classes: '' },
-      { text: '  ┌──────────────────────────────────────────┐', classes: 't-amber' },
-      { text: '  │       HUMAN APPROVAL REQUIRED            │', classes: 't-amber t-bold' },
-      { text: '  └──────────────────────────────────────────┘', classes: 't-amber' },
-      { text: '  Enter your decision (approve/skip/reject): _', classes: 't-white', cursor: true },
-    ];
-
-    const terminalBody = document.getElementById('terminal-body');
-    let lineIndex = 0;
+    // ── Terminal Demo ──
+    // A real recording of `crisismode demo` (site/assets/demo.cast), produced by
+    // scripts/record-demo.sh. Playback starts when the terminal scrolls into view.
+    const terminalMount = document.getElementById('terminal-player');
     let terminalStarted = false;
 
-    function addTerminalLine() {
-      if (lineIndex >= terminalLines.length) return;
-
-      const line = terminalLines[lineIndex];
-      const div = document.createElement('div');
-      div.className = 'terminal-line';
-      div.style.animationDelay = '0s';
-
-      if (line.text === '') {
-        div.innerHTML = '&nbsp;';
-      } else {
-        div.innerHTML = `<span class="${line.classes}">${escapeHtml(line.text)}</span>`;
-        if (line.cursor) {
-          div.querySelector('span').innerHTML =
-            div.querySelector('span').innerHTML.replace('_', '<span class="cursor-blink"></span>');
-        }
-      }
-
-      terminalBody.appendChild(div);
-      terminalBody.scrollTop = terminalBody.scrollHeight;
-      lineIndex++;
-
-      const delay = line.text === '' ? 80 : line.cursor ? 600 : 120;
-      setTimeout(addTerminalLine, delay);
-    }
-
-    function escapeHtml(text) {
-      const d = document.createElement('div');
-      d.textContent = text;
-      return d.innerHTML;
+    // When scripting is enabled a <noscript> element's children are parsed as
+    // raw text, so its textContent is the fallback markup. Reusing it here means
+    // the GIF and its alt text are declared once, and the 2.8MB asset stays
+    // unfetched unless the player genuinely cannot run.
+    function showTerminalFallback() {
+      const fallback = document.getElementById('terminal-fallback');
+      if (fallback) terminalMount.innerHTML = fallback.textContent;
     }
 
     const terminalObserver = new IntersectionObserver(
       (entries) => {
-        if (entries[0].isIntersecting && !terminalStarted) {
-          terminalStarted = true;
-          setTimeout(addTerminalLine, 400);
+        if (!entries[0].isIntersecting || terminalStarted) return;
+        terminalStarted = true;
+        terminalObserver.disconnect();
+
+        if (typeof AsciinemaPlayer === 'undefined') {
+          showTerminalFallback();
+          return;
         }
+
+        let player;
+        try {
+          player = AsciinemaPlayer.create('assets/demo.cast', terminalMount, {
+            theme: 'crisismode',
+            fit: 'width',
+            loop: true,
+            // No idleTimeLimit: scripts/pace-cast.mjs assigns every gap and
+            // clamps the longest to 4s, so there is nothing left to trim.
+            // Verified against the current cast: 314 events, 56.2s, max gap 4.0s.
+            // Trimming here would also cut the deliberate pause on the approval
+            // gate, which is the point of that frame.
+            poster: 'npt:0:03',
+            controls: 'auto',
+          });
+        } catch {
+          // A broken vendored player should degrade to the GIF, not an empty box.
+          showTerminalFallback();
+          return;
+        }
+
+        // Autoplay is muted-equivalent (no audio), so browsers allow it. If a
+        // policy blocks it the controls remain, so this stays non-fatal.
+        Promise.resolve(player.play()).catch(() => {});
       },
       { threshold: 0.3 }
     );
diff --git a/site/index.html.zip b/site/index.html.zip
deleted file mode 100644
index 7748d12be91c9a2d3b1610eaf3a740186462cc44..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 21372
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
Q2?G8cr#}O|G5G8CAAJ4nivR!s


From 27347593e0bf9ae9e828c0f0ba40b1ce04610576 Mon Sep 17 00:00:00 2001
From: trs-80 <109326+trs-80@users.noreply.github.com>
Date: Sun, 9 Aug 2026 12:05:36 -0400
Subject: [PATCH 06/17] chore(demo): fit the GIF teaser inside the 1MB commit
 ceiling
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The teaser rendered at 2.8MB, which the pre-commit hook rejects. Preserving
the old Phase 7 cut was not an option: rendering through the plan table costs
1.3MB even at font-size 10 and 4fps, which is past legible.

Re-anchors the cut on the Phase 6 heading and drops to 2fps: 905KiB, and it
still contains the part worth recording live — the model's own root-cause
paragraph at 78% confidence. The anchor stays content-based rather than a
fixed timestamp, so a wordier AI response cannot silently truncate it.

The size guard now fails the build at 1MB instead of warning at 3MB, so this
regresses loudly rather than at commit time. Alt text updated: the excerpt now
ends as plan creation begins, not at plan validation.

Cloudflare bundle drops from 2.8MB to 990KiB total.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 scripts/record-demo.sh |  37 ++++++++++++++++++++++++-------------
 site/assets/demo.gif   | Bin 0 -> 927088 bytes
 site/index.html        |   2 +-
 3 files changed, 25 insertions(+), 14 deletions(-)
 create mode 100644 site/assets/demo.gif

diff --git a/scripts/record-demo.sh b/scripts/record-demo.sh
index 6310a8e..12be588 100644
--- a/scripts/record-demo.sh
+++ b/scripts/record-demo.sh
@@ -125,14 +125,20 @@ node "$REPO_ROOT/scripts/pace-cast.mjs" "$RAW_CAST" "$CAST"
 THEME="0a0a0b,e4e4e7,27272a,ef4444,22c55e,f59e0b,3b82f6,ec4899,06b6d4,e4e4e7,52525b,f87171,4ade80,fbbf24,60a5fa,f472b6,22d3ee,fafafa"
 
 # The GIF is a fallback/social teaser, not the whole story: a full-length 100x30
-# GIF is >7MB at any usable quality. Cover the opening arc (alert -> diagnosis ->
-# plan table) and let the player carry the rest.
+# GIF is >7MB at any usable quality. Cover the opening arc (alert -> live AI
+# diagnosis) and let the player carry the rest.
 #
 # The cut point is found in the cast rather than fixed at a percentage: the live
 # AI diagnosis varies in length run to run, so a percentage lands somewhere
 # different every time (36% used to reach the plan table; with a wordier model
-# response it stops short of it). Anchor on the Phase 7 heading instead, which
-# is exactly where the plan table ends.
+# response it stops short of it). Anchor on the Phase 6 heading instead, which
+# is exactly where the diagnosis verdict ends.
+#
+# Phase 6 and not Phase 7: the repo refuses to commit a file over 1MB, and
+# rendering through the plan table costs 1.3MB even at font-size 10 / 4fps,
+# which is past legible. Ending on the diagnosis keeps the part that matters —
+# the model's own root-cause paragraph, which is the whole reason this is
+# recorded live — inside the budget.
 CUT="$(node -e '
 const fs = require("node:fs");
 const lines = fs.readFileSync(process.argv[1], "utf8").trim().split("\n").slice(1);
@@ -142,26 +148,28 @@ for (const line of lines) {
   if (!line.trim()) continue;
   const [interval, code, data] = JSON.parse(line);
   t += interval;
-  if (code === "o" && String(data).replace(/\x1b\[[0-9;]*[A-Za-z]/g, "").includes("Phase 7:")) {
+  if (code === "o" && String(data).replace(/\x1b\[[0-9;]*[A-Za-z]/g, "").includes("Phase 6:")) {
     // A beat past the heading so the transition is visible in the last frame.
     cut = t + 0.8;
     break;
   }
 }
 if (cut === null) {
-  console.error("record-demo: could not find the Phase 7 heading; cannot place the GIF cut");
+  console.error("record-demo: could not find the Phase 6 heading; cannot place the GIF cut");
   process.exit(1);
 }
 process.stdout.write(cut.toFixed(2));
 ' "$CAST")"
 
-# 6fps, not 10: the wider window needed to reach the plan table past a live AI
-# diagnosis renders at 4.4MB at 10fps. 6fps holds it under 3MB and text output
-# stays legible — nothing is lost, the reveal is just less smooth.
+# 2fps, not 6: the window has to span a real 8-20s AI call, and the diagnosis
+# text is expensive to render (6fps costs 2.9MB, 3fps still 1.4MB). At 2fps the
+# GIF lands near 900KB, inside the repo's 1MB commit ceiling. The demo reveals
+# text in bursts and the cast is already re-timed for reading speed, so the
+# frame rate costs smoothness rather than content.
 echo "==> rendering GIF teaser (0..${CUT}s) -> $GIF"
 agg -q \
   --select "0..$CUT" \
-  --fps-cap 6 \
+  --fps-cap 2 \
   --font-size 14 \
   --line-height 1.4 \
   --theme "$THEME" \
@@ -169,10 +177,13 @@ agg -q \
 
 # The teaser is embedded in the landing page, so guard the budget out loud
 # rather than discovering a 5MB GIF in production.
+# 1MB is not a soft budget: the pre-commit hook rejects files above it, so a
+# regression here blocks the commit rather than quietly shipping a heavy page.
 GIF_BYTES="$(wc -c < "$GIF" | tr -d ' ')"
-if [ "$GIF_BYTES" -gt 3145728 ]; then
-  echo "warning: GIF is $((GIF_BYTES / 1024))KiB, over the ~3MB budget." >&2
-  echo "         Lower --fps-cap or --font-size, or shorten the window." >&2
+if [ "$GIF_BYTES" -gt 1048576 ]; then
+  echo "error: GIF is $((GIF_BYTES / 1024))KiB, over the 1MB pre-commit ceiling." >&2
+  echo "       Lower --fps-cap or --font-size, or move the cut anchor earlier." >&2
+  exit 1
 fi
 
 echo
diff --git a/site/assets/demo.gif b/site/assets/demo.gif
new file mode 100644
index 0000000000000000000000000000000000000000..0f2312e514e6c300f143552853ec372bcd2b4a3d
GIT binary patch
literal 927088
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%0AtFEJV~3zR>lXPw$)-
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%0Doyv?<2z<m+4y!7V48
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
Nqg-Y#K?VkH{6CFBqxt{<

literal 0
HcmV?d00001

diff --git a/site/index.html b/site/index.html
index ea1b65d..e9349ea 100644
--- a/site/index.html
+++ b/site/index.html
@@ -935,7 +935,7 @@ <h1>
              markup if the player cannot start, so the GIF lives in exactly one
              place and is never fetched alongside a working player. -->
         <noscript id="terminal-fallback">
-          <img src="assets/demo.gif" alt="Opening excerpt of a terminal recording of `crisismode demo`: a Prometheus PostgresReplicationLagCritical alert selects the postgresql-replication-recovery agent, a live AI diagnosis identifies the scenario as replication_lag_cascade at 78% confidence — a primary-side WAL generation spike putting all three replicas behind the same sent_lsn, worst on 10.0.1.52 — and the agent builds a 10-step recovery plan with per-step risk, blast radius and undo notes, which the framework then begins validating. The excerpt ends at plan validation; the full recording continues through a human approval gate into dry-run execution." style="display: block; width: 100%;">
+          <img src="assets/demo.gif" alt="Opening excerpt of a terminal recording of `crisismode demo`: a Prometheus PostgresReplicationLagCritical alert selects the postgresql-replication-recovery agent, and a live AI diagnosis identifies the scenario as replication_lag_cascade at 78% confidence — a primary-side WAL generation spike putting all three replicas behind the same sent_lsn, worst on 10.0.1.52. The excerpt ends as plan creation begins; the full recording continues through the 10-step recovery plan, its validation, a human approval gate and dry-run execution." style="display: block; width: 100%;">
         </noscript>
       </div>
       <p class="terminal-caption">

From 075a616324950e7b6fffa82153114aed9fa10474 Mon Sep 17 00:00:00 2001
From: trs-80 <109326+trs-80@users.noreply.github.com>
Date: Sun, 9 Aug 2026 12:50:05 -0400
Subject: [PATCH 07/17] fix(ai): bound the last two token budgets and stop
 hiding truncation
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The two call sites left at max_tokens=1024 were measured across 39 live
sonnet-5 calls and set explicitly:

- ai-diagnosis-universal.ts: 4096 / 45s. Measured 1076-1891 tokens and
  10.1-23.4s across the three prompt shapes it builds, so 1024 truncated
  every shape including the simplest question, and the old 15s timeout was
  below the widest shape's 15.4-23.4s.
- ask.ts REPL: 6144 / 45s. Measured 543-3638 tokens and 6.7-37.1s; only the
  first turn ever fit in 1024, and the old 30s was below a long runbook
  session's 29.0-37.1s.

Truncation was also undetectable. callClaude returned only concatenated text
and discarded stop_reason, so a cut-off answer was indistinguishable from a
finished one. A text heuristic is not good enough: in 24 forced-truncation
trials, 2 of 20 truncated answers ended on a period and read as complete.

Adds a strictly additive callClaudeDetailed() returning a typed
{text, stopReason}; callClaude delegates to it, so no existing signature or
behaviour changes. `truncated` is a required field on both result types, and
both ask modes now say plainly that an answer was cut off — verified at the
real CLI, not only in tests.

Also fixes the hermeticity break this new export caused.
ai-timeout-reporting.test.ts mocked ai-client with `{...actual, callClaude}`,
so callClaudeDetailed fell through to a real Anthropic client and the suite
made live authenticated calls (genuine 401s with fresh request_ids). Mocking
@anthropic-ai/sdk itself means no future export can reach the network,
whatever the module mock spreads. Confirmed by re-breaking the spread mock:
2 loud failures and 0 network attempts, against 6 live calls before.

New tests mutation-tested: reverting the fix fails 9 of 17.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 src/__tests__/ai-timeout-reporting.test.ts    |  45 ++-
 .../ai-universal-token-budget.test.ts         | 311 ++++++++++++++++++
 src/__tests__/ask-token-budget.test.ts        | 260 +++++++++++++++
 src/cli/commands/ask.ts                       |  80 ++++-
 src/framework/ai-client.ts                    |  61 +++-
 src/framework/ai-diagnosis-universal.ts       |  55 +++-
 6 files changed, 787 insertions(+), 25 deletions(-)
 create mode 100644 src/__tests__/ai-universal-token-budget.test.ts
 create mode 100644 src/__tests__/ask-token-budget.test.ts

diff --git a/src/__tests__/ai-timeout-reporting.test.ts b/src/__tests__/ai-timeout-reporting.test.ts
index fa6ae31..480d7b4 100644
--- a/src/__tests__/ai-timeout-reporting.test.ts
+++ b/src/__tests__/ai-timeout-reporting.test.ts
@@ -15,11 +15,40 @@ import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { AiTimeoutError } from '../framework/ai-client.js';
 import type * as AiClientModule from '../framework/ai-client.js';
 
-const { callClaudeMock } = vi.hoisted(() => ({ callClaudeMock: vi.fn() }));
+const { callClaudeMock, callClaudeDetailedMock } = vi.hoisted(() => ({
+  callClaudeMock: vi.fn(),
+  callClaudeDetailedMock: vi.fn(),
+}));
+
+/**
+ * Backstop: no test in this file may construct a real Anthropic client.
+ *
+ * The mock below spreads `...actual`, so it only intercepts the exports it
+ * names. When `callClaudeDetailed` was added to ai-client.ts and
+ * ai-diagnosis-universal.ts switched to it, the spread quietly passed the new
+ * export through to the real implementation and two tests here began making
+ * live calls to api.anthropic.com — they still "passed", because a 401 lands in
+ * the same fallback branch a timeout does.
+ *
+ * Naming the new export in the spread fixes today's break; mocking the SDK
+ * itself is what stops the next added export from reopening the hole. Anything
+ * that slips past the spread fails here, loudly and offline, instead of
+ * silently reaching the network.
+ */
+vi.mock('@anthropic-ai/sdk', () => ({
+  default: class {
+    constructor() {
+      throw new Error(
+        'ai-timeout-reporting.test.ts reached a real Anthropic client. ' +
+          'An ai-client.js export is not covered by the mock below.',
+      );
+    }
+  },
+}));
 
 vi.mock('../framework/ai-client.js', async (importOriginal) => {
   const actual = await importOriginal<typeof AiClientModule>();
-  return { ...actual, callClaude: callClaudeMock };
+  return { ...actual, callClaude: callClaudeMock, callClaudeDetailed: callClaudeDetailedMock };
 });
 
 const { aiCallText } = await import('../framework/ai-diagnosis.js');
@@ -40,6 +69,7 @@ describe('AI timeout reporting', () => {
 
   beforeEach(() => {
     callClaudeMock.mockReset();
+    callClaudeDetailedMock.mockReset();
     errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
     originalApiKey = process.env.ANTHROPIC_API_KEY;
     process.env.ANTHROPIC_API_KEY = 'test-key';
@@ -97,17 +127,22 @@ describe('AI timeout reporting', () => {
 
   // The other three reporters were changed in the same pass. Each names its own
   // subject and must still fall back to rules rather than propagate.
+  // universalAiDiagnosis reads stop_reason to tell a truncated answer from a
+  // complete one, so it calls callClaudeDetailed rather than callClaude. Its
+  // 45s deadline is measured, not arbitrary: the widest request this path builds
+  // took 15.4-23.4s against live claude-sonnet-5, so the previous 15s bound
+  // aborted the richest requests. See ai-diagnosis-universal.ts for the figures.
   it('universalAiDiagnosis names the timeout and still falls back', async () => {
-    callClaudeMock.mockRejectedValue(new AiTimeoutError(15_000));
+    callClaudeDetailedMock.mockRejectedValue(new AiTimeoutError(45_000));
 
     const result = await universalAiDiagnosis({ question: 'why is replication lagging?' });
 
-    expect(logged()).toBe('AI diagnosis timed out after 15000ms');
+    expect(logged()).toBe('AI diagnosis timed out after 45000ms');
     expect(result.source).toBe('fallback');
   });
 
   it('universalAiDiagnosis still reports genuine API errors as failures', async () => {
-    callClaudeMock.mockRejectedValue(new Error('overloaded_error'));
+    callClaudeDetailedMock.mockRejectedValue(new Error('overloaded_error'));
 
     const result = await universalAiDiagnosis({ question: 'why is replication lagging?' });
 
diff --git a/src/__tests__/ai-universal-token-budget.test.ts b/src/__tests__/ai-universal-token-budget.test.ts
new file mode 100644
index 0000000..43e87b8
--- /dev/null
+++ b/src/__tests__/ai-universal-token-budget.test.ts
@@ -0,0 +1,311 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 CrisisMode Contributors
+
+/**
+ * Regression: the response budget for `crisismode ask "<question>"`, and the
+ * truncation signal that keeps a cut-off answer from being presented as a
+ * complete one.
+ *
+ * This call site was left at max_tokens=1024 / 15s when the structured-JSON
+ * budgets were fixed (see ai-response-budgets.test.ts), on the reasoning that it
+ * does not parse its response so truncation is merely visible rather than
+ * silent. Live measurement against claude-sonnet-5 on 2026-08-09 showed both
+ * halves of that to be wrong:
+ *
+ *   - 1024 tokens truncated EVERY shape. Even "my postgres is slow" — the
+ *     simplest and most common invocation — measured 1076-1151 output tokens.
+ *   - 15s was below the measured latency of the widest payload (15.4-23.4s),
+ *     so rich requests aborted and degraded to buildFallback().
+ *   - Truncation is not reliably visible. Across 24 forced-truncation trials,
+ *     2 of 20 truncated answers ended on a period and read as finished.
+ *
+ * Every fixture here is a verbatim live capture, so the token counts asserted
+ * are measured facts. No test in this file touches the network.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import type * as AnthropicSdk from '@anthropic-ai/sdk';
+
+const { createMock } = vi.hoisted(() => ({ createMock: vi.fn() }));
+
+vi.mock('@anthropic-ai/sdk', async (importOriginal) => {
+  const actual = await importOriginal<typeof AnthropicSdk>();
+  return {
+    ...actual,
+    default: class {
+      messages = { create: createMock };
+    },
+  };
+});
+
+vi.mock('../framework/network-profile.js', () => ({
+  getNetworkProfile: vi.fn(() => null),
+  isInternetAvailable: vi.fn(() => true),
+}));
+
+import { universalAiDiagnosis } from '../framework/ai-diagnosis-universal.js';
+
+const OLD_MAX_TOKENS = 1024;
+const OLD_TIMEOUT_MS = 15_000;
+
+/**
+ * Verbatim claude-sonnet-5 answer to `ask "my postgres is slow"` (captured
+ * 2026-08-09, max_tokens=8192). The API reported usage.output_tokens = 1076 with
+ * stop_reason=end_turn — past the old 1024 ceiling, so the CLI's single most
+ * common question could never return a whole answer.
+ */
+const QUESTION_ONLY_RESPONSE = `# PostgreSQL Slowness — Triage
+
+**Urgency: HIGH** (until diagnosed — could escalate to CRITICAL if connections are maxing out)
+
+## Step 1: Check what's actually blocking you (30 seconds)
+
+\`\`\`sql
+-- Active queries and how long they've been running
+SELECT pid, now() - query_start AS duration, state, wait_event_type, wait_event, query
+FROM pg_stat_activity
+WHERE state != 'idle'
+ORDER BY duration DESC
+LIMIT 20;
+\`\`\`
+
+Look for:
+- **Long-running queries** (duration > seconds/minutes) → likely culprit
+- **\`wait_event_type = 'Lock'\`** → blocking chain, go to Step 2
+- **Many rows with same query** → connection pool exhaustion or app bug
+
+## Step 2: Check for lock contention
+
+\`\`\`sql
+SELECT blocked_locks.pid AS blocked_pid,
+       blocking_locks.pid AS blocking_pid,
+       blocked_activity.query AS blocked_query,
+       blocking_activity.query AS blocking_query
+FROM pg_catalog.pg_locks blocked_locks
+JOIN pg_catalog.pg_locks blocking_locks
+  ON blocking_locks.locktype = blocked_locks.locktype
+  AND blocking_locks.pid != blocked_locks.pid
+JOIN pg_catalog.pg_stat_activity blocked_activity ON blocked_activity.pid = blocked_locks.pid
+JOIN pg_catalog.pg_stat_activity blocking_activity ON blocking_activity.pid = blocking_locks.pid
+WHERE NOT blocked_locks.granted;
+\`\`\`
+
+If you find a blocker, kill it: \`SELECT pg_cancel_backend(<blocking_pid>);\` (or \`pg_terminate_backend\` if cancel doesn't work).
+
+## Step 3: Connection saturation
+
+\`\`\`sql
+SELECT count(*), state FROM pg_stat_activity GROUP BY state;
+SHOW max_connections;
+\`\`\`
+If \`count(*)\` is near \`max_connections\` → you're connection-starved. Restart app pool or bump \`max_connections\` (requires restart).
+
+## Step 4: Check for bloat / missing autovacuum
+
+\`\`\`sql
+SELECT relname, n_dead_tup, n_live_tup, last_autovacuum
+FROM pg_stat_user_tables
+ORDER BY n_dead_tup DESC LIMIT 10;
+\`\`\`
+High \`n_dead_tup\` and stale \`last_autovacuum\` → manually run \`VACUUM ANALYZE <table>;\` on worst offenders.
+
+## Step 5: Check disk I/O / CPU on host
+
+\`\`\`bash
+iostat -x 2
+top
+\`\`\`
+If disk \`%util\` is pegged → I/O bound, check for competing processes or undersized storage.
+
+## Step 6: Check for missing indexes on slow queries
+
+\`\`\`sql
+EXPLAIN ANALYZE <your slow query>;
+\`\`\`
+Look for \`Seq Scan\` on large tables.
+
+---
+
+**Tell me what you find in Step 1 and I'll narrow it down further** (lock contention vs. resource exhaustion vs. bad query plan all have different fixes).`;
+
+/** usage.output_tokens for QUESTION_ONLY_RESPONSE, stop_reason=end_turn. */
+const QUESTION_ONLY_TOKENS = 1076;
+
+/**
+ * The widest payload callAi assembles (question + health + diagnosis + sentry).
+ * Measured over 6 reps: 1285-1891 output tokens, 15.4-23.4s.
+ */
+const WIDEST_MEASURED_TOKENS = 1891;
+const WIDEST_MEASURED_MS = 23_400;
+
+/**
+ * Verbatim tail of the SAME question asked with max_tokens=1024, the production
+ * value before this fix. The API returned stop_reason=max_tokens at exactly 1024
+ * output tokens, cutting mid-word ("...or bl" — "blocked"). This is what the
+ * operator actually saw.
+ */
+const TRUNCATED_AT_1024 = `## 5. System-level
+\`\`\`bash
+# CPU/IO/mem pressure
+top -o %CPU
+iostat -x 5
+# disk full = silent killer
+df -h $PGDATA
+\`\`\`
+
+## 6. Missing indexes / bad plans
+On the specific slow query:
+\`\`\`sql
+EXPLAIN (ANALYZE, BUFFERS) <your query>;
+\`\`\`
+Look for \`Seq Scan\` on large tables or \`Rows Removed by Filter\` >> rows returned.
+
+---
+**Escalate to CRITICAL if:** disk >90% full, connections maxed, or bl`;
+
+/**
+ * Verbatim tail of a truncated Kafka answer (stop_reason=max_tokens at a 700
+ * ceiling). This is the dangerous case: it ends on a period, mid-list, and reads
+ * like a finished thought. One of 2 such cases in 20 truncated trials.
+ */
+const TRUNCATED_BUT_READS_FINISHED = `- Check if lag is uniform across partitions or skewed to a few:
+\`\`\`bash
+kafka-consumer-groups.sh --describe --group <group>
+\`\`\`
+- Disk I/O saturation on brokers can slow fetch responses.`;
+
+/** Resolve after `ms`, honoring the abort signal the way the real SDK does. */
+function respondAfter(ms: number, text: string, stopReason = 'end_turn') {
+  return (_params: unknown, opts: { signal: AbortSignal }) =>
+    new Promise((resolve, reject) => {
+      const timer = setTimeout(
+        () => resolve({ content: [{ type: 'text', text }], stop_reason: stopReason }),
+        ms,
+      );
+      opts.signal.addEventListener('abort', () => {
+        clearTimeout(timer);
+        reject(new Error('Request was aborted.'));
+      });
+    });
+}
+
+function reply(text: string, stopReason = 'end_turn') {
+  return { content: [{ type: 'text', text }], stop_reason: stopReason };
+}
+
+describe('universalAiDiagnosis response budget', () => {
+  let originalApiKey: string | undefined;
+
+  beforeEach(() => {
+    originalApiKey = process.env.ANTHROPIC_API_KEY;
+    process.env.ANTHROPIC_API_KEY = 'test-key';
+    createMock.mockReset();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    if (originalApiKey !== undefined) {
+      process.env.ANTHROPIC_API_KEY = originalApiKey;
+    } else {
+      delete process.env.ANTHROPIC_API_KEY;
+    }
+  });
+
+  it('asks for more tokens than the widest measured payload needs', async () => {
+    createMock.mockResolvedValue(reply(QUESTION_ONLY_RESPONSE));
+
+    await universalAiDiagnosis({ question: 'my postgres is slow' });
+
+    const [params] = createMock.mock.calls[0]!;
+    expect(params.max_tokens).toBeGreaterThanOrEqual(WIDEST_MEASURED_TOKENS);
+  });
+
+  it('would have truncated even the simplest question at the old 1024 ceiling', () => {
+    // Not a behavioral assertion — a measured fact about the fixture, and the
+    // reason this call site could not be left alone. The shortest real answer
+    // this prompt produces already exceeds the budget it used to be given.
+    expect(QUESTION_ONLY_TOKENS).toBeGreaterThan(OLD_MAX_TOKENS);
+  });
+
+  it('waits past the old 15s deadline for a request that really takes 23.4s', async () => {
+    vi.useFakeTimers();
+    createMock.mockImplementation(respondAfter(WIDEST_MEASURED_MS, QUESTION_ONLY_RESPONSE));
+
+    const pending = universalAiDiagnosis({ question: 'why is redis slow?' });
+    await vi.advanceTimersByTimeAsync(WIDEST_MEASURED_MS);
+
+    expect(WIDEST_MEASURED_MS).toBeGreaterThan(OLD_TIMEOUT_MS);
+    expect((await pending).source).toBe('ai');
+  });
+
+  it('still gives up before the 60s non-interactive bound, because a human typed the command', async () => {
+    vi.useFakeTimers();
+    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    createMock.mockImplementation(respondAfter(55_000, QUESTION_ONLY_RESPONSE));
+
+    const pending = universalAiDiagnosis({ question: 'my postgres is slow' });
+    await vi.advanceTimersByTimeAsync(55_000);
+
+    // 55s is past this call site's deadline: the operator gets guidance rather
+    // than a terminal that sits there for a full minute.
+    expect((await pending).source).toBe('fallback');
+    consoleSpy.mockRestore();
+  });
+
+  it('reports a complete answer as not truncated', async () => {
+    createMock.mockResolvedValue(reply(QUESTION_ONLY_RESPONSE, 'end_turn'));
+
+    const result = await universalAiDiagnosis({ question: 'my postgres is slow' });
+
+    expect(result.source).toBe('ai');
+    expect(result.truncated).toBe(false);
+  });
+
+  it('flags a truncated answer instead of passing it off as whole', async () => {
+    createMock.mockResolvedValue(reply(TRUNCATED_AT_1024, 'max_tokens'));
+
+    const result = await universalAiDiagnosis({ question: 'my postgres is slow' });
+
+    expect(result.source).toBe('ai');
+    expect(result.truncated).toBe(true);
+    // The content is still returned — a partial answer beats no answer, as long
+    // as the caller is told which one it has.
+    expect(result.response).toContain('Missing indexes');
+  });
+
+  it('flags truncation even when the cut-off answer reads as finished', async () => {
+    createMock.mockResolvedValue(reply(TRUNCATED_BUT_READS_FINISHED, 'max_tokens'));
+
+    const result = await universalAiDiagnosis({ question: 'kafka consumer lag keeps growing' });
+
+    // This is the case a text heuristic cannot catch, and the reason the fix
+    // reads stop_reason instead: the response ends on a period, mid-list, and
+    // looks like a complete final bullet.
+    expect(/[.!?]$/.test(result.response)).toBe(true);
+    expect(result.truncated).toBe(true);
+  });
+
+  it('never marks a locally built fallback as truncated', async () => {
+    delete process.env.ANTHROPIC_API_KEY;
+
+    const result = await universalAiDiagnosis({ question: 'my postgres is slow' });
+
+    expect(result.source).toBe('fallback');
+    expect(result.truncated).toBe(false);
+  });
+
+  it('reports a timeout as a fallback rather than an empty answer', async () => {
+    vi.useFakeTimers();
+    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    createMock.mockImplementation(respondAfter(90_000, QUESTION_ONLY_RESPONSE));
+
+    const pending = universalAiDiagnosis({ question: 'my postgres is slow' });
+    await vi.advanceTimersByTimeAsync(90_000);
+    const result = await pending;
+
+    expect(result.source).toBe('fallback');
+    expect(result.truncated).toBe(false);
+    expect(consoleSpy.mock.calls.flat().join(' ')).toMatch(/timed out/);
+    consoleSpy.mockRestore();
+  });
+});
diff --git a/src/__tests__/ask-token-budget.test.ts b/src/__tests__/ask-token-budget.test.ts
new file mode 100644
index 0000000..9aff29f
--- /dev/null
+++ b/src/__tests__/ask-token-budget.test.ts
@@ -0,0 +1,260 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 CrisisMode Contributors
+
+/**
+ * Regression: the `ask` REPL's per-turn response budget, and the truncation
+ * notice both `ask` modes now print.
+ *
+ * The REPL was left at max_tokens=1024 / 30s. Measured against live
+ * claude-sonnet-5 on 2026-08-09 with max_tokens=8192, using this module's real
+ * system prompt and real accumulated history:
+ *
+ *   turn 1, one short question                      543-684 tokens    6.7-11.9s
+ *   turn 4, pasted pg output + "full remediation
+ *     sequence with rollback, in order"            1817-2339 tokens  19.6-26.6s
+ *   turn 9 of a long session, "write me the
+ *     complete runbook for the next shift"         2724-3638 tokens  29.0-37.1s
+ *
+ * Answers grow with the conversation, so only the first turn ever fit in 1024 —
+ * and the long-session runbook, the most valuable output this REPL produces,
+ * exceeded BOTH the token ceiling and the 30s deadline at once.
+ *
+ * No test in this file touches the network.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import type * as AnthropicSdk from '@anthropic-ai/sdk';
+import type * as NodeFs from 'node:fs';
+
+const { createMock, lines } = vi.hoisted(() => ({
+  createMock: vi.fn(),
+  lines: { queue: [] as string[] },
+}));
+
+vi.mock('@anthropic-ai/sdk', async (importOriginal) => {
+  const actual = await importOriginal<typeof AnthropicSdk>();
+  return {
+    ...actual,
+    default: class {
+      messages = { create: createMock };
+    },
+  };
+});
+
+vi.mock('../framework/network-profile.js', () => ({
+  getNetworkProfile: vi.fn(() => null),
+  isInternetAvailable: vi.fn(() => true),
+}));
+
+// Drive the REPL from a scripted line queue instead of stdin. `prompt` and
+// `close` are no-ops; the async iterator is what the read loop consumes.
+vi.mock('node:readline', () => ({
+  createInterface: () => ({
+    prompt: () => {},
+    close: () => {},
+    async *[Symbol.asyncIterator]() {
+      for (const line of lines.queue) yield line;
+    },
+  }),
+}));
+
+// Keep the REPL hermetic: without this it would pick up a real
+// ~/.crisismode/watch-state.json on a developer machine but not in CI.
+vi.mock('node:fs', async (importOriginal) => {
+  const actual = await importOriginal<typeof NodeFs>();
+  return { ...actual, existsSync: () => false, default: { ...actual, existsSync: () => false } };
+});
+
+import { runAsk, runAskRepl } from '../cli/commands/ask.js';
+
+const OLD_MAX_TOKENS = 1024;
+const OLD_TIMEOUT_MS = 30_000;
+
+/** Measured maximum for a long-session runbook request: 3638 tokens, 37.1s. */
+const RUNBOOK_MEASURED_TOKENS = 3638;
+const RUNBOOK_MEASURED_MS = 37_100;
+
+/** Measured for turn 4 (pasted output + full remediation sequence). */
+const TURN4_MEASURED_TOKENS = 2339;
+
+/**
+ * Verbatim shape of a truncated REPL answer that ends on a period and reads as
+ * finished — the failure a text heuristic cannot detect. Captured at
+ * stop_reason=max_tokens in the 24-trial truncation run.
+ */
+const TRUNCATED_BUT_READS_FINISHED =
+  'Check whether the pooler is leaking connections:\n' +
+  '```sql\nSELECT count(*), state FROM pg_stat_activity GROUP BY state;\n```\n' +
+  '- If idle-in-transaction dominates (connection leak), restart the offending service/pod rather than the DB.';
+
+const COMPLETE_ANSWER =
+  'HIGH urgency. Start by separating "cannot keep up" from "cannot receive":\n' +
+  '```sql\nSELECT client_addr, write_lag, replay_lag FROM pg_stat_replication;\n```\n' +
+  'Report back what that shows and I will narrow it down.';
+
+function reply(text: string, stopReason = 'end_turn') {
+  return { content: [{ type: 'text', text }], stop_reason: stopReason };
+}
+
+function respondAfter(ms: number, text: string, stopReason = 'end_turn') {
+  return (_params: unknown, opts: { signal: AbortSignal }) =>
+    new Promise((resolve, reject) => {
+      const timer = setTimeout(
+        () => resolve({ content: [{ type: 'text', text }], stop_reason: stopReason }),
+        ms,
+      );
+      opts.signal.addEventListener('abort', () => {
+        clearTimeout(timer);
+        reject(new Error('Request was aborted.'));
+      });
+    });
+}
+
+describe('ask REPL response budget', () => {
+  let originalApiKey: string | undefined;
+  let logged: string[];
+
+  beforeEach(() => {
+    originalApiKey = process.env.ANTHROPIC_API_KEY;
+    process.env.ANTHROPIC_API_KEY = 'test-key';
+    createMock.mockReset();
+    lines.queue = [];
+    logged = [];
+    vi.spyOn(console, 'log').mockImplementation((...args: unknown[]) => {
+      logged.push(args.join(' '));
+    });
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+    if (originalApiKey !== undefined) {
+      process.env.ANTHROPIC_API_KEY = originalApiKey;
+    } else {
+      delete process.env.ANTHROPIC_API_KEY;
+    }
+  });
+
+  it('asks for more tokens than the longest measured REPL answer needs', async () => {
+    lines.queue = ['my postgres replica is lagging', '/exit'];
+    createMock.mockResolvedValue(reply(COMPLETE_ANSWER));
+
+    await runAskRepl();
+
+    const [params] = createMock.mock.calls[0]!;
+    expect(params.max_tokens).toBeGreaterThanOrEqual(RUNBOOK_MEASURED_TOKENS);
+    // And well past the ceiling that truncated every turn after the first.
+    expect(params.max_tokens).toBeGreaterThan(OLD_MAX_TOKENS);
+    expect(TURN4_MEASURED_TOKENS).toBeGreaterThan(OLD_MAX_TOKENS);
+  });
+
+  it('waits past the old 30s deadline for a runbook that really takes 37s', async () => {
+    vi.useFakeTimers();
+    lines.queue = ['write me the complete runbook for the next shift', '/exit'];
+    createMock.mockImplementation(respondAfter(RUNBOOK_MEASURED_MS, COMPLETE_ANSWER));
+
+    const pending = runAskRepl();
+    await vi.advanceTimersByTimeAsync(RUNBOOK_MEASURED_MS);
+    await pending;
+
+    expect(RUNBOOK_MEASURED_MS).toBeGreaterThan(OLD_TIMEOUT_MS);
+    expect(logged.join('\n')).toContain('HIGH urgency');
+  });
+
+  it('reports an honest timeout rather than hanging an operator indefinitely', async () => {
+    vi.useFakeTimers();
+    lines.queue = ['write me an exhaustive runbook', '/exit'];
+    createMock.mockImplementation(respondAfter(90_000, COMPLETE_ANSWER));
+
+    const pending = runAskRepl();
+    await vi.advanceTimersByTimeAsync(90_000);
+    await pending;
+
+    // printWarning goes through console.log, so the REPL's error branch is here.
+    expect(logged.join('\n')).toMatch(/timed out after 45000ms/);
+  });
+
+  it('tells the operator when a REPL answer is cut off', async () => {
+    lines.queue = ['give me the full remediation sequence', '/exit'];
+    createMock.mockResolvedValue(reply(TRUNCATED_BUT_READS_FINISHED, 'max_tokens'));
+
+    await runAskRepl();
+    const out = logged.join('\n');
+
+    // The answer ends on a period and reads as complete — nothing in the text
+    // marks it as partial, so the notice is the only signal the operator gets.
+    expect(TRUNCATED_BUT_READS_FINISHED.endsWith('.')).toBe(true);
+    expect(out).toContain('cut off');
+    expect(out).toContain('continue');
+  });
+
+  it('stays quiet about truncation when the answer is complete', async () => {
+    lines.queue = ['my postgres replica is lagging', '/exit'];
+    createMock.mockResolvedValue(reply(COMPLETE_ANSWER, 'end_turn'));
+
+    await runAskRepl();
+
+    expect(logged.join('\n')).not.toContain('cut off');
+  });
+
+  it('keeps a truncated answer in history so "continue" has something to resume', async () => {
+    lines.queue = ['give me the full remediation sequence', 'continue', '/exit'];
+    createMock
+      .mockResolvedValueOnce(reply(TRUNCATED_BUT_READS_FINISHED, 'max_tokens'))
+      .mockResolvedValueOnce(reply('...and then restart the pooler.', 'end_turn'));
+
+    await runAskRepl();
+
+    const [secondParams] = createMock.mock.calls[1]!;
+    const assistantTurns = secondParams.messages.filter(
+      (m: { role: string }) => m.role === 'assistant',
+    );
+    expect(assistantTurns).toHaveLength(1);
+    expect(assistantTurns[0].content).toBe(TRUNCATED_BUT_READS_FINISHED);
+  });
+});
+
+describe('ask single-shot truncation notice', () => {
+  let originalApiKey: string | undefined;
+  let logged: string[];
+
+  beforeEach(() => {
+    originalApiKey = process.env.ANTHROPIC_API_KEY;
+    process.env.ANTHROPIC_API_KEY = 'test-key';
+    createMock.mockReset();
+    logged = [];
+    vi.spyOn(console, 'log').mockImplementation((...args: unknown[]) => {
+      logged.push(args.join(' '));
+    });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    if (originalApiKey !== undefined) {
+      process.env.ANTHROPIC_API_KEY = originalApiKey;
+    } else {
+      delete process.env.ANTHROPIC_API_KEY;
+    }
+  });
+
+  it('says the answer is cut off instead of printing it as if it were whole', async () => {
+    createMock.mockResolvedValue(reply(TRUNCATED_BUT_READS_FINISHED, 'max_tokens'));
+
+    await runAsk('my database connections are maxed out');
+    const out = logged.join('\n');
+
+    expect(out).toContain(TRUNCATED_BUT_READS_FINISHED);
+    expect(out).toContain('cut off');
+    expect(out).toContain('narrower');
+  });
+
+  it('prints nothing extra for a complete answer', async () => {
+    createMock.mockResolvedValue(reply(COMPLETE_ANSWER, 'end_turn'));
+
+    await runAsk('my postgres replica is lagging');
+    const out = logged.join('\n');
+
+    expect(out).toContain('HIGH urgency');
+    expect(out).not.toContain('cut off');
+  });
+});
diff --git a/src/cli/commands/ask.ts b/src/cli/commands/ask.ts
index 846aef6..05239a5 100644
--- a/src/cli/commands/ask.ts
+++ b/src/cli/commands/ask.ts
@@ -19,7 +19,7 @@ import { getNetworkProfile } from '../../framework/network-profile.js';
 import { printBanner, printInfo, printWarning } from '../output.js';
 import { missingEnvVar } from '../errors.js';
 import { defaultAiModel } from '../../framework/ai-model.js';
-import { callClaude } from '../../framework/ai-client.js';
+import { callClaudeDetailed } from '../../framework/ai-client.js';
 
 // ── Types ──
 
@@ -33,10 +33,48 @@ interface ReplContext {
   systemContext: string[];
 }
 
+/** One completed REPL exchange. `truncated` is required so the render path cannot ignore it. */
+interface ReplTurn {
+  text: string;
+  truncated: boolean;
+}
+
 const DEFAULT_MODEL = defaultAiModel();
-const DEFAULT_TIMEOUT_MS = 30_000;
 const MAX_HISTORY_TURNS = 20;
 
+/**
+ * Response budget for a REPL turn.
+ *
+ * Measured against live claude-sonnet-5 on 2026-08-09 with max_tokens=8192 so
+ * the numbers are natural response lengths, using this module's real system
+ * prompt and real accumulated history:
+ *
+ *   turn 1, one short question              543-684 tokens    6.7-11.9s
+ *   turn 4, operator pasted pg output and
+ *     asked for a full remediation sequence 1817-2339 tokens  19.6-26.6s
+ *   turn 9 of a long session, "write me the
+ *     complete runbook for the next shift"  2724-3638 tokens  29.0-37.1s
+ *
+ * Answers grow with the conversation, which is the point of a REPL that keeps
+ * MAX_HISTORY_TURNS of context — so the first turn is the least informative
+ * case to size against. At 1024 tokens every turn past the first was truncated,
+ * and the old 30s deadline sat below the measured 29.0-37.1s of a long session,
+ * so the runbook request — the most valuable thing this REPL does — could fail
+ * both ways at once.
+ *
+ * 45s is 1.2x the measured 37.1s worst case. It is deliberately no longer: a
+ * human is sitting at a prompt with no streaming and no spinner, and past this
+ * point an honest AiTimeoutError beats continued silence.
+ *
+ * 6144 is 1.7x the measured 3638-token maximum, and intentionally above what
+ * 45s can deliver at the ~95 tokens/s observed here (~4300 tokens). That
+ * asymmetry is the safer failure: an answer that genuinely runs longer than the
+ * deadline surfaces as a reported timeout rather than as a runbook that ends
+ * halfway through a step an operator is about to execute.
+ */
+const RESPONSE_MAX_TOKENS = 6144;
+const RESPONSE_TIMEOUT_MS = 45_000;
+
 const SYSTEM_PROMPT = `You are an infrastructure recovery specialist embedded in the CrisisMode CLI tool. You're in a multi-turn diagnostic conversation with an operator who may be dealing with a live incident.
 
 Guidelines:
@@ -73,6 +111,15 @@ export async function runAsk(question: string): Promise<void> {
     printWarning('AI diagnosis unavailable. Showing basic guidance.');
     console.log(result.response);
   }
+
+  if (result.truncated) {
+    console.log('');
+    printWarning(
+      'This answer is cut off — it hit the response length limit, so the last point above is incomplete.',
+    );
+    printInfo('Ask a narrower question to get a complete answer.');
+  }
+
   console.log('');
 }
 
@@ -135,10 +182,17 @@ export async function runAskRepl(): Promise<void> {
 
     // Send question to AI with conversation history
     try {
-      const response = await sendWithHistory(ctx, input);
+      const turn = await sendWithHistory(ctx, input);
       console.log('');
-      console.log(response);
+      console.log(turn.text);
       console.log('');
+      if (turn.truncated) {
+        printWarning(
+          'This answer is cut off — it hit the response length limit, so the last point above is incomplete.',
+        );
+        printInfo('Type "continue" to pick up where it stopped, or ask something narrower.');
+        console.log('');
+      }
     } catch (err) {
       printWarning(`AI error: ${err instanceof Error ? err.message : String(err)}`);
     }
@@ -185,7 +239,7 @@ function handleReplCommand(input: string, ctx: ReplContext): 'exit' | 'handled'
 
 // ── AI conversation ──
 
-async function sendWithHistory(ctx: ReplContext, question: string): Promise<string> {
+async function sendWithHistory(ctx: ReplContext, question: string): Promise<ReplTurn> {
   const sanitized = sanitizeInput(question);
 
   ctx.history.push({ role: 'user', content: sanitized });
@@ -211,18 +265,26 @@ async function sendWithHistory(ctx: ReplContext, question: string): Promise<stri
   }));
 
   try {
-    const text = await callClaude({
+    const { text, stopReason } = await callClaudeDetailed({
       system: systemParts.join('\n'),
       messages,
       model: DEFAULT_MODEL,
-      maxTokens: 1024,
-      timeoutMs: DEFAULT_TIMEOUT_MS,
+      maxTokens: RESPONSE_MAX_TOKENS,
+      timeoutMs: RESPONSE_TIMEOUT_MS,
       apiKey: process.env.ANTHROPIC_API_KEY!,
     });
 
     const trimmed = text.trim();
+
+    // The partial answer still goes into history: it is what the model actually
+    // said, and keeping it is what makes "continue" a working follow-up rather
+    // than a request the model has no context for.
     ctx.history.push({ role: 'assistant', content: trimmed });
-    return trimmed;
+
+    // stop_reason, not a text heuristic — 2 of 20 truncated responses in a live
+    // 24-trial run ended on a period and read as finished. Guessing from the
+    // text would hand an operator a half-written runbook as if it were whole.
+    return { text: trimmed, truncated: stopReason === 'max_tokens' };
   } catch (err) {
     // Remove the user message that failed
     ctx.history.pop();
diff --git a/src/framework/ai-client.ts b/src/framework/ai-client.ts
index 9731c95..0b029ee 100644
--- a/src/framework/ai-client.ts
+++ b/src/framework/ai-client.ts
@@ -69,6 +69,34 @@ export interface ClaudeMessage {
   content: string;
 }
 
+/**
+ * Why the model stopped generating.
+ *
+ * Modelled as a union rather than a passed-through string so a call site that
+ * compares against a typo (`'max-tokens'`) fails to compile instead of silently
+ * never matching. `null` is what the SDK reports for a non-streaming response
+ * with no stop reason.
+ *
+ * Only `'max_tokens'` currently matters to callers: it is the one value that
+ * means the returned text is an incomplete prefix of the real answer.
+ */
+export type ClaudeStopReason =
+  | 'end_turn'
+  | 'max_tokens'
+  | 'stop_sequence'
+  | 'tool_use'
+  | 'pause_turn'
+  | 'refusal'
+  | 'model_context_window_exceeded'
+  | null;
+
+export interface CallClaudeResult {
+  /** Concatenated text of all text content blocks. NOT trimmed. */
+  text: string;
+  /** Why generation stopped. `'max_tokens'` means `text` is truncated. */
+  stopReason: ClaudeStopReason;
+}
+
 export interface CallClaudeOptions {
   /** System prompt. */
   system: string;
@@ -92,10 +120,32 @@ export interface CallClaudeOptions {
  * The returned string is NOT trimmed — callers that need trimming apply it,
  * matching pre-consolidation behavior byte-for-byte.
  *
+ * Callers that render the text to a human should prefer
+ * {@link callClaudeDetailed}: this signature discards `stop_reason`, so a
+ * response truncated at `maxTokens` is indistinguishable from a complete one.
+ *
  * @throws if no API key is available, {@link AiTimeoutError} on timeout, or the
  * underlying SDK error on API failure.
  */
 export async function callClaude(opts: CallClaudeOptions): Promise<string> {
+  return (await callClaudeDetailed(opts)).text;
+}
+
+/**
+ * Same call as {@link callClaude}, but also reports why generation stopped.
+ *
+ * Exists because truncation is otherwise invisible. When the model hits
+ * `maxTokens` the API still returns HTTP 200 with a well-formed partial
+ * response, so a caller holding only the text cannot tell a complete answer
+ * from a prefix of one. That is tolerable for callers that parse JSON (the
+ * parse throws) but not for callers that print prose straight to an operator:
+ * across 24 live forced-truncation trials, 2 of 20 truncated answers ended on a
+ * period and read as finished, so no text heuristic can close the gap.
+ *
+ * @throws if no API key is available, {@link AiTimeoutError} on timeout, or the
+ * underlying SDK error on API failure.
+ */
+export async function callClaudeDetailed(opts: CallClaudeOptions): Promise<CallClaudeResult> {
   const apiKey = opts.apiKey ?? process.env.ANTHROPIC_API_KEY;
   if (!apiKey) {
     throw new Error(
@@ -131,10 +181,13 @@ export async function callClaude(opts: CallClaudeOptions): Promise<string> {
       { signal: controller.signal },
     );
 
-    return response.content
-      .filter((block) => block.type === 'text')
-      .map((block) => ('text' in block ? block.text : ''))
-      .join('');
+    return {
+      text: response.content
+        .filter((block) => block.type === 'text')
+        .map((block) => ('text' in block ? block.text : ''))
+        .join(''),
+      stopReason: response.stop_reason,
+    };
   } catch (err) {
     // The signal, not the error shape, is the reliable witness: the SDK's abort
     // error is named "Error" and says only "Request was aborted.". Nothing else
diff --git a/src/framework/ai-diagnosis-universal.ts b/src/framework/ai-diagnosis-universal.ts
index e72d277..1a8ecf3 100644
--- a/src/framework/ai-diagnosis-universal.ts
+++ b/src/framework/ai-diagnosis-universal.ts
@@ -9,7 +9,7 @@
  * timeout-protected, graceful fallback.
  *
  * Safety:
- * - 15s timeout via AbortController
+ * - Bounded timeout via AbortController (see RESPONSE_TIMEOUT_MS)
  * - Input sanitization via framework AI toolkit
  * - Advisory only — never executes commands
  */
@@ -20,10 +20,37 @@ import type { DiagnosisResult } from '../types/diagnosis-result.js';
 import type { HealthAssessment } from '../types/health.js';
 import type { SentryEnrichment } from '../integrations/sentry.js';
 import { defaultAiModel } from './ai-model.js';
-import { AiTimeoutError, callClaude } from './ai-client.js';
+import { AiTimeoutError, callClaudeDetailed } from './ai-client.js';
 
 const DEFAULT_MODEL = defaultAiModel();
-const DEFAULT_TIMEOUT_MS = 15_000;
+
+/**
+ * Response budget for `crisismode ask "<question>"`, this module's only caller.
+ *
+ * Measured against live claude-sonnet-5 on 2026-08-09 with max_tokens=8192, so
+ * every figure is a natural response length rather than a clipped one. Three
+ * request shapes this module actually assembles, 3 reps each, plus 3 extra reps
+ * of the widest:
+ *
+ *   question only ("my postgres is slow")  1076-1151 tokens   10.1-11.7s
+ *   structured health+diagnosis, no question 1202-1254 tokens 14.6-15.7s
+ *   question+health+diagnosis+sentry (n=6) 1285-1891 tokens   15.4-23.4s
+ *
+ * So BOTH previous budgets were wrong, not just the token one. At 1024 tokens
+ * even the simplest question — the single most common invocation of this CLI —
+ * truncated on every call, confirmed by a forced-truncation run that came back
+ * stop_reason=max_tokens and cut mid-word ("...or bl"). And 15s sat below the
+ * measured 15.4-23.4s of the widest shape, so the richest requests aborted and
+ * degraded to buildFallback().
+ *
+ * 4096 is 2.2x the measured 1891-token maximum. 45s is 1.9x the measured 23.4s
+ * and matches the ~85 tokens/s observed here, so the deadline and the ceiling
+ * are reachable together rather than one masking the other. It stays under the
+ * 60s non-interactive bound in ai-client.ts on purpose: an operator typed this
+ * command and is watching a terminal with no progress output.
+ */
+const RESPONSE_MAX_TOKENS = 4096;
+const RESPONSE_TIMEOUT_MS = 45_000;
 
 export interface UniversalDiagnosisRequest {
   /** Free-form question from the user. */
@@ -39,6 +66,15 @@ export interface UniversalDiagnosisRequest {
 export interface UniversalDiagnosisResult {
   response: string;
   source: 'ai' | 'fallback';
+  /**
+   * True when the model hit RESPONSE_MAX_TOKENS and `response` is a prefix of
+   * the real answer rather than the whole thing.
+   *
+   * Required, not optional: a caller that renders `response` must not be able
+   * to forget that it might be half an answer. Always false for fallbacks,
+   * which are locally generated and complete by construction.
+   */
+  truncated: boolean;
 }
 
 const SYSTEM_PROMPT = `You are an infrastructure recovery specialist embedded in the CrisisMode CLI tool. Your job is to help operators understand what's wrong with their systems and what to do about it.
@@ -119,16 +155,20 @@ async function callAi(
 
   const userMessage = sanitizeInput(parts.join('\n\n'));
 
-  const text = await callClaude({
+  const { text, stopReason } = await callClaudeDetailed({
     system: SYSTEM_PROMPT,
     user: userMessage,
     model: DEFAULT_MODEL,
-    maxTokens: 1024,
-    timeoutMs: DEFAULT_TIMEOUT_MS,
+    maxTokens: RESPONSE_MAX_TOKENS,
+    timeoutMs: RESPONSE_TIMEOUT_MS,
     apiKey,
   });
 
-  return { response: text.trim(), source: 'ai' };
+  // Report truncation from stop_reason rather than inferring it from the text.
+  // A cut answer frequently reads as a finished one: in 24 live trials, 2 of 20
+  // truncated responses ended on a period, so "does it end mid-sentence?" would
+  // present a partial diagnosis as complete roughly 1 time in 10.
+  return { response: text.trim(), source: 'ai', truncated: stopReason === 'max_tokens' };
 }
 
 function buildFallback(request: UniversalDiagnosisRequest): UniversalDiagnosisResult {
@@ -169,5 +209,6 @@ function buildFallback(request: UniversalDiagnosisRequest): UniversalDiagnosisRe
   return {
     response: parts.join('\n') || 'Set ANTHROPIC_API_KEY for AI-powered diagnosis, or run `crisismode diagnose` for automated checks.',
     source: 'fallback',
+    truncated: false,
   };
 }

From 42312ca7078824038c8b3b30da34c8abe1dc3931 Mon Sep 17 00:00:00 2001
From: trs-80 <109326+trs-80@users.noreply.github.com>
Date: Sun, 9 Aug 2026 12:50:21 -0400
Subject: [PATCH 08/17] fix(cli): make init --plugin canonical and reject
 unsafe plugin names
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`init --agent <name>` scaffolds a CHECK PLUGIN, not an agent. In a codebase
where "agent" is a distinct core concept (RecoveryAgent, src/agent/*,
AgentManifest), the flag actively misled — the help text even read
`init --agent <name>   Scaffold a check plugin`, contradicting itself.

`--plugin` is now canonical. `--agent` still works as a deprecated alias with
a one-line stderr notice, and `--plugin` wins if both are passed, so no
existing user breaks. Help text, the scan hint and all three completion
scripts now agree with the real surface.

Two latent bugs in the same path, found while fixing it:

- a valueless `--plugin`/`--agent` crashed with a raw internal error; it is
  now a usage error exiting 1
- a name like `../../evil` scaffolded OUTSIDE checks/ — path traversal via an
  unvalidated directory name. Names are now restricted to letters, digits,
  ".", "_" and "-", exiting 1 on anything else.

Also drops `init --agent` from the `--local` documentation row, since init
never honored `--local`.

Verified at the real CLI after a build: traversal exits 1, valueless exits 1,
the deprecated alias exits 0 and warns.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 src/__tests__/completions.test.ts      |   2 +-
 src/__tests__/init-plugin-flag.test.ts | 208 +++++++++++++++++++++++++
 src/cli/commands/completions.ts        |   6 +-
 src/cli/commands/init.ts               |  65 +++++++-
 src/cli/commands/scan.ts               |   2 +-
 src/cli/index.ts                       |  17 +-
 6 files changed, 289 insertions(+), 11 deletions(-)
 create mode 100644 src/__tests__/init-plugin-flag.test.ts

diff --git a/src/__tests__/completions.test.ts b/src/__tests__/completions.test.ts
index 1416628..b722837 100644
--- a/src/__tests__/completions.test.ts
+++ b/src/__tests__/completions.test.ts
@@ -83,7 +83,7 @@ describe('Shell completions (6.2)', () => {
     expect(output).toContain('--execute');
     expect(output).toContain('--health-only');
     expect(output).toContain('--interval');
-    expect(output).toContain('--agent');
+    expect(output).toContain('--plugin');
   });
 
   it('zsh completions include descriptions', async () => {
diff --git a/src/__tests__/init-plugin-flag.test.ts b/src/__tests__/init-plugin-flag.test.ts
new file mode 100644
index 0000000..2db3f7e
--- /dev/null
+++ b/src/__tests__/init-plugin-flag.test.ts
@@ -0,0 +1,208 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 CrisisMode Contributors
+
+/**
+ * `crisismode init` scaffolds a *check plugin*, never a RecoveryAgent, so
+ * `--plugin <name>` is the canonical flag. `--agent <name>` is kept working as a
+ * deprecated alias for users who already scripted it.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mkdtempSync, rmSync, existsSync, readFileSync, statSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { parseArgs } from 'node:util';
+import { fileURLToPath } from 'node:url';
+import { runInit } from '../cli/commands/init.js';
+import { configure } from '../cli/output.js';
+
+const INDEX_SOURCE = readFileSync(fileURLToPath(new URL('../cli/index.ts', import.meta.url)), 'utf-8');
+const SCAN_SOURCE = readFileSync(
+  fileURLToPath(new URL('../cli/commands/scan.ts', import.meta.url)),
+  'utf-8',
+);
+const COMPLETIONS_SOURCE = readFileSync(
+  fileURLToPath(new URL('../cli/commands/completions.ts', import.meta.url)),
+  'utf-8',
+);
+
+describe('crisismode init — plugin scaffolding flags', () => {
+  let tmpDir: string;
+  let origCwd: string;
+  let stderr: string[];
+  let stdout: string[];
+
+  beforeEach(() => {
+    origCwd = process.cwd();
+    tmpDir = mkdtempSync(join(tmpdir(), 'crisismode-init-'));
+    process.chdir(tmpDir);
+    stderr = [];
+    stdout = [];
+    vi.spyOn(process.stderr, 'write').mockImplementation((chunk: unknown) => {
+      stderr.push(String(chunk));
+      return true;
+    });
+    vi.spyOn(console, 'log').mockImplementation((...args: unknown[]) => {
+      stdout.push(args.map(String).join(' '));
+    });
+    configure({ noColor: true });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    process.chdir(origCwd);
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  function pluginFiles(name: string): { manifest: string; script: string } {
+    return {
+      manifest: join(tmpDir, 'checks', name, 'manifest.json'),
+      script: join(tmpDir, 'checks', name, 'check.sh'),
+    };
+  }
+
+  it('scaffolds a check plugin with the canonical --plugin flag', async () => {
+    await runInit(undefined, { plugin: 'my-check' });
+
+    const { manifest, script } = pluginFiles('my-check');
+    expect(existsSync(manifest)).toBe(true);
+    expect(existsSync(script)).toBe(true);
+    expect(JSON.parse(readFileSync(manifest, 'utf-8')).name).toBe('my-check');
+    // Executable bit — the runner spawns check.sh directly.
+    expect(statSync(script).mode & 0o111).not.toBe(0);
+  });
+
+  it('prints no deprecation notice for --plugin', async () => {
+    await runInit(undefined, { plugin: 'my-check' });
+    expect(stderr.join('')).toBe('');
+  });
+
+  it('still scaffolds with the deprecated --agent alias', async () => {
+    await runInit(undefined, { agent: 'legacy-check' });
+
+    const { manifest, script } = pluginFiles('legacy-check');
+    expect(existsSync(manifest)).toBe(true);
+    expect(existsSync(script)).toBe(true);
+    expect(JSON.parse(readFileSync(manifest, 'utf-8')).name).toBe('legacy-check');
+  });
+
+  it('warns on --agent and points at --plugin', async () => {
+    await runInit(undefined, { agent: 'legacy-check' });
+
+    const notice = stderr.join('');
+    expect(notice).toContain('--agent is deprecated');
+    expect(notice).toContain('crisismode init --plugin legacy-check');
+    // One line, not a paragraph.
+    expect(notice.trimEnd().split('\n')).toHaveLength(1);
+  });
+
+  it('prefers --plugin over --agent when both are given, and says so', async () => {
+    await runInit(undefined, { plugin: 'canonical', agent: 'legacy' });
+
+    expect(existsSync(pluginFiles('canonical').manifest)).toBe(true);
+    expect(existsSync(pluginFiles('legacy').manifest)).toBe(false);
+    expect(stderr.join('')).toContain('scaffolding --plugin canonical and ignoring --agent legacy');
+  });
+
+  it('scaffolds once when both flags name the same plugin', async () => {
+    await runInit(undefined, { plugin: 'same', agent: 'same' });
+
+    expect(existsSync(pluginFiles('same').manifest)).toBe(true);
+    expect(stderr.join('')).toContain('--agent is deprecated');
+  });
+
+  it('rejects a valueless --plugin with a usage error instead of scaffolding', async () => {
+    // `strict: false` parses a bare `--plugin` as boolean true.
+    await expect(runInit(undefined, { plugin: true })).rejects.toThrow(
+      'crisismode init --plugin my-check',
+    );
+    expect(existsSync(join(tmpDir, 'checks'))).toBe(false);
+    expect(existsSync(join(tmpDir, 'crisismode.yaml'))).toBe(false);
+  });
+
+  it('rejects a valueless --agent with a usage error', async () => {
+    await expect(runInit(undefined, { agent: true })).rejects.toThrow(
+      'crisismode init --agent my-check',
+    );
+    expect(existsSync(join(tmpDir, 'checks'))).toBe(false);
+  });
+
+  it('rejects a plugin name that would escape checks/', async () => {
+    await expect(runInit(undefined, { plugin: '../../evil' })).rejects.toThrow('Invalid plugin name');
+    expect(existsSync(join(tmpDir, 'checks'))).toBe(false);
+  });
+
+  it('still generates crisismode.yaml when neither flag is given', async () => {
+    await runInit();
+
+    expect(existsSync(join(tmpDir, 'crisismode.yaml'))).toBe(true);
+    expect(existsSync(join(tmpDir, 'checks'))).toBe(false);
+    expect(stderr.join('')).toBe('');
+  });
+});
+
+describe('crisismode init — CLI flag registration', () => {
+  // Mirrors the string-valued flags registered in src/cli/index.ts. Registration
+  // matters: under `strict: false` an *unregistered* `--plugin foo` would be
+  // parsed as a boolean and `foo` would fall through to the positional path
+  // argument, silently writing a config file named "foo".
+  const parseOpts = {
+    options: {
+      plugin: { type: 'string' as const },
+      agent: { type: 'string' as const },
+    },
+    allowPositionals: true,
+    strict: false,
+  };
+
+  it('parses --plugin as a string value, not a positional', () => {
+    const { values, positionals } = parseArgs({ ...parseOpts, args: ['--plugin', 'my-check'] });
+    expect(values.plugin).toBe('my-check');
+    expect(positionals).toEqual([]);
+  });
+
+  it('parses the deprecated --agent as a string value', () => {
+    const { values, positionals } = parseArgs({ ...parseOpts, args: ['--agent', 'legacy-check'] });
+    expect(values.agent).toBe('legacy-check');
+    expect(positionals).toEqual([]);
+  });
+
+  it('registers both flags in the real parseArgs config', () => {
+    expect(INDEX_SOURCE).toContain('plugin: { type: \'string\' }');
+    expect(INDEX_SOURCE).toContain('agent: { type: \'string\' }');
+  });
+
+  it('forwards both flags from the init route to runInit', () => {
+    expect(INDEX_SOURCE).toContain('plugin: values.plugin as string | boolean | undefined');
+    expect(INDEX_SOURCE).toContain('agent: values.agent as string | boolean | undefined');
+  });
+});
+
+describe('crisismode init — documented surface matches the real one', () => {
+  it('help text advertises --plugin for scaffolding', () => {
+    expect(INDEX_SOURCE).toContain('crisismode init --plugin <name>');
+    expect(INDEX_SOURCE).toMatch(/--plugin <name>\s+Scaffold a new check plugin \(init only\)/);
+  });
+
+  it('help text never describes --agent as the way to scaffold a plugin', () => {
+    expect(INDEX_SOURCE).not.toContain('init --agent');
+    expect(INDEX_SOURCE).not.toMatch(/--agent <name>\s+Scaffold/);
+  });
+
+  it('help text marks --agent as a deprecated alias', () => {
+    expect(INDEX_SOURCE).toMatch(/--agent <name>\s+Deprecated alias for --plugin/);
+  });
+
+  it('the empty-plugin scan hint suggests the canonical flag', () => {
+    expect(SCAN_SOURCE).toContain('crisismode init --plugin my-check');
+    expect(SCAN_SOURCE).not.toContain('init --agent');
+  });
+
+  it('shell completions offer --plugin for init', () => {
+    expect(COMPLETIONS_SOURCE).toContain('--plugin --json --no-color -h --help');
+    expect(COMPLETIONS_SOURCE).toContain("'--plugin[Scaffold a new check plugin]:plugin name'");
+    expect(COMPLETIONS_SOURCE).toContain(
+      "__fish_seen_subcommand_from init' -l plugin -d 'Scaffold a new check plugin' -r",
+    );
+  });
+});
diff --git a/src/cli/commands/completions.ts b/src/cli/commands/completions.ts
index 374845f..790685e 100644
--- a/src/cli/commands/completions.ts
+++ b/src/cli/commands/completions.ts
@@ -52,7 +52,7 @@ _crisismode_completions() {
       COMPREPLY=( $(compgen -W "--config --terse --json --no-color --verbose -h --help" -- "\${cur}") )
       ;;
     init)
-      COMPREPLY=( $(compgen -W "--agent --json --no-color -h --help" -- "\${cur}") )
+      COMPREPLY=( $(compgen -W "--plugin --json --no-color -h --help" -- "\${cur}") )
       ;;
     demo)
       COMPREPLY=( $(compgen -W "--json --no-color -h --help" -- "\${cur}") )
@@ -178,7 +178,7 @@ _crisismode() {
           ;;
         init)
           _arguments \\
-            '--agent[Scaffold a new check plugin]:agent name' \\
+            '--plugin[Scaffold a new check plugin]:plugin name' \\
             '--json[Machine-readable JSON output]' \\
             '--no-color[Disable colored output]' \\
             {-h,--help}'[Show help]'
@@ -267,7 +267,7 @@ complete -c crisismode -n '__fish_seen_subcommand_from recover' -l execute     -
 complete -c crisismode -n '__fish_seen_subcommand_from recover' -l health-only -d 'Health check only, no diagnosis'
 
 # init
-complete -c crisismode -n '__fish_seen_subcommand_from init' -l agent -d 'Scaffold a new check plugin' -r
+complete -c crisismode -n '__fish_seen_subcommand_from init' -l plugin -d 'Scaffold a new check plugin' -r
 
 # webhook
 complete -c crisismode -n '__fish_seen_subcommand_from webhook' -l execute -d 'Enable mutations'
diff --git a/src/cli/commands/init.ts b/src/cli/commands/init.ts
index a11608b..93126d6 100644
--- a/src/cli/commands/init.ts
+++ b/src/cli/commands/init.ts
@@ -11,9 +11,68 @@ import { generateTemplate } from '../../config/init.js';
 import { printSuccess, printInfo } from '../output.js';
 import type { CheckPluginManifest } from '../../framework/check-plugin.js';
 
-export async function runInit(outputPath?: string, agentName?: string): Promise<void> {
-  if (agentName) {
-    await scaffoldCheckPlugin(agentName);
+export interface InitOptions {
+  /**
+   * `--plugin <name>` — canonical flag: scaffold a check plugin. Typed loosely
+   * because the CLI parses with `strict: false`, where a valueless `--plugin`
+   * arrives as `true` rather than a name.
+   */
+  plugin?: string | boolean | undefined;
+  /**
+   * `--agent <name>` — deprecated alias for `--plugin`, kept working for
+   * existing users. It never scaffolded a RecoveryAgent (`src/agent/*`); the
+   * name misled about what the command creates.
+   */
+  agent?: string | boolean | undefined;
+}
+
+/** Plugin names become a directory under `checks/`, so keep them path-safe. */
+const PLUGIN_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+
+function pluginNameFrom(flag: 'plugin' | 'agent', value: string | boolean | undefined): string | undefined {
+  if (value === undefined || value === false) return undefined;
+  if (typeof value !== 'string' || value.trim() === '') {
+    throw new Error(`--${flag} requires a plugin name, e.g. crisismode init --${flag} my-check`);
+  }
+  if (!PLUGIN_NAME_PATTERN.test(value)) {
+    throw new Error(
+      `Invalid plugin name "${value}". Use letters, digits, ".", "_", or "-" — the name becomes a directory under checks/.`,
+    );
+  }
+  return value;
+}
+
+/**
+ * Deprecation notices go to stderr, not stdout: they describe how the command
+ * was invoked rather than what it produced, so they stay out of piped output
+ * and are never swallowed the way `printWarning` is in machine mode.
+ */
+function printDeprecation(msg: string): void {
+  process.stderr.write(`  ! ${msg}\n`);
+}
+
+export async function runInit(outputPath?: string, options: InitOptions = {}): Promise<void> {
+  const plugin = pluginNameFrom('plugin', options.plugin);
+  const agent = pluginNameFrom('agent', options.agent);
+
+  if (agent) {
+    // `--plugin` wins when both are given — the canonical flag is the one the
+    // user is being pointed at, so honoring it keeps the two invocations from
+    // disagreeing about which name gets scaffolded.
+    if (plugin && plugin !== agent) {
+      printDeprecation(
+        `--agent is deprecated; scaffolding --plugin ${plugin} and ignoring --agent ${agent}.`,
+      );
+    } else {
+      printDeprecation(
+        `--agent is deprecated and will be removed in a future release. Use: crisismode init --plugin ${agent}`,
+      );
+    }
+  }
+
+  const pluginName = plugin ?? agent;
+  if (pluginName) {
+    await scaffoldCheckPlugin(pluginName);
     return;
   }
 
diff --git a/src/cli/commands/scan.ts b/src/cli/commands/scan.ts
index d55460d..e08b6d2 100644
--- a/src/cli/commands/scan.ts
+++ b/src/cli/commands/scan.ts
@@ -571,7 +571,7 @@ export async function runScan(opts: ScanOptions): Promise<ScanResult> {
 
   // Hint about check plugins when none are discovered
   if (healthPlugins.length === 0) {
-    printInfo('No check plugins found. Add custom checks in ./checks/ or scaffold one with: crisismode init --agent my-check');
+    printInfo('No check plugins found. Add custom checks in ./checks/ or scaffold one with: crisismode init --plugin my-check');
   }
 
   return result;
diff --git a/src/cli/index.ts b/src/cli/index.ts
index 623941d..01b714a 100644
--- a/src/cli/index.ts
+++ b/src/cli/index.ts
@@ -35,7 +35,7 @@ const HELP = `
     crisismode down [<service>...]          Is <service> down, or is it just me? (exit 0/1/2; bare form checks configured services)
     crisismode readiness                    Scale-readiness report (read-only, will-it-break-under-load)
     crisismode init [path]                  Generate crisismode.yaml
-    crisismode init --agent <name>          Scaffold a check plugin
+    crisismode init --plugin <name>         Scaffold a check plugin
     crisismode demo                         Run simulator demo
     crisismode webhook [options]            Start webhook receiver
     crisismode ask "<question>"             Natural language AI diagnosis
@@ -56,7 +56,9 @@ const HELP = `
     crisismode mcp                         Start MCP server on stdio (read-only diagnosis tools)
 
   Options:
-    --agent <name>      Scaffold a new check plugin (init only)
+    --plugin <name>     Scaffold a new check plugin (init only)
+    --agent <name>      Deprecated alias for --plugin (init only); --plugin wins
+                        if both are given
     --config <path>     Path to crisismode.yaml
     --target <name>     Target name from config
     --category <kinds>  Comma-separated service kinds to scan (scan only)
@@ -89,6 +91,9 @@ async function main(): Promise<void> {
         config: { type: 'string' },
         target: { type: 'string' },
         category: { type: 'string' },
+        plugin: { type: 'string' },
+        // Deprecated alias for --plugin; registered so it still consumes its
+        // value instead of being swallowed by `strict: false`.
         agent: { type: 'string' },
         execute: { type: 'boolean', default: false },
         'health-only': { type: 'boolean', default: false },
@@ -208,7 +213,13 @@ async function main(): Promise<void> {
 
     case 'init': {
       const { runInit } = await import('./commands/init.js');
-      await runInit(positionals[0], values.agent as string | undefined);
+      await runInit(positionals[0], {
+        // Passed through as parsed: under `strict: false` a valueless
+        // `--plugin`/`--agent` arrives as `true`, which runInit rejects with a
+        // usage error instead of treating it as a name.
+        plugin: values.plugin as string | boolean | undefined,
+        agent: values.agent as string | boolean | undefined,
+      });
       break;
     }
 

From 5a72496e71d9e46d8187a77b8b7a3082f9ce253c Mon Sep 17 00:00:00 2001
From: trs-80 <109326+trs-80@users.noreply.github.com>
Date: Sun, 9 Aug 2026 12:50:40 -0400
Subject: [PATCH 09/17] test: cover the AI recovery paths and enforce
 plan-fixture safety
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Codecov flagged 9 uncovered lines in the token/timeout fix, concentrated in
the new error-recovery code — exactly the paths that must not rot silently.

Coverage across the five affected files goes from 85.93% to 99.74% lines and
78.49% to 98.56% branches, prioritising this PR's new behaviour over raw
percentage: escapeControlCharsInStrings escape-tracking through \" and \\,
the \uXXXX fallback, and the retry-once contract proved by spying on
JSON.parse (1 call when already valid, 1 when the repair is a no-op and
rethrows, 2 when the repair runs and must still throw).

Two assumptions in the brief were wrong and are corrected here: diagnoseCommandFor
and root-cause-synthesis's stripCodeFence were already covered, and ai-client's
110/136 are ternary arms rather than the abort path, which was also already
covered. The 9 missing incident-summary lines were all printIncidentSummary.
Four lines stay uncovered deliberately — two are genuinely unreachable, two are
pre-existing cosmetic string arms not worth contorting a fixture for.

Separately, the elevated-risk fixture in ai-response-budgets.test.ts violated
this repo's own safety contract. It could not even be validated (TypeError in
validator.ts at the missing requiredCapabilities), and once runnable it failed
TWO checks: state preservation AND human notification for elevated+ plans. A
fixture that breaks the safety rules teaches the wrong shape to anyone who
copies it.

Swept all 11 test files in scope: 2 plan fixtures, 3 violations total, all
fixed, plus a `command: 'shell'` that is not a member of the Command union. No
deliberately-invalid negative tests were touched. Adds a mechanical test that
runs every plan fixture through the real validator, so future validator rules
apply automatically instead of waiting for a reviewer.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 src/__tests__/ai-client.test.ts               |  24 +
 .../ai-diagnosis-response-recovery.test.ts    | 392 +++++++++++++
 src/__tests__/ai-explainer-fallback.test.ts   | 486 ++++++++++++++++
 src/__tests__/ai-explainer-plan-fixtures.ts   |  80 +++
 src/__tests__/ai-response-budgets.test.ts     |  96 +++-
 src/__tests__/incident-summary-print.test.ts  | 163 ++++++
 src/__tests__/incident-summary.test.ts        |  28 +
 .../root-cause-synthesis-ai-path.test.ts      | 523 ++++++++++++++++++
 8 files changed, 1787 insertions(+), 5 deletions(-)
 create mode 100644 src/__tests__/ai-diagnosis-response-recovery.test.ts
 create mode 100644 src/__tests__/ai-explainer-fallback.test.ts
 create mode 100644 src/__tests__/ai-explainer-plan-fixtures.ts
 create mode 100644 src/__tests__/incident-summary-print.test.ts
 create mode 100644 src/__tests__/root-cause-synthesis-ai-path.test.ts

diff --git a/src/__tests__/ai-client.test.ts b/src/__tests__/ai-client.test.ts
index 887f724..3a7c797 100644
--- a/src/__tests__/ai-client.test.ts
+++ b/src/__tests__/ai-client.test.ts
@@ -93,6 +93,30 @@ describe('callClaude', () => {
     expect(params.model).toBe('claude-test');
   });
 
+  /**
+   * Neither `messages` nor `user` set. This is a caller bug, and the point of
+   * pinning it is that `callClaude` does not paper over it with an invented
+   * prompt: it sends one empty user turn, which the API rejects, so the mistake
+   * surfaces at the call site instead of producing a confident answer to a
+   * question nobody asked.
+   */
+  it('sends a single empty user turn when neither user nor messages is given', async () => {
+    createMock.mockResolvedValue({ content: [{ type: 'text', text: 'ok' }] });
+
+    await callClaude({ system: 'sys', apiKey: 'test-key' });
+
+    const [params] = createMock.mock.calls[0]!;
+    expect(params.messages).toEqual([{ role: 'user', content: '' }]);
+  });
+
+  it('returns an empty string when the model replies with no text blocks', async () => {
+    // A stop-at-tool-use or otherwise text-free reply must not throw here; the
+    // JSON-parsing callers turn the empty string into their own fallback.
+    createMock.mockResolvedValue({ content: [] });
+
+    expect(await callClaude({ system: 'sys', user: 'hi', apiKey: 'test-key' })).toBe('');
+  });
+
   it('throws with a clear message when no API key is available', async () => {
     delete process.env.ANTHROPIC_API_KEY;
     await expect(callClaude({ system: 'sys', user: 'hi' })).rejects.toThrow(/API key/i);
diff --git a/src/__tests__/ai-diagnosis-response-recovery.test.ts b/src/__tests__/ai-diagnosis-response-recovery.test.ts
new file mode 100644
index 0000000..af59c0b
--- /dev/null
+++ b/src/__tests__/ai-diagnosis-response-recovery.test.ts
@@ -0,0 +1,392 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 CrisisMode Contributors
+
+/**
+ * The error-recovery paths of the AI diagnosis toolkit.
+ *
+ * `ai-diagnosis-token-budget.test.ts` covers the budget itself (max_tokens and
+ * timeoutMs large enough that a real diagnosis arrives whole). This file covers
+ * what happens when a response arrives anyway malformed: the in-string control
+ * character repair added alongside the budget fix, and the two `catch` blocks
+ * that must turn a bad response into a clean `null` so the caller falls back to
+ * its rule-based path instead of throwing mid-crisis.
+ *
+ * That recovery code is only ever exercised when the AI misbehaves, so nothing
+ * in normal operation would notice it rotting — which is exactly why it is
+ * pinned here. Every test is hermetic: the SDK is mocked and the network
+ * profile is written directly, so no test touches the network.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import type * as AnthropicSdk from '@anthropic-ai/sdk';
+import type { NetworkProfile } from '@crisismode/agent-sdk';
+import {
+  aiCallText,
+  aiDiagnose,
+  parseStandardDiagnosisResponse,
+} from '../framework/ai-diagnosis.js';
+import { resetNetworkProfile, setNetworkProfile } from '../framework/network-profile.js';
+
+const { createMock } = vi.hoisted(() => ({ createMock: vi.fn() }));
+
+vi.mock('@anthropic-ai/sdk', async (importOriginal) => {
+  const actual = await importOriginal<typeof AnthropicSdk>();
+  return {
+    ...actual,
+    default: class {
+      messages = { create: createMock };
+    },
+  };
+});
+
+// ─────────────────────────────────────────────────────────────────────────
+// In-string control character repair
+// ─────────────────────────────────────────────────────────────────────────
+
+describe('parseStandardDiagnosisResponse — control character repair', () => {
+  /**
+   * The repair tracks in-string state, so it has to honor backslash escapes:
+   * if it treated the `\"` inside a string value as the closing quote, it would
+   * be "outside a string" for the rest of the body and would then escape the
+   * STRUCTURAL newlines between JSON tokens, producing `{\n` outside a string —
+   * still unparseable, just failing differently. This fixture puts an escaped
+   * quote and an escaped backslash before the raw newline it has to repair, so
+   * a tracker that loses its place fails the test rather than silently working
+   * for simpler inputs.
+   */
+  it('keeps its place through escaped quotes and backslashes while repairing', () => {
+    const withEscapesAndRawNewline = [
+      '{',
+      '  "status": "identified",',
+      '  "scenario": "wal_generation_spike",',
+      '  "confidence": 0.7,',
+      '  "root_cause": "The primary logged \\"could not fork worker\\" repeatedly.',
+      'Replay is not paused.",',
+      '  "findings": [',
+      '    {',
+      '      "source": "logs",',
+      '      "observation": "Archive dir C:\\\\pgdata\\\\pg_wal is full.",',
+      '      "severity": "critical",',
+      '      "evidence": "df reports 100%"',
+      '    }',
+      '  ],',
+      '  "recommendations": ["Free space on the archive volume"]',
+      '}',
+    ].join('\n');
+
+    // Precondition: the raw newline really is the only defect.
+    expect(() => JSON.parse(withEscapesAndRawNewline)).toThrow(/control character/i);
+
+    const result = parseStandardDiagnosisResponse(withEscapesAndRawNewline);
+
+    expect(result.scenario).toBe('wal_generation_spike');
+    // The escaped quote survived as a real quote, not as a lost string boundary.
+    expect(result.findings[0]?.data?.root_cause).toBe(
+      'The primary logged "could not fork worker" repeatedly.\nReplay is not paused.',
+    );
+    // The escaped backslashes survived as single backslashes.
+    expect(result.findings[0]?.observation).toBe('Archive dir C:\\pgdata\\pg_wal is full.');
+  });
+
+  /**
+   * \n \r \t \b \f have short JSON escapes; every other C0 control character
+   * has to go out as a \uXXXX sequence. Nothing maps 0x01, so this exercises
+   * the fallback arm of the escape lookup.
+   */
+  it('escapes a control character with no short JSON escape as \\uXXXX', () => {
+    const withUnitSeparator =
+      '{"status":"identified","scenario":"pipe\u0001delimited","confidence":0.5,"findings":[]}';
+
+    expect(() => JSON.parse(withUnitSeparator)).toThrow(/control character/i);
+
+    const result = parseStandardDiagnosisResponse(withUnitSeparator);
+    expect(result.scenario).toBe('pipe\u0001delimited');
+  });
+
+  /**
+   * The repair must be reached only after a real parse failure. A well-formed
+   * response has to be parsed on the first attempt and handed back untouched —
+   * rewriting it would be a needless second pass over every AI response on the
+   * happy path.
+   */
+  it('does not touch a response that already parses', () => {
+    const valid = JSON.stringify({
+      status: 'identified',
+      scenario: 'replication_lag',
+      confidence: 0.9,
+      root_cause: 'line one\nline two with a "quote"\tand a tab',
+      findings: [{ source: 'pg_stat_replication', observation: 'lagging', severity: 'warning' }],
+    });
+
+    const parseSpy = vi.spyOn(JSON, 'parse');
+    try {
+      const result = parseStandardDiagnosisResponse(valid);
+
+      expect(parseSpy).toHaveBeenCalledTimes(1);
+      expect(result.findings[0]?.data?.root_cause).toBe(
+        'line one\nline two with a "quote"\tand a tab',
+      );
+    } finally {
+      parseSpy.mockRestore();
+    }
+  });
+
+  /**
+   * When there is nothing to repair the original error must propagate, not a
+   * second confusing one from the repaired copy — the caller's contract is
+   * "throw and I will fall back", and the message it logs should describe the
+   * response it actually received.
+   */
+  it('rethrows the original error when the repair changes nothing', () => {
+    // Truncated mid-object: no in-string control characters, so the repaired
+    // copy is identical to the input and the first error is rethrown.
+    const truncated = '{"status": "identified", "findings": [{"source": "pg';
+
+    const parseSpy = vi.spyOn(JSON, 'parse');
+    try {
+      expect(() => parseStandardDiagnosisResponse(truncated)).toThrow(SyntaxError);
+      // One attempt only: the repair was a no-op, so no second parse was tried.
+      expect(parseSpy).toHaveBeenCalledTimes(1);
+    } finally {
+      parseSpy.mockRestore();
+    }
+  });
+
+  /**
+   * A response that has BOTH a control character and a structural defect gets
+   * two parse attempts and still throws. This is the "repair did not help"
+   * case — it must fail, not return a half-read diagnosis.
+   */
+  it('still throws when the repair runs but does not make the response valid', () => {
+    // Raw newline inside a string value AND the object is never closed.
+    const irreparable = '{"status":"identified","root_cause":"first line\nsecond line", "findings"';
+
+    const parseSpy = vi.spyOn(JSON, 'parse');
+    try {
+      expect(() => parseStandardDiagnosisResponse(irreparable)).toThrow(SyntaxError);
+      expect(parseSpy).toHaveBeenCalledTimes(2);
+    } finally {
+      parseSpy.mockRestore();
+    }
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────────
+// Field-level defaults
+// ─────────────────────────────────────────────────────────────────────────
+
+describe('parseStandardDiagnosisResponse — field defaults', () => {
+  it('fills in missing finding fields rather than emitting undefined', () => {
+    const result = parseStandardDiagnosisResponse('{"status":"identified","findings":[{}]}');
+
+    expect(result.findings).toHaveLength(1);
+    expect(result.findings[0]).toMatchObject({
+      source: 'ai_analysis',
+      observation: '',
+      severity: 'info',
+    });
+  });
+
+  it('downgrades a severity the schema does not define to info', () => {
+    const result = parseStandardDiagnosisResponse(
+      '{"status":"identified","findings":[{"source":"s","observation":"o","severity":"catastrophic"}]}',
+    );
+
+    expect(result.findings[0]?.severity).toBe('info');
+  });
+
+  it('defaults confidence and scenario when the model omits them', () => {
+    const result = parseStandardDiagnosisResponse('{"status":"partial","findings":[]}');
+
+    expect(result.confidence).toBe(0.5);
+    expect(result.scenario).toBeNull();
+    expect(result.status).toBe('partial');
+  });
+
+  it('clamps a confidence outside 0-1', () => {
+    expect(parseStandardDiagnosisResponse('{"confidence":4.2,"findings":[]}').confidence).toBe(1);
+    expect(parseStandardDiagnosisResponse('{"confidence":-3,"findings":[]}').confidence).toBe(0);
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────────
+// aiCallText / aiDiagnose failure handling
+// ─────────────────────────────────────────────────────────────────────────
+
+function offlineProfile(): NetworkProfile {
+  const checkedAt = '2026-08-09T12:00:00.000Z';
+  return {
+    internet: { status: 'unavailable', probes: [], checkedAt },
+    hub: { status: 'unknown', probes: [], checkedAt },
+    targets: { status: 'available', probes: [], checkedAt },
+    dns: { available: false, latencyMs: 0 },
+    mode: 'private_only',
+    profiledAt: checkedAt,
+  };
+}
+
+describe('aiCallText / aiDiagnose failure handling', () => {
+  let originalApiKey: string | undefined;
+  let errorSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    originalApiKey = process.env.ANTHROPIC_API_KEY;
+    process.env.ANTHROPIC_API_KEY = 'test-key';
+    createMock.mockReset();
+    resetNetworkProfile();
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    errorSpy.mockRestore();
+    resetNetworkProfile();
+    if (originalApiKey !== undefined) {
+      process.env.ANTHROPIC_API_KEY = originalApiKey;
+    } else {
+      delete process.env.ANTHROPIC_API_KEY;
+    }
+  });
+
+  it('returns null without an API key and never reaches the SDK', async () => {
+    delete process.env.ANTHROPIC_API_KEY;
+
+    expect(await aiCallText('sys', 'state')).toBeNull();
+    expect(await aiDiagnose({ systemPrompt: 'sys', userMessage: 'state' })).toBeNull();
+    expect(createMock).not.toHaveBeenCalled();
+  });
+
+  /**
+   * The offline gate: when the startup probe says there is no internet, the
+   * toolkit must not spend a 60s timeout discovering that. `triage` writes the
+   * same cached profile, so this is the path an air-gapped spoke takes.
+   */
+  it('returns null when the network profile reports no internet', async () => {
+    setNetworkProfile(offlineProfile());
+
+    expect(await aiCallText('sys', 'state')).toBeNull();
+    expect(await aiDiagnose({ systemPrompt: 'sys', userMessage: 'state' })).toBeNull();
+    expect(createMock).not.toHaveBeenCalled();
+  });
+
+  it('reports an API failure and returns null instead of throwing', async () => {
+    createMock.mockRejectedValue(new Error('overloaded_error'));
+
+    expect(await aiCallText('sys', 'state')).toBeNull();
+    expect(errorSpy).toHaveBeenCalledWith('AI call failed:', 'overloaded_error');
+  });
+
+  /**
+   * Not everything thrown is an Error — an SDK or transport layer can reject
+   * with a bare value, and the handler has to log something useful rather than
+   * `undefined` from reading `.message` off a string.
+   */
+  it('logs a non-Error rejection as-is', async () => {
+    const thrown: unknown = 'socket hang up';
+    createMock.mockRejectedValue(thrown);
+
+    expect(await aiCallText('sys', 'state')).toBeNull();
+    expect(errorSpy).toHaveBeenCalledWith('AI call failed:', 'socket hang up');
+  });
+
+  /**
+   * The end-to-end shape of the bug this PR fixed: the call succeeds, the body
+   * is unparseable, and the agent must get a clean null (its cue to fall back)
+   * plus a log line naming the parse failure — the signal whose absence made
+   * the truncation bug look like "AI is unavailable".
+   */
+  it('returns null and names the parse failure when the response is not JSON', async () => {
+    createMock.mockResolvedValue({
+      content: [{ type: 'text', text: 'I could not determine the root cause.' }],
+    });
+
+    const result = await aiDiagnose({ systemPrompt: 'sys', userMessage: 'state' });
+
+    expect(result).toBeNull();
+    expect(errorSpy).toHaveBeenCalledWith(
+      'AI diagnosis response could not be parsed:',
+      expect.stringMatching(/JSON|Unexpected/i),
+    );
+  });
+
+  it('returns null when a truncated response reaches the parser', async () => {
+    createMock.mockResolvedValue({
+      content: [{ type: 'text', text: '{"status":"identified","root_cause":"The primary is ou' }],
+    });
+
+    expect(await aiDiagnose({ systemPrompt: 'sys', userMessage: 'state' })).toBeNull();
+    expect(errorSpy).toHaveBeenCalledWith(
+      'AI diagnosis response could not be parsed:',
+      expect.any(String),
+    );
+  });
+
+  it('returns null when a caller-supplied parser throws', async () => {
+    createMock.mockResolvedValue({ content: [{ type: 'text', text: 'anything' }] });
+
+    const result = await aiDiagnose({
+      systemPrompt: 'sys',
+      userMessage: 'state',
+      parseResponse: () => {
+        throw new Error('custom parser rejected the shape');
+      },
+    });
+
+    expect(result).toBeNull();
+    expect(errorSpy).toHaveBeenCalledWith(
+      'AI diagnosis response could not be parsed:',
+      'custom parser rejected the shape',
+    );
+  });
+
+  it('logs a non-Error thrown by a caller-supplied parser as-is', async () => {
+    createMock.mockResolvedValue({ content: [{ type: 'text', text: 'anything' }] });
+    const thrown: unknown = 'parser exploded';
+
+    const result = await aiDiagnose({
+      systemPrompt: 'sys',
+      userMessage: 'state',
+      parseResponse: () => {
+        throw thrown;
+      },
+    });
+
+    expect(result).toBeNull();
+    expect(errorSpy).toHaveBeenCalledWith(
+      'AI diagnosis response could not be parsed:',
+      'parser exploded',
+    );
+  });
+
+  /**
+   * The repair is wired into the real call path, not just the exported parser:
+   * a live response with a raw newline inside a string value has to come back
+   * as a diagnosis, which is the run the demo recording lost.
+   */
+  it('recovers a live response whose only defect is a raw newline', async () => {
+    const raw = [
+      '{"status":"identified","scenario":"replication_lag_cascade","confidence":0.74,',
+      '"root_cause":"The primary is outrunning the replicas.',
+      'Replay is not paused.",',
+      '"findings":[{"source":"pg_stat_replication","observation":"lag 342s","severity":"critical"}],',
+      '"recommendations":["Check WAL generation rate"]}',
+    ].join('\n');
+    createMock.mockResolvedValue({ content: [{ type: 'text', text: raw }] });
+
+    const result = await aiDiagnose({ systemPrompt: 'sys', userMessage: 'state' });
+
+    expect(result?.scenario).toBe('replication_lag_cascade');
+    expect(result?.confidence).toBeCloseTo(0.74);
+    expect(errorSpy).not.toHaveBeenCalled();
+  });
+
+  it('strips a code fence the model wrapped around the diagnosis', async () => {
+    const fenced =
+      '```json\n{"status":"identified","scenario":"slot_exhaustion","confidence":0.6,"findings":[]}\n```';
+    createMock.mockResolvedValue({ content: [{ type: 'text', text: fenced }] });
+
+    const result = await aiDiagnose({ systemPrompt: 'sys', userMessage: 'state' });
+
+    expect(result?.scenario).toBe('slot_exhaustion');
+    expect(errorSpy).not.toHaveBeenCalled();
+  });
+});
diff --git a/src/__tests__/ai-explainer-fallback.test.ts b/src/__tests__/ai-explainer-fallback.test.ts
new file mode 100644
index 0000000..35ef21b
--- /dev/null
+++ b/src/__tests__/ai-explainer-fallback.test.ts
@@ -0,0 +1,486 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 CrisisMode Contributors
+
+/**
+ * `explainPlan`'s degradation paths.
+ *
+ * `ai-response-budgets.test.ts` pins the budget (enough tokens and time for the
+ * real explanation to arrive). This file pins what the operator gets when it
+ * does not: the structural fallback, and the response-shape defaults that keep
+ * a partially-shaped AI reply usable instead of throwing.
+ *
+ * That matters because the fallback is indistinguishable from a real answer in
+ * the terminal apart from `source`. The truncation bug this arc fixed was
+ * exactly that failure — a fallback presented as an explanation — so the
+ * fallback itself has to stay correct and complete for every step type.
+ *
+ * Hermetic: the SDK is mocked and the network profile is written directly.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import type * as AnthropicSdk from '@anthropic-ai/sdk';
+import type { NetworkProfile } from '@crisismode/agent-sdk';
+import { explainPlan } from '../framework/ai-explainer.js';
+import { validatePlan } from '../framework/validator.js';
+import { safetyManifestFor } from './ai-explainer-plan-fixtures.js';
+import { resetNetworkProfile, setNetworkProfile } from '../framework/network-profile.js';
+import type { RecoveryPlan } from '../types/recovery-plan.js';
+import type { DiagnosisResult } from '../types/diagnosis-result.js';
+
+const { createMock } = vi.hoisted(() => ({ createMock: vi.fn() }));
+
+vi.mock('@anthropic-ai/sdk', async (importOriginal) => {
+  const actual = await importOriginal<typeof AnthropicSdk>();
+  return {
+    ...actual,
+    default: class {
+      messages = { create: createMock };
+    },
+  };
+});
+
+const DIAGNOSIS: DiagnosisResult = {
+  status: 'identified',
+  scenario: 'replication_lag_cascade',
+  confidence: 0.78,
+  findings: [],
+  diagnosticPlanNeeded: false,
+};
+
+/**
+ * One step of every type, so the fallback's switch is exercised end to end.
+ *
+ * Contract-compliant as well as complete: the elevated-risk `system_action`
+ * carries `statePreservation.before` captures and the plan carries a
+ * `human_notification`, per CLAUDE.md's safety rules and
+ * src/framework/validator.ts. `explainPlan` never validates what it is handed,
+ * so `passes the real plan validator` below is what keeps that true — a plan
+ * fixture with one step of every type is the one most likely to be copied as a
+ * starting point, which makes being wrong here expensive.
+ *
+ * The trailing cast covers only plan-envelope fields nothing here reads
+ * (agentName, createdAt, affectedSystems, ...).
+ */
+function makeAllStepTypesPlan(overrides: Partial<RecoveryPlan> = {}): RecoveryPlan {
+  return {
+    planId: 'rp-fallback-001',
+    metadata: {
+      scenario: 'replication_lag_cascade',
+      summary: 'Resync the lagging replica',
+      estimatedDuration: 'PT15M',
+    },
+    steps: [
+      {
+        stepId: 'step-001',
+        type: 'diagnosis_action',
+        name: 'Assess replication lag',
+        executionContext: 'postgresql_read',
+        target: 'prod-db-primary',
+        // No `operation`: the AI prompt builder has to tolerate a command that
+        // only names its type.
+        command: { type: 'sql' },
+      },
+      {
+        stepId: 'step-002',
+        type: 'human_notification',
+        name: 'Page the on-call DBA',
+        recipients: [{ role: 'dba-oncall', urgency: 'high' }],
+        message: {
+          summary: 'Replication recovery starting',
+          detail: 'The lagging replica will be disconnected and resynced.',
+          actionRequired: false,
+        },
+        channel: 'slack',
+      },
+      {
+        stepId: 'step-003',
+        type: 'checkpoint',
+        name: 'Pre-recovery checkpoint',
+        stateCaptures: [
+          {
+            name: 'replication_state',
+            captureType: 'sql_query',
+            statement: 'SELECT * FROM pg_stat_replication;',
+            captureCost: 'negligible',
+            capturePolicy: 'required',
+          },
+          {
+            name: 'replication_slots',
+            captureType: 'sql_query',
+            statement: 'SELECT * FROM pg_replication_slots;',
+            captureCost: 'negligible',
+            capturePolicy: 'required',
+          },
+        ],
+      },
+      {
+        stepId: 'step-004',
+        type: 'system_action',
+        name: 'Disconnect the lagging replica',
+        executionContext: 'postgresql_write',
+        target: 'prod-db-primary',
+        riskLevel: 'elevated',
+        requiredCapabilities: ['db.replica.disconnect'],
+        command: { type: 'sql', operation: 'SELECT pg_terminate_backend(pid)' },
+        // Required at elevated risk or higher: the pre-mutation snapshot is
+        // what a rollback and the forensic trail are reconstructed from.
+        statePreservation: {
+          before: [
+            {
+              name: 'replication_state_snapshot',
+              captureType: 'sql_query',
+              statement: 'SELECT * FROM pg_stat_replication;',
+              captureCost: 'negligible',
+              capturePolicy: 'required',
+              retention: 'P30D',
+            },
+          ],
+          after: [
+            {
+              name: 'replication_state_post_disconnect',
+              captureType: 'sql_query',
+              statement: 'SELECT * FROM pg_stat_replication;',
+              captureCost: 'negligible',
+              capturePolicy: 'best_effort',
+              retention: 'P30D',
+            },
+          ],
+        },
+        blastRadius: {
+          directComponents: ['pg-replica-52', 'read-pool'],
+          indirectComponents: ['reporting-jobs'],
+          maxImpact: 'single_replica_disconnected',
+          cascadeRisk: 'low',
+        },
+      },
+      {
+        stepId: 'step-005',
+        type: 'human_approval',
+        name: 'Approve resynchronization',
+        approvers: [{ role: 'dba-oncall', required: true }],
+        requiredApprovals: 1,
+        presentation: { summary: 'Rebuild replica 10.0.1.52 from a base backup?' },
+        timeout: 'PT10M',
+        timeoutAction: 'escalate',
+      },
+      {
+        stepId: 'step-006',
+        type: 'replanning_checkpoint',
+        name: 'Reassess before rebuild',
+        fastReplan: true,
+        replanTimeout: 'PT30S',
+      },
+      {
+        stepId: 'step-007',
+        type: 'conditional',
+        name: 'Restore traffic if healthy',
+        condition: { description: 'replica lag below 10s' },
+        thenStep: {
+          stepId: 'step-007-then',
+          type: 'human_notification',
+          name: 'Confirm the replica is serving reads again',
+          recipients: [{ role: 'dba-oncall', urgency: 'low' }],
+          message: {
+            summary: 'Replica 10.0.1.52 is back in the read pool',
+            detail: 'Lag is below the 10s threshold and traffic has been restored.',
+            actionRequired: false,
+          },
+          channel: 'slack',
+        },
+        elseStep: 'skip',
+      },
+      {
+        stepId: 'step-008',
+        type: 'system_action',
+        name: 'Reattach the replica to the read pool',
+        executionContext: 'load_balancer',
+        target: 'read-pool',
+        riskLevel: 'routine',
+        requiredCapabilities: ['traffic.backend.attach'],
+        // No `operation` — the prompt builder must not emit a trailing space.
+        command: { type: 'configuration_change' },
+        statePreservation: { before: [], after: [] },
+        blastRadius: {
+          directComponents: ['pgbouncer'],
+          indirectComponents: [],
+          maxImpact: 'read_pool_membership_changed',
+          cascadeRisk: 'none',
+        },
+      },
+    ],
+    rollbackStrategy: {
+      type: 'stepwise',
+      description: 'Undo each completed step in reverse order.',
+    },
+    impact: {
+      dataLossRisk: 'none',
+      estimatedUserImpact: 'Read queries may be slower',
+    },
+    ...overrides,
+  } as unknown as RecoveryPlan;
+}
+
+function offlineProfile(): NetworkProfile {
+  const checkedAt = '2026-08-09T12:00:00.000Z';
+  return {
+    internet: { status: 'unavailable', probes: [], checkedAt },
+    hub: { status: 'unknown', probes: [], checkedAt },
+    targets: { status: 'available', probes: [], checkedAt },
+    dns: { available: false, latencyMs: 0 },
+    mode: 'private_only',
+    profiledAt: checkedAt,
+  };
+}
+
+/**
+ * The mechanical guard: assert the whole validation result rather than a
+ * hand-picked subset of checks, so a rule added to the validator later applies
+ * to this fixture automatically instead of needing a reviewer to remember it.
+ */
+describe('all-step-types plan fixture', () => {
+  it('passes the real plan validator', () => {
+    const result = validatePlan(
+      makeAllStepTypesPlan(),
+      safetyManifestFor({
+        scenario: 'replication_lag_cascade',
+        executionContexts: ['postgresql_read', 'postgresql_write', 'load_balancer'],
+        maxRiskLevel: 'elevated',
+      }),
+    );
+
+    expect(result.checks.filter((c) => !c.passed)).toEqual([]);
+    expect(result.valid).toBe(true);
+  });
+});
+
+describe('explainPlan — when the AI cannot be used', () => {
+  let originalApiKey: string | undefined;
+  let errorSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    originalApiKey = process.env.ANTHROPIC_API_KEY;
+    process.env.ANTHROPIC_API_KEY = 'test-key';
+    createMock.mockReset();
+    resetNetworkProfile();
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    errorSpy.mockRestore();
+    resetNetworkProfile();
+    if (originalApiKey !== undefined) {
+      process.env.ANTHROPIC_API_KEY = originalApiKey;
+    } else {
+      delete process.env.ANTHROPIC_API_KEY;
+    }
+  });
+
+  it('falls back without an API key and never reaches the SDK', async () => {
+    delete process.env.ANTHROPIC_API_KEY;
+
+    const result = await explainPlan(makeAllStepTypesPlan(), DIAGNOSIS);
+
+    expect(result.source).toBe('fallback');
+    expect(createMock).not.toHaveBeenCalled();
+  });
+
+  it('falls back when the network profile reports no internet', async () => {
+    setNetworkProfile(offlineProfile());
+
+    const result = await explainPlan(makeAllStepTypesPlan(), DIAGNOSIS);
+
+    expect(result.source).toBe('fallback');
+    expect(createMock).not.toHaveBeenCalled();
+  });
+
+  it('falls back and reports the reason on an API failure', async () => {
+    createMock.mockRejectedValue(new Error('overloaded_error'));
+
+    const result = await explainPlan(makeAllStepTypesPlan(), DIAGNOSIS);
+
+    expect(result.source).toBe('fallback');
+    expect(errorSpy).toHaveBeenCalledWith(
+      'AI plan explanation failed, using fallback:',
+      'overloaded_error',
+    );
+  });
+
+  it('logs a non-Error rejection as-is', async () => {
+    const thrown: unknown = 'socket hang up';
+    createMock.mockRejectedValue(thrown);
+
+    const result = await explainPlan(makeAllStepTypesPlan(), DIAGNOSIS);
+
+    expect(result.source).toBe('fallback');
+    expect(errorSpy).toHaveBeenCalledWith(
+      'AI plan explanation failed, using fallback:',
+      'socket hang up',
+    );
+  });
+});
+
+describe('explainPlan — structural fallback content', () => {
+  let originalApiKey: string | undefined;
+
+  beforeEach(() => {
+    originalApiKey = process.env.ANTHROPIC_API_KEY;
+    delete process.env.ANTHROPIC_API_KEY;
+    createMock.mockReset();
+    resetNetworkProfile();
+  });
+
+  afterEach(() => {
+    resetNetworkProfile();
+    if (originalApiKey !== undefined) {
+      process.env.ANTHROPIC_API_KEY = originalApiKey;
+    } else {
+      delete process.env.ANTHROPIC_API_KEY;
+    }
+  });
+
+  it('explains every step type, leaving none blank', async () => {
+    const result = await explainPlan(makeAllStepTypesPlan(), DIAGNOSIS);
+
+    expect(result.stepExplanations).toHaveLength(8);
+    for (const se of result.stepExplanations) {
+      expect(se.explanation.length).toBeGreaterThan(0);
+    }
+
+    const byId = Object.fromEntries(result.stepExplanations.map((s) => [s.stepId, s.explanation]));
+    expect(byId['step-001']).toContain('Gather diagnostic data');
+    expect(byId['step-002']).toContain('Replication recovery starting');
+    expect(byId['step-003']).toContain('2 capture(s)');
+    expect(byId['step-004']).toContain('elevated-risk');
+    expect(byId['step-004']).toContain('pg-replica-52, read-pool');
+    // The approval step's own presentation text, not a generic placeholder —
+    // this is what an operator reads before deciding.
+    expect(byId['step-005']).toContain('Rebuild replica 10.0.1.52 from a base backup?');
+    expect(byId['step-006']).toContain('needs revision');
+    expect(byId['step-007']).toContain('replica lag below 10s');
+  });
+
+  it('summarizes duration, rollback and scenario', async () => {
+    const result = await explainPlan(makeAllStepTypesPlan(), DIAGNOSIS);
+
+    expect(result.summary).toContain('replication_lag_cascade');
+    expect(result.summary).toContain('PT15M');
+    expect(result.summary).toContain('stepwise');
+  });
+
+  it('says "unknown scenario" rather than "null" when the diagnosis has none', async () => {
+    const result = await explainPlan(makeAllStepTypesPlan(), { ...DIAGNOSIS, scenario: null });
+
+    expect(result.summary).toContain('unknown scenario');
+    expect(result.summary).not.toContain('null');
+  });
+
+  it('raises data loss as its own risk line when the plan carries any', async () => {
+    const plan = makeAllStepTypesPlan({
+      impact: {
+        dataLossRisk: 'possible',
+        estimatedUserImpact: 'Writes rejected during failover',
+      },
+    } as unknown as Partial<RecoveryPlan>);
+
+    const result = await explainPlan(plan, DIAGNOSIS);
+
+    expect(result.risks).toContain('Data loss risk: possible');
+    expect(result.risks).toContain('1 step(s) at elevated risk or higher');
+    expect(result.risks).toContain('User impact: Writes rejected during failover');
+  });
+
+  it('omits the data loss line when the plan risks none', async () => {
+    const result = await explainPlan(makeAllStepTypesPlan(), DIAGNOSIS);
+
+    expect(result.risks.some((r) => r.startsWith('Data loss risk'))).toBe(false);
+  });
+});
+
+describe('explainPlan — tolerating a partially shaped AI reply', () => {
+  let originalApiKey: string | undefined;
+
+  beforeEach(() => {
+    originalApiKey = process.env.ANTHROPIC_API_KEY;
+    process.env.ANTHROPIC_API_KEY = 'test-key';
+    createMock.mockReset();
+    resetNetworkProfile();
+  });
+
+  afterEach(() => {
+    resetNetworkProfile();
+    if (originalApiKey !== undefined) {
+      process.env.ANTHROPIC_API_KEY = originalApiKey;
+    } else {
+      delete process.env.ANTHROPIC_API_KEY;
+    }
+  });
+
+  /**
+   * Parseable but incomplete: the reply is JSON, so `explainPlan` reports
+   * `source: 'ai'` and the operator is told this is the model's explanation.
+   * It therefore must not render `undefined` for the fields the model skipped —
+   * it substitutes the plan's own summary and one row per real step.
+   */
+  it('substitutes the plan summary and a row per step when both are missing', async () => {
+    createMock.mockResolvedValue({ content: [{ type: 'text', text: '{}' }] });
+
+    const result = await explainPlan(makeAllStepTypesPlan(), DIAGNOSIS);
+
+    expect(result.source).toBe('ai');
+    expect(result.summary).toBe('Resync the lagging replica');
+    expect(result.stepExplanations).toHaveLength(8);
+    expect(result.stepExplanations.map((s) => s.stepId)).toEqual([
+      'step-001',
+      'step-002',
+      'step-003',
+      'step-004',
+      'step-005',
+      'step-006',
+      'step-007',
+      'step-008',
+    ]);
+    expect(result.risks).toEqual([]);
+  });
+
+  it('drops a stepExplanations value that is not an array', async () => {
+    createMock.mockResolvedValue({
+      content: [{ type: 'text', text: '{"summary":"s","stepExplanations":"nope","risks":"nope"}' }],
+    });
+
+    const result = await explainPlan(makeAllStepTypesPlan(), DIAGNOSIS);
+
+    expect(result.stepExplanations).toHaveLength(8);
+    expect(result.risks).toEqual([]);
+  });
+
+  it('fills in blanks inside individual step explanations', async () => {
+    createMock.mockResolvedValue({
+      content: [
+        {
+          type: 'text',
+          text: '{"summary":"s","stepExplanations":[{}],"risks":[1,true]}',
+        },
+      ],
+    });
+
+    const result = await explainPlan(makeAllStepTypesPlan(), DIAGNOSIS);
+
+    expect(result.stepExplanations).toEqual([{ stepId: '', name: '', explanation: '' }]);
+    // Risks are coerced to strings so the renderer never prints "[object Object]".
+    expect(result.risks).toEqual(['1', 'true']);
+  });
+
+  it('sends the command type alone when a step has no operation', async () => {
+    createMock.mockResolvedValue({ content: [{ type: 'text', text: '{"summary":"s"}' }] });
+
+    await explainPlan(makeAllStepTypesPlan(), DIAGNOSIS);
+
+    const [params] = createMock.mock.calls[0]!;
+    const userMessage = String(params.messages[0].content);
+    expect(userMessage).toContain('"command": "sql SELECT pg_terminate_backend(pid)"');
+    // step-008 has no operation: the command reads as the bare type, with no
+    // trailing space to make the prompt look like a truncated command.
+    expect(userMessage).toContain('"command": "configuration_change"');
+    expect(userMessage).not.toMatch(/"command": "\w+ "/);
+  });
+});
diff --git a/src/__tests__/ai-explainer-plan-fixtures.ts b/src/__tests__/ai-explainer-plan-fixtures.ts
new file mode 100644
index 0000000..3dcc9f7
--- /dev/null
+++ b/src/__tests__/ai-explainer-plan-fixtures.ts
@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 CrisisMode Contributors
+
+/**
+ * Shared scaffolding for running the AI-explainer plan fixtures through the
+ * real plan validator.
+ *
+ * `explainPlan` never validates the plan it is handed, so nothing in those
+ * tests would notice a fixture that violates the repo's safety contract
+ * (CLAUDE.md "Safety Rules", enforced by src/framework/validator.ts). A fixture
+ * that does is worse than untidy: it is the shape a contributor copies, and it
+ * is the shape the real engine would refuse to execute. This module exists so
+ * each fixture can be asserted valid mechanically instead of by review.
+ *
+ * Not a test file (no `.test.ts` suffix), so vitest does not collect it.
+ */
+
+import type { AgentManifest } from '../types/manifest.js';
+import type { RiskLevel } from '../types/common.js';
+
+/**
+ * The minimum manifest that lets `validatePlan` judge a plan on its own merits.
+ *
+ * `validatePlan` cross-checks a plan against its agent's manifest — declared
+ * scenario, declared execution contexts, and the agent's maximum risk level —
+ * so a manifest is required even when the question being asked is only about
+ * the plan. Everything here is therefore derived from the plan under test: it
+ * grants exactly what the plan needs and nothing more, so the checks that
+ * remain meaningful are the plan-safety ones.
+ *
+ * `capabilities` is deliberately left off each execution context. That field is
+ * only read by the opt-in `requireExecutableCapabilities` check, which asks a
+ * different question (can this spoke actually run the plan?) and is not what
+ * these fixtures are for.
+ */
+export function safetyManifestFor(options: {
+  scenario: string;
+  executionContexts: string[];
+  maxRiskLevel: RiskLevel;
+}): AgentManifest {
+  return {
+    apiVersion: 'crisismode.io/v1alpha1',
+    kind: 'AgentManifest',
+    metadata: {
+      name: 'ai-explainer-fixture-agent',
+      version: '0.0.0',
+      description: 'Manifest scaffold for validating AI-explainer plan fixtures',
+      authors: ['CrisisMode Contributors'],
+      license: 'Apache-2.0',
+      tags: ['test-fixture'],
+      plugin: {
+        type: 'agent',
+        sdkVersion: '^0.4.0',
+        entrypoint: 'test-fixture',
+      },
+    },
+    spec: {
+      targetSystems: [],
+      triggerConditions: [],
+      failureScenarios: [options.scenario],
+      executionContexts: options.executionContexts.map((name) => ({
+        name,
+        type: 'test-fixture',
+        privilege: 'read_write',
+        target: 'fixture-target',
+      })),
+      observabilityDependencies: { required: [], optional: [] },
+      riskProfile: {
+        maxRiskLevel: options.maxRiskLevel,
+        dataLossPossible: false,
+        serviceDisruptionPossible: true,
+      },
+      humanInteraction: {
+        requiresApproval: true,
+        minimumApprovalRole: 'sre-oncall',
+        escalationPath: ['sre-oncall'],
+      },
+    },
+  } as unknown as AgentManifest;
+}
diff --git a/src/__tests__/ai-response-budgets.test.ts b/src/__tests__/ai-response-budgets.test.ts
index f9ebaa2..13f57e2 100644
--- a/src/__tests__/ai-response-budgets.test.ts
+++ b/src/__tests__/ai-response-budgets.test.ts
@@ -25,6 +25,8 @@ import type * as AnthropicSdk from '@anthropic-ai/sdk';
 import { explainPlan } from '../framework/ai-explainer.js';
 import { synthesizeByAi } from '../framework/root-cause-synthesis.js';
 import type { AgentEvidence } from '../framework/root-cause-synthesis.js';
+import { validatePlan } from '../framework/validator.js';
+import { safetyManifestFor } from './ai-explainer-plan-fixtures.js';
 import type { RecoveryPlan } from '../types/recovery-plan.js';
 import type { DiagnosisResult } from '../types/diagnosis-result.js';
 
@@ -144,9 +146,19 @@ const EXPLAINER_MEASURED_TOKENS = 1484;
 const EXPLAINER_MEASURED_MS = 16_400;
 
 /**
- * The plan only has to satisfy the fallback builder and the prompt assembly —
- * the SDK is mocked, so the response is EXPLAINER_RESPONSE regardless of what
- * is sent. The fixture itself is the real answer to the 10-step reference plan.
+ * The SDK is mocked, so the response is EXPLAINER_RESPONSE regardless of what
+ * is sent, and this plan only has to satisfy the fallback builder and the
+ * prompt assembly. It still has to obey the repo's safety contract though
+ * (CLAUDE.md "Safety Rules", enforced by src/framework/validator.ts): an
+ * elevated-risk `system_action` carries `statePreservation.before` captures,
+ * and a plan containing one carries a `human_notification`. This fixture had
+ * neither, which made it both unexecutable by the real engine and the wrong
+ * shape to copy — the `passes the real plan validator` test above is what keeps
+ * that from recurring silently.
+ *
+ * The trailing cast covers only plan-envelope fields no code path here reads
+ * (agentName, createdAt, affectedSystems, ...), not anything the validator
+ * inspects.
  */
 function makePlan(): RecoveryPlan {
   return {
@@ -161,18 +173,68 @@ function makePlan(): RecoveryPlan {
         stepId: 'step-001',
         type: 'diagnosis_action',
         name: 'Assess current replication lag across all replicas',
+        executionContext: 'postgresql_read',
+        target: 'prod-db-primary',
         command: { type: 'sql', operation: 'SELECT * FROM pg_stat_replication' },
       },
+      {
+        stepId: 'step-002',
+        type: 'human_notification',
+        name: 'Notify on-call DBA of replication recovery initiation',
+        recipients: [{ role: 'dba-oncall', urgency: 'high' }],
+        message: {
+          summary: 'Replication recovery starting on prod-db-primary',
+          detail:
+            'The lagging replica 10.0.1.52 will be disconnected and resynced. Reads served from that replica will fail over to the remaining two.',
+          actionRequired: false,
+        },
+        channel: 'slack',
+      },
       {
         stepId: 'step-004',
         type: 'system_action',
         name: 'Disconnect lagging replica 10.0.1.52 from replication',
+        executionContext: 'postgresql_write',
+        target: 'prod-db-primary',
         riskLevel: 'elevated',
+        requiredCapabilities: ['db.replica.disconnect'],
         command: { type: 'sql', operation: 'SELECT pg_terminate_backend(pid)' },
-        blastRadius: { directComponents: ['pg-replica-10-0-1-52'] },
+        // Required at elevated risk or higher: the pre-mutation snapshot is
+        // what a rollback and the forensic trail are reconstructed from.
+        statePreservation: {
+          before: [
+            {
+              name: 'replication_state_snapshot',
+              captureType: 'sql_query',
+              statement: 'SELECT * FROM pg_stat_replication;',
+              captureCost: 'negligible',
+              capturePolicy: 'required',
+              retention: 'P30D',
+            },
+          ],
+          after: [
+            {
+              name: 'replication_state_post_disconnect',
+              captureType: 'sql_query',
+              statement: 'SELECT * FROM pg_stat_replication;',
+              captureCost: 'negligible',
+              capturePolicy: 'best_effort',
+              retention: 'P30D',
+            },
+          ],
+        },
+        blastRadius: {
+          directComponents: ['pg-replica-10-0-1-52'],
+          indirectComponents: ['read-pool'],
+          maxImpact: 'single_replica_disconnected',
+          cascadeRisk: 'low',
+        },
       },
     ],
-    rollbackStrategy: { type: 'stepwise' },
+    rollbackStrategy: {
+      type: 'stepwise',
+      description: 'Undo each completed step in reverse order.',
+    },
     impact: {
       dataLossRisk: 'none',
       estimatedUserImpact: 'Read queries may experience elevated latency',
@@ -188,6 +250,30 @@ const DIAGNOSIS: DiagnosisResult = {
   diagnosticPlanNeeded: false,
 };
 
+/**
+ * The mechanical guard for this fixture. `explainPlan` never validates the plan
+ * it is given, so without this the fixture could drift out of the repo's safety
+ * contract and only a reviewer would notice — which is how it acquired an
+ * elevated-risk action with no `statePreservation.before` captures in the first
+ * place. Asserting the full result (not a hand-picked subset) means a new
+ * validator rule applies here automatically.
+ */
+describe('ai-explainer plan fixture', () => {
+  it('passes the real plan validator', () => {
+    const result = validatePlan(
+      makePlan(),
+      safetyManifestFor({
+        scenario: 'replication_lag_cascade',
+        executionContexts: ['postgresql_read', 'postgresql_write'],
+        maxRiskLevel: 'elevated',
+      }),
+    );
+
+    expect(result.checks.filter((c) => !c.passed)).toEqual([]);
+    expect(result.valid).toBe(true);
+  });
+});
+
 describe('ai-explainer response budget', () => {
   let originalApiKey: string | undefined;
 
diff --git a/src/__tests__/incident-summary-print.test.ts b/src/__tests__/incident-summary-print.test.ts
new file mode 100644
index 0000000..d0b43b6
--- /dev/null
+++ b/src/__tests__/incident-summary-print.test.ts
@@ -0,0 +1,163 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 CrisisMode Contributors
+
+/**
+ * `printIncidentSummary` — the human-mode renderer.
+ *
+ * `formatIncidentSummaryText` (the pipe/paste form) is covered in
+ * incident-summary.test.ts; this is its terminal counterpart, and the two must
+ * not drift apart. It is the surface an operator actually reads at the end of a
+ * scan, including the `crisismode diagnose <target>` line whose correctness
+ * `diagnoseCommandFor` exists to guarantee — a suggestion printed here that
+ * does not resolve is a dead end mid-incident.
+ *
+ * Assertions are on content, not colour: chalk emits no ANSI when stdout is not
+ * a TTY, which is the case under vitest, so a colour assertion would pass
+ * vacuously.
+ */
+
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import {
+  buildIncidentSummary,
+  printIncidentSummary,
+} from '../cli/incident-summary.js';
+import type { ScanResult } from '../cli/output.js';
+
+function makeFinding(
+  overrides: Partial<ScanResult['findings'][0]> = {},
+): ScanResult['findings'][0] {
+  return {
+    id: 'TEST-001',
+    service: 'test-service',
+    status: 'healthy',
+    summary: 'All good',
+    confidence: 0.9,
+    escalationLevel: 1,
+    signals: [],
+    ...overrides,
+  };
+}
+
+function makeResult(overrides: Partial<ScanResult> = {}): ScanResult {
+  return {
+    score: 100,
+    findings: [],
+    recentChanges: [],
+    scannedAt: '2026-08-09T12:00:00Z',
+    durationMs: 1500,
+    ...overrides,
+  };
+}
+
+/** Print a summary and return everything it wrote as one string. */
+function capturePrinted(result: ScanResult): string {
+  const lines: string[] = [];
+  const logSpy = vi.spyOn(console, 'log').mockImplementation((...args: unknown[]) => {
+    lines.push(args.map(String).join(' '));
+  });
+  try {
+    printIncidentSummary(buildIncidentSummary(result));
+  } finally {
+    logSpy.mockRestore();
+  }
+  return lines.join('\n');
+}
+
+describe('printIncidentSummary', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('prints every section when all three severities are present', () => {
+    const out = capturePrinted(
+      makeResult({
+        score: 42,
+        findings: [
+          makeFinding({
+            id: 'PG-001',
+            service: 'postgresql (prod-db)',
+            status: 'unhealthy',
+            summary: 'Replication lag 342s',
+          }),
+          makeFinding({
+            id: 'REDIS-001',
+            service: 'redis (cache-01)',
+            status: 'recovering',
+            summary: 'Memory pressure easing',
+          }),
+          makeFinding({ id: 'DNS-001', service: 'dns (resolver)', status: 'healthy' }),
+        ],
+      }),
+    );
+
+    expect(out).toContain('Incident Summary (paste into Slack/incident channel)');
+    expect(out).toContain('Time: 2026-08-09T12:00:00Z');
+    expect(out).toContain('Scan completed in 1.5s');
+
+    // Headline: critical wins over warning.
+    expect(out).toContain('1 service unhealthy out of 3 checked (score: 42/100)');
+
+    expect(out).toContain('UNHEALTHY:');
+    expect(out).toContain('[PG-001] postgresql (prod-db) — Replication lag 342s');
+    expect(out).toContain('NEEDS ATTENTION:');
+    expect(out).toContain('[REDIS-001] redis (cache-01) — Memory pressure easing');
+    expect(out).toContain('OK: dns (resolver)');
+
+    // The next step must name the target, not the finding id.
+    expect(out).toContain('NEXT STEPS:');
+    expect(out).toContain('crisismode diagnose prod-db');
+    expect(out).not.toContain('crisismode diagnose PG-001');
+  });
+
+  it('omits the sections that have no findings', () => {
+    const out = capturePrinted(
+      makeResult({
+        findings: [makeFinding({ id: 'PG-001', service: 'postgresql (prod-db)' })],
+      }),
+    );
+
+    expect(out).toContain('All 1 services healthy (score: 100/100)');
+    expect(out).toContain('OK: postgresql (prod-db)');
+    expect(out).not.toContain('UNHEALTHY:');
+    expect(out).not.toContain('NEEDS ATTENTION:');
+    expect(out).toContain('All systems healthy. Monitor with: `crisismode watch`');
+  });
+
+  it('leads with the warning headline when nothing is unhealthy', () => {
+    const out = capturePrinted(
+      makeResult({
+        score: 70,
+        findings: [
+          makeFinding({ id: 'PG-001', status: 'unknown', summary: 'Unreachable' }),
+          makeFinding({ id: 'REDIS-001', status: 'unknown', summary: 'Timeout' }),
+        ],
+      }),
+    );
+
+    expect(out).toContain('2 services need attention out of 2 checked (score: 70/100)');
+    expect(out).toContain('NEEDS ATTENTION:');
+    expect(out).not.toContain('UNHEALTHY:');
+    expect(out).not.toContain('OK:');
+    expect(out).toContain('crisismode scan --verbose');
+  });
+
+  it('prints nothing but the frame when there are no findings at all', () => {
+    const out = capturePrinted(makeResult());
+
+    expect(out).toContain('All 0 services healthy (score: 100/100)');
+    expect(out).not.toContain('UNHEALTHY:');
+    expect(out).not.toContain('NEEDS ATTENTION:');
+    expect(out).not.toContain('OK:');
+    // No findings means no actionable next step to invent.
+    expect(out).not.toContain('NEXT STEPS:');
+  });
+
+  it('emits no ANSI escapes under a non-TTY stdout', () => {
+    const out = capturePrinted(
+      makeResult({ findings: [makeFinding({ id: 'PG-001', status: 'unhealthy' })] }),
+    );
+
+    // eslint-disable-next-line no-control-regex
+    expect(out).not.toMatch(/\x1b\[/);
+  });
+});
diff --git a/src/__tests__/incident-summary.test.ts b/src/__tests__/incident-summary.test.ts
index ceeadde..8c98627 100644
--- a/src/__tests__/incident-summary.test.ts
+++ b/src/__tests__/incident-summary.test.ts
@@ -77,6 +77,34 @@ describe('diagnoseCommandFor', () => {
       diagnoseCommandFor(summaryFinding({ service: 'postgresql (v16) (prod-db)' })),
     ).toBe('crisismode diagnose prod-db');
   });
+
+  it('falls back rather than emitting a blank target for an empty group', () => {
+    // `crisismode diagnose ""` is a dead end; the bare command at least
+    // diagnoses the first configured target.
+    expect(diagnoseCommandFor(summaryFinding({ service: 'postgresql ()' })))
+      .toBe('crisismode diagnose');
+    expect(diagnoseCommandFor(summaryFinding({ service: 'postgresql (   )' })))
+      .toBe('crisismode diagnose');
+  });
+
+  it('trims padding around a recoverable target name', () => {
+    expect(diagnoseCommandFor(summaryFinding({ service: 'postgresql ( prod-db )' })))
+      .toBe('crisismode diagnose prod-db');
+  });
+
+  /**
+   * PLUG passthrough is keyed to the whole id, not a prefix: `PLUGIN-1` is not
+   * a plugin finding index, so it must go through target extraction like any
+   * other agent finding.
+   */
+  it('does not treat a PLUG-lookalike id as a plugin index', () => {
+    expect(
+      diagnoseCommandFor(summaryFinding({ id: 'PLUGIN-1', service: 'kafka (prod-kafka)' })),
+    ).toBe('crisismode diagnose prod-kafka');
+    expect(
+      diagnoseCommandFor(summaryFinding({ id: 'PLUG-2A', service: 'kafka (prod-kafka)' })),
+    ).toBe('crisismode diagnose prod-kafka');
+  });
 });
 
 describe('buildIncidentSummary', () => {
diff --git a/src/__tests__/root-cause-synthesis-ai-path.test.ts b/src/__tests__/root-cause-synthesis-ai-path.test.ts
new file mode 100644
index 0000000..9ee4ae5
--- /dev/null
+++ b/src/__tests__/root-cause-synthesis-ai-path.test.ts
@@ -0,0 +1,523 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 CrisisMode Contributors
+
+/**
+ * `synthesizeByAi`'s gates, prompt assembly and response tolerance.
+ *
+ * `ai-response-budgets.test.ts` pins the budget and the code-fence handling —
+ * the fence was the dominant live failure mode here, and stripping it is what
+ * made 2 of 3 real calls usable. This file pins the surrounding behaviour: the
+ * conditions under which no call is made at all, that every kind of evidence an
+ * agent can carry actually reaches the prompt (evidence the model never sees
+ * cannot be correlated), and that a partially shaped reply degrades into a
+ * usable cluster list rather than an exception.
+ *
+ * Every path here ends in rule-based correlation on failure, so a regression is
+ * invisible in output apart from `source` — which is why it is asserted
+ * explicitly everywhere below. Hermetic: the SDK is mocked, the network profile
+ * is written directly.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import type * as AnthropicSdk from '@anthropic-ai/sdk';
+import type { NetworkProfile } from '@crisismode/agent-sdk';
+import { synthesizeByAi, synthesizeByRules } from '../framework/root-cause-synthesis.js';
+import type { AgentEvidence } from '../framework/root-cause-synthesis.js';
+import { resetNetworkProfile, setNetworkProfile } from '../framework/network-profile.js';
+
+const { createMock } = vi.hoisted(() => ({ createMock: vi.fn() }));
+
+vi.mock('@anthropic-ai/sdk', async (importOriginal) => {
+  const actual = await importOriginal<typeof AnthropicSdk>();
+  return {
+    ...actual,
+    default: class {
+      messages = { create: createMock };
+    },
+  };
+});
+
+function offlineProfile(): NetworkProfile {
+  const checkedAt = '2026-08-09T12:00:00.000Z';
+  return {
+    internet: { status: 'unavailable', probes: [], checkedAt },
+    hub: { status: 'unknown', probes: [], checkedAt },
+    targets: { status: 'available', probes: [], checkedAt },
+    dns: { available: false, latencyMs: 0 },
+    mode: 'private_only',
+    profiledAt: checkedAt,
+  };
+}
+
+function twoAgents(): AgentEvidence[] {
+  return ['postgresql', 'redis'].map((agentKind) => ({
+    agentKind,
+    targetName: `prod-${agentKind}`,
+    signals: [
+      {
+        type: 'connection' as const,
+        source: `${agentKind}_probe`,
+        detail: 'refusing connections',
+        severity: 'critical' as const,
+      },
+    ],
+  }));
+}
+
+describe('synthesizeByAi — gates that skip the call entirely', () => {
+  let originalApiKey: string | undefined;
+  let errorSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    originalApiKey = process.env.ANTHROPIC_API_KEY;
+    process.env.ANTHROPIC_API_KEY = 'test-key';
+    createMock.mockReset();
+    resetNetworkProfile();
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    errorSpy.mockRestore();
+    resetNetworkProfile();
+    if (originalApiKey !== undefined) {
+      process.env.ANTHROPIC_API_KEY = originalApiKey;
+    } else {
+      delete process.env.ANTHROPIC_API_KEY;
+    }
+  });
+
+  it('does not call the model for a single agent — there is nothing to correlate', async () => {
+    const one = twoAgents().slice(0, 1);
+
+    const result = await synthesizeByAi(one);
+
+    expect(result.source).toBe('rules');
+    expect(result.uncorrelated).toEqual(['postgresql']);
+    expect(result.narrative).toContain('no cross-system correlation possible');
+    expect(createMock).not.toHaveBeenCalled();
+  });
+
+  it('does not call the model for empty evidence', async () => {
+    const result = await synthesizeByAi([]);
+
+    expect(result.source).toBe('rules');
+    expect(result.narrative).toBe('No evidence provided for synthesis.');
+    expect(createMock).not.toHaveBeenCalled();
+  });
+
+  it('falls back to rules without an API key', async () => {
+    delete process.env.ANTHROPIC_API_KEY;
+
+    const result = await synthesizeByAi(twoAgents());
+
+    expect(result.source).toBe('rules');
+    expect(createMock).not.toHaveBeenCalled();
+  });
+
+  it('falls back to rules when the network profile reports no internet', async () => {
+    setNetworkProfile(offlineProfile());
+
+    const result = await synthesizeByAi(twoAgents());
+
+    expect(result.source).toBe('rules');
+    expect(createMock).not.toHaveBeenCalled();
+  });
+
+  it('falls back to rules and reports the reason on an API failure', async () => {
+    createMock.mockRejectedValue(new Error('overloaded_error'));
+
+    const result = await synthesizeByAi(twoAgents());
+
+    expect(result.source).toBe('rules');
+    expect(errorSpy).toHaveBeenCalledWith('AI synthesis failed:', 'overloaded_error');
+  });
+
+  it('logs a non-Error rejection as-is', async () => {
+    const thrown: unknown = 'socket hang up';
+    createMock.mockRejectedValue(thrown);
+
+    const result = await synthesizeByAi(twoAgents());
+
+    expect(result.source).toBe('rules');
+    expect(errorSpy).toHaveBeenCalledWith('AI synthesis failed:', 'socket hang up');
+  });
+});
+
+describe('synthesizeByAi — what the model is shown', () => {
+  let originalApiKey: string | undefined;
+
+  beforeEach(() => {
+    originalApiKey = process.env.ANTHROPIC_API_KEY;
+    process.env.ANTHROPIC_API_KEY = 'test-key';
+    createMock.mockReset();
+    resetNetworkProfile();
+  });
+
+  afterEach(() => {
+    resetNetworkProfile();
+    if (originalApiKey !== undefined) {
+      process.env.ANTHROPIC_API_KEY = originalApiKey;
+    } else {
+      delete process.env.ANTHROPIC_API_KEY;
+    }
+  });
+
+  /**
+   * Health signals, diagnosis findings and recurring patterns are the three
+   * things an agent can contribute beyond raw signals. Evidence that never
+   * reaches the prompt cannot be correlated, so a silent omission here would
+   * degrade synthesis quality with no visible failure at all.
+   */
+  it('includes health signals, diagnosis findings and patterns in the prompt', async () => {
+    createMock.mockResolvedValue({ content: [{ type: 'text', text: '{"clusters":[]}' }] });
+
+    const evidence: AgentEvidence[] = [
+      {
+        agentKind: 'postgresql',
+        targetName: 'prod-db',
+        health: {
+          status: 'unhealthy',
+          confidence: 0.82,
+          summary: 'Replication lag is growing',
+          observedAt: '2026-08-09T12:00:00.000Z',
+          signals: [
+            {
+              source: 'pg_stat_replication',
+              status: 'critical',
+              detail: 'replica 10.0.1.52 is 342s behind',
+              observedAt: '2026-08-09T12:00:00.000Z',
+            },
+          ],
+          recommendedActions: [],
+        },
+        diagnosis: {
+          status: 'identified',
+          scenario: 'replication_lag_cascade',
+          confidence: 0.78,
+          findings: [
+            {
+              source: 'pg_stat_replication',
+              observation: 'All replicas share one sent_lsn',
+              severity: 'warning',
+              data: {},
+            },
+          ],
+          diagnosticPlanNeeded: false,
+        },
+        patterns: [
+          {
+            pattern: 'degradation-cycle',
+            occurrences: 4,
+            firstSeen: '2026-08-09T11:00:00.000Z',
+            lastSeen: '2026-08-09T12:00:00.000Z',
+            description: 'lag climbs then partially recovers',
+          },
+        ],
+      },
+      {
+        agentKind: 'redis',
+        targetName: 'prod-cache',
+        // No health, diagnosis or patterns — the builder must simply skip them.
+        signals: [
+          {
+            type: 'latency',
+            source: 'redis_probe',
+            detail: 'p99 climbing',
+            severity: 'warning',
+          },
+        ],
+      },
+    ];
+
+    await synthesizeByAi(evidence);
+
+    const [params] = createMock.mock.calls[0]!;
+    const prompt = String(params.messages[0].content);
+
+    expect(prompt).toContain('--- Agent: postgresql (target: prod-db) ---');
+    expect(prompt).toContain('Health: unhealthy (82% confidence)');
+    expect(prompt).toContain('Summary: Replication lag is growing');
+    expect(prompt).toContain('Signal: [CRITICAL] pg_stat_replication: replica 10.0.1.52 is 342s behind');
+    expect(prompt).toContain('Diagnosis: replication_lag_cascade (identified, 78%)');
+    expect(prompt).toContain('Finding: [WARNING] All replicas share one sent_lsn');
+    expect(prompt).toContain('Patterns: degradation-cycle (4x)');
+    expect(prompt).toContain('--- Agent: redis (target: prod-cache) ---');
+  });
+
+  it('says "unknown" rather than "null" for a diagnosis with no scenario', async () => {
+    createMock.mockResolvedValue({ content: [{ type: 'text', text: '{"clusters":[]}' }] });
+
+    await synthesizeByAi([
+      {
+        agentKind: 'kafka',
+        targetName: 'prod-kafka',
+        diagnosis: {
+          status: 'inconclusive',
+          scenario: null,
+          confidence: 0.2,
+          findings: [],
+          diagnosticPlanNeeded: true,
+        },
+      },
+      { agentKind: 'flink', targetName: 'prod-flink' },
+    ]);
+
+    const [params] = createMock.mock.calls[0]!;
+    expect(String(params.messages[0].content)).toContain('Diagnosis: unknown (inconclusive, 20%)');
+  });
+});
+
+describe('synthesizeByAi — tolerating a partially shaped reply', () => {
+  let originalApiKey: string | undefined;
+
+  beforeEach(() => {
+    originalApiKey = process.env.ANTHROPIC_API_KEY;
+    process.env.ANTHROPIC_API_KEY = 'test-key';
+    createMock.mockReset();
+    resetNetworkProfile();
+  });
+
+  afterEach(() => {
+    resetNetworkProfile();
+    if (originalApiKey !== undefined) {
+      process.env.ANTHROPIC_API_KEY = originalApiKey;
+    } else {
+      delete process.env.ANTHROPIC_API_KEY;
+    }
+  });
+
+  it('defaults uncorrelated and narrative when the model omits them', async () => {
+    createMock.mockResolvedValue({ content: [{ type: 'text', text: '{"clusters":[]}' }] });
+
+    const result = await synthesizeByAi(twoAgents());
+
+    expect(result.source).toBe('ai');
+    expect(result.clusters).toEqual([]);
+    expect(result.uncorrelated).toEqual([]);
+    expect(result.narrative).toBe('AI synthesis completed.');
+  });
+
+  /**
+   * An empty object is valid JSON, so it is reported as an AI answer. "The
+   * model found no correlation" is a legitimate result and must not be turned
+   * into a crash by a missing key.
+   */
+  it('treats a reply with no clusters key as "no correlation found"', async () => {
+    createMock.mockResolvedValue({ content: [{ type: 'text', text: '{}' }] });
+
+    const result = await synthesizeByAi(twoAgents());
+
+    expect(result.source).toBe('ai');
+    expect(result.clusters).toEqual([]);
+    expect(result.narrative).toBe('AI synthesis completed.');
+  });
+
+  it('reuses the agent list as the investigation order when none is given', async () => {
+    createMock.mockResolvedValue({
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            clusters: [
+              {
+                rootCause: 'shared upstream throughput ceiling',
+                confidence: 0.7,
+                agents: ['postgresql', 'redis'],
+                reasoning: 'both degraded in the same window',
+              },
+            ],
+          }),
+        },
+      ],
+    });
+
+    const result = await synthesizeByAi(twoAgents());
+
+    expect(result.clusters[0]?.investigationOrder).toEqual(['postgresql', 'redis']);
+    // The AI path claims no temporal analysis — it has no snapshot timeline.
+    expect(result.clusters[0]?.temporalCorrelation).toBe(false);
+    expect(result.clusters[0]?.id).toBe('cluster-0');
+  });
+
+  /**
+   * The model is asked for 0.0-1.0 and does not always comply. Confidence is an
+   * ordering weight, so an out-of-range value would sort a cluster above every
+   * legitimate one — clamping keeps the ranking meaningful.
+   */
+  it('clamps and rounds a confidence the model returned out of range', async () => {
+    createMock.mockResolvedValue({
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            clusters: [
+              { rootCause: 'too sure', confidence: 9, agents: ['a'], reasoning: 'r' },
+              { rootCause: 'negative', confidence: -2, agents: ['b'], reasoning: 'r' },
+              { rootCause: 'noisy', confidence: 0.6789, agents: ['c'], reasoning: 'r' },
+            ],
+          }),
+        },
+      ],
+    });
+
+    const result = await synthesizeByAi(twoAgents());
+
+    expect(result.clusters.map((c) => c.confidence)).toEqual([1, 0, 0.68]);
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────────
+// Rule-based paths the AI gates fall back to
+// ─────────────────────────────────────────────────────────────────────────
+
+describe('synthesizeByRules — health signals as a correlation input', () => {
+  /**
+   * An agent that reports only a health assessment (no SymptomSignals) still
+   * has to be correlatable: a `warning` health signal is read as latency and a
+   * `critical` one as an error rate. This is how `scan` evidence reaches the
+   * correlator, since scan produces assessments rather than symptom streams.
+   */
+  it('reads a warning health signal as latency', () => {
+    const result = synthesizeByRules([
+      makeHealthOnlyEvidence('kafka', 'warning'),
+      makeHealthOnlyEvidence('flink', 'warning'),
+    ]);
+
+    expect(result.clusters).toHaveLength(1);
+    expect(result.clusters[0]?.agents).toEqual(['kafka', 'flink']);
+    expect(result.clusters[0]?.reasoning).toContain('streaming-backpressure');
+  });
+
+  it('reads a critical health signal as an error rate', () => {
+    const result = synthesizeByRules([
+      makeHealthOnlyEvidence('application', 'critical'),
+      makeHealthOnlyEvidence('postgresql', 'critical'),
+    ]);
+
+    expect(result.clusters).toHaveLength(1);
+    expect(result.clusters[0]?.reasoning).toContain('deploy-cascade');
+  });
+});
+
+function makeHealthOnlyEvidence(
+  agentKind: string,
+  signalStatus: 'warning' | 'critical',
+): AgentEvidence {
+  return {
+    agentKind,
+    targetName: `prod-${agentKind}`,
+    health: {
+      // `recovering`, not `unhealthy`: this test is about signal-type mapping,
+      // and an unhealthy assessment would also add a temporal-correlation boost.
+      status: 'recovering',
+      confidence: 0.6,
+      summary: `${agentKind} is degraded`,
+      observedAt: '2026-08-09T12:00:00.000Z',
+      signals: [
+        {
+          source: `${agentKind}_probe`,
+          status: signalStatus,
+          detail: 'degraded',
+          observedAt: '2026-08-09T12:00:00.000Z',
+        },
+      ],
+      recommendedActions: [],
+    },
+  };
+}
+
+describe('synthesizeByRules — a trimmed cluster re-states only what survives', () => {
+  /**
+   * De-dup can strip agents out of a weaker cluster after a stronger one claims
+   * them. When that happens the cluster's `reasoning` is re-rendered, and the
+   * pattern count in it has to be recomputed from the survivors — the original
+   * count was over the pre-trim membership, so reusing it would have the cluster
+   * cite corroboration from evidence it no longer contains.
+   *
+   * Setup: `network-partition` scores 0.9 (four agents on connection signals,
+   * two of them flapping) and claims etcd/postgresql/kafka/ceph.
+   * `database-backpressure` scores 0.85 and matched postgresql, kafka and both
+   * redis targets, so it is left holding only the two redis targets — which are
+   * exactly the two carrying its `degradation-cycle` pattern.
+   */
+  it('recounts shared patterns over the surviving agents only', () => {
+    const connection = (source: string) => [
+      {
+        type: 'connection' as const,
+        source,
+        detail: 'connection refused',
+        severity: 'critical' as const,
+      },
+    ];
+    const pattern = (name: string) => [
+      {
+        pattern: name,
+        occurrences: 3,
+        firstSeen: '2026-08-09T11:00:00.000Z',
+        lastSeen: '2026-08-09T12:00:00.000Z',
+        description: name,
+      },
+    ];
+
+    const result = synthesizeByRules([
+      { agentKind: 'etcd', targetName: 'etcd-1', signals: connection('etcd_probe'), patterns: pattern('flapping') },
+      { agentKind: 'ceph', targetName: 'ceph-1', signals: connection('ceph_probe'), patterns: pattern('flapping') },
+      { agentKind: 'postgresql', targetName: 'prod-db', signals: connection('pg_probe') },
+      { agentKind: 'kafka', targetName: 'prod-kafka', signals: connection('kafka_probe') },
+      { agentKind: 'redis', targetName: 'cache-a', signals: connection('redis_probe'), patterns: pattern('degradation-cycle') },
+      { agentKind: 'redis', targetName: 'cache-b', signals: connection('redis_probe'), patterns: pattern('degradation-cycle') },
+    ]);
+
+    const partition = result.clusters.find((c) => c.reasoning.includes('network-partition'));
+    expect(partition?.agents).toEqual(['etcd', 'ceph', 'postgresql', 'kafka']);
+
+    const backpressure = result.clusters.find((c) => c.reasoning.includes('database-backpressure'));
+    // Trimmed down to the two redis targets the stronger cluster did not claim.
+    expect(backpressure?.agents).toEqual(['redis', 'redis']);
+    expect(backpressure?.reasoning).toContain('2 agents share signal types');
+    expect(backpressure?.reasoning).toContain('2 share patterns');
+    // And its prose no longer names an agent it lost.
+    expect(backpressure?.investigationOrder).toEqual(['redis']);
+  });
+});
+
+describe('synthesizeByRules — same-entity requirement', () => {
+  /**
+   * `iac-out-of-band-change` is the one rule that requires a shared entity id.
+   * Evidence that carries no ids at all must not satisfy it: pairing an
+   * arbitrary drift report with an arbitrary RDS instance would assert a
+   * causal link between two things that may not even be the same resource.
+   */
+  it('does not fire when neither agent declares an entity id', () => {
+    const result = synthesizeByRules([
+      {
+        agentKind: 'iac-drift',
+        targetName: 'terraform-prod',
+        signals: [
+          {
+            type: 'config_mismatch',
+            source: 'terraform_plan',
+            detail: 'instance class changed outside Terraform',
+            severity: 'warning',
+          },
+        ],
+      },
+      {
+        agentKind: 'aws-rds',
+        targetName: 'prod-db',
+        signals: [
+          {
+            type: 'connection',
+            source: 'rds_describe',
+            detail: 'connection limit reached',
+            severity: 'critical',
+          },
+        ],
+      },
+    ]);
+
+    expect(result.clusters.map((c) => c.reasoning).join(' ')).not.toContain(
+      'iac-out-of-band-change',
+    );
+  });
+});

From 8235c1cefc376ec217de7191c2be5dda3bed790c Mon Sep 17 00:00:00 2001
From: trs-80 <109326+trs-80@users.noreply.github.com>
Date: Sun, 9 Aug 2026 12:51:01 -0400
Subject: [PATCH 10/17] fix(scripts): stop clobbering the committed cast and
 leaking temp files
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Four CodeRabbit findings on the demo tooling, each reproduced before fixing.

pace-cast.mjs wrote outPath and only then verified that output bytes matched
input. record-demo.sh passes site/assets/demo.cast as outPath, so a failed
check left the rejected cast in place — having already overwritten the
committed asset — while printing "refusing to ship". Reproduced by forcing a
byte mismatch and watching the committed file's hash change. It now writes a
sibling temp and renames only after the check passes, with cleanup wired to
exit, SIGINT, SIGTERM and SIGHUP; verified across success, forced failure,
SIGTERM, SIGINT and an uncaught throw with zero leftovers.

record-demo.sh leaked a temp file per run: `mktemp -t ...).exp` appends `.exp`
to the path mktemp already created, so `cat` wrote to a different file and the
trap only removed the second one. Eight leaked zero-byte files were sitting in
$TMPDIR from earlier runs. Now uses mktemp -d with a recursive trap.

DECISION was documented as [approve|skip|reject] but accepted any argument and
was interpolated into the expect here-doc as Tcl, so a typo burned a live API
call. It is now validated, exiting 2. Going further than the finding:
$REPO_ROOT was interpolated into Tcl too, and a checkout path containing
brackets provably breaks the driver with "invalid command name" — the here-doc
is now quoted and the path and decision pass through the environment.

Adds an agg >= 1.9.0 check, since --select is load-bearing for the GIF cut and
only existence was verified before.

No behavioural change to the recording: same content-anchored Phase 6 cut,
same 2fps and 1MB budget, and pace-cast still verifies output bytes equal
input. site/assets/demo.cast is byte-identical, confirmed by hash.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 scripts/pace-cast.mjs  | 44 +++++++++++++++++++++++++++---
 scripts/record-demo.sh | 61 +++++++++++++++++++++++++++++++++++++-----
 2 files changed, 96 insertions(+), 9 deletions(-)

diff --git a/scripts/pace-cast.mjs b/scripts/pace-cast.mjs
index dcc6845..b74a100 100644
--- a/scripts/pace-cast.mjs
+++ b/scripts/pace-cast.mjs
@@ -28,7 +28,8 @@
  * Usage: node scripts/pace-cast.mjs <in.cast> <out.cast>
  */
 
-import { readFileSync, writeFileSync } from 'node:fs';
+import { readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
 
 // ── Pacing model (seconds) ───────────────────────────────────────────────
 const DELAY = {
@@ -141,7 +142,39 @@ for (const rawLine of raw.slice(1)) {
   }
 }
 
-writeFileSync(outPath, out.join('\n') + '\n');
+// Write to a sibling temp file and rename into place only once the byte check
+// below has passed. record-demo.sh passes a committed site asset as outPath, so
+// writing there before verifying would overwrite the good cast with the rejected
+// one — while printing "refusing to ship". The temp file is a sibling so the
+// rename stays on one filesystem and is therefore atomic.
+const tmpPath = join(dirname(outPath), `.${basename(outPath)}.pace-cast.${process.pid}.tmp`);
+
+let tmpPending = false;
+const removeTmp = () => {
+  if (!tmpPending) return;
+  tmpPending = false;
+  try {
+    unlinkSync(tmpPath);
+  } catch {
+    // Already gone: renamed into place, or removed by an earlier handler.
+  }
+};
+
+// Covers every exit path Node can observe — normal return, process.exit(), and
+// uncaught throws. Signals do not run 'exit' handlers by themselves, so they are
+// wired to it explicitly. (SIGKILL is uncatchable and cannot be covered.)
+process.on('exit', removeTmp);
+for (const signal of ['SIGINT', 'SIGTERM', 'SIGHUP']) {
+  process.on(signal, () => {
+    removeTmp();
+    process.exit(1);
+  });
+}
+
+// Set before the write, not after: a write that throws part-way through still
+// leaves a partial file to clean up.
+tmpPending = true;
+writeFileSync(tmpPath, out.join('\n') + '\n');
 
 // Verify content is unchanged — pacing must be timing-only.
 const bytesOf = (path) =>
@@ -155,11 +188,16 @@ const bytesOf = (path) =>
     .map((e) => e[2])
     .join('');
 
-if (bytesOf(inPath) !== bytesOf(outPath)) {
+if (bytesOf(inPath) !== bytesOf(tmpPath)) {
   console.error('pace-cast: FAILED — output bytes differ from input; refusing to ship');
+  console.error(`pace-cast: ${outPath} left untouched`);
+  // The 'exit' handler discards the rejected cast.
   process.exit(1);
 }
 
+renameSync(tmpPath, outPath);
+tmpPending = false;
+
 console.log(
   `pace-cast: ${originalWall.toFixed(1)}s -> ${pacedWall.toFixed(1)}s ` +
     `(${splitCount} bursts split, output bytes verified identical)`,
diff --git a/scripts/record-demo.sh b/scripts/record-demo.sh
index 12be588..5117fb8 100644
--- a/scripts/record-demo.sh
+++ b/scripts/record-demo.sh
@@ -28,6 +28,19 @@
 set -euo pipefail
 
 DECISION="${1:-approve}"
+
+# Validate before anything expensive happens: the recording makes a live billed
+# API call, so a typo must not be discovered only when the driver mistypes it at
+# the approval gate and the whole capture has to be thrown away.
+case "$DECISION" in
+  approve | skip | reject) ;;
+  *)
+    echo "error: invalid decision '$DECISION'. Expected: approve, skip, or reject." >&2
+    echo "Usage: bash scripts/record-demo.sh [approve|skip|reject]" >&2
+    exit 2
+    ;;
+esac
+
 REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 OUT_DIR="$REPO_ROOT/site/assets"
 CAST="$OUT_DIR/demo.cast"
@@ -48,6 +61,27 @@ for tool in asciinema agg expect; do
   }
 done
 
+# agg's --select is load-bearing for the content-anchored GIF cut below and only
+# exists from agg 1.9.0 (released 2026-05-29). On an older agg the run dies at the
+# very last step with a bare clap "unexpected argument" error — after the live,
+# billed recording has already been spent. Check the version up front instead.
+AGG_VERSION="$(agg --version 2>/dev/null | awk 'NR == 1 {print $2}')"
+AGG_MAJOR="${AGG_VERSION%%.*}"
+AGG_MINOR="${AGG_VERSION#*.}"
+AGG_MINOR="${AGG_MINOR%%.*}"
+if [[ "$AGG_MAJOR" =~ ^[0-9]+$ && "$AGG_MINOR" =~ ^[0-9]+$ ]]; then
+  if [ "$AGG_MAJOR" -lt 1 ] || { [ "$AGG_MAJOR" -eq 1 ] && [ "$AGG_MINOR" -lt 9 ]; }; then
+    echo "error: agg $AGG_VERSION is too old; --select needs agg >= 1.9.0." >&2
+    echo "       Upgrade with: brew upgrade agg" >&2
+    exit 1
+  fi
+else
+  # Only our own parsing failed (nightly build, patched --version output, ...).
+  # Refusing here would block a perfectly new agg, and the fallback is just
+  # today's behaviour: agg rejects --select itself if it really is too old.
+  echo "warning: could not parse agg version from '${AGG_VERSION:-}'; assuming >= 1.9.0" >&2
+fi
+
 [ -f "$REPO_ROOT/dist/cli/index.js" ] || {
   echo "error: dist/cli/index.js missing. Run 'pnpm run build' first." >&2
   exit 1
@@ -65,10 +99,21 @@ done
 
 mkdir -p "$OUT_DIR" "$(dirname "$RAW_CAST")"
 
-DRIVER="$(mktemp -t crisismode-demo-driver).exp"
-trap 'rm -f "$DRIVER"' EXIT
-
-cat > "$DRIVER" <<EXPECT_SCRIPT
+# A private directory, not a bare mktemp file: `mktemp -t X` creates a file at the
+# path it returns, so appending `.exp` to that path produced a second, unmanaged
+# file and leaked the mktemp one on every run. The 0700 directory also means the
+# driver is written into a location nothing else can pre-create or observe.
+TMP_BASE="${TMPDIR:-/tmp}"
+DRIVER_DIR="$(mktemp -d "${TMP_BASE%/}/crisismode-demo-driver.XXXXXX")"
+trap 'rm -rf "$DRIVER_DIR"' EXIT
+DRIVER="$DRIVER_DIR/driver.exp"
+
+# The here-doc is QUOTED: nothing is interpolated into Tcl source. Tcl substitutes
+# [...] and $... while parsing, so a repo path containing brackets would be
+# mis-parsed as a command, and an interpolated decision would be Tcl code rather
+# than a keystroke. Both values reach the driver through the environment instead,
+# where Tcl reads them as data and never re-parses them.
+cat > "$DRIVER" <<'EXPECT_SCRIPT'
 #!/usr/bin/env expect -f
 # Drives the demo through its interactive approval gate.
 #
@@ -81,12 +126,12 @@ set send_human {0.09 0.02 1 0.20 0.40}
 
 # A beat before the first keystroke so the recording does not open mid-command.
 sleep 1.2
-spawn -noecho node "$REPO_ROOT/dist/cli/index.js" demo
+spawn -noecho node $env(CRISISMODE_DEMO_CLI) demo
 expect {
   -re {Enter your decision \(approve/skip/reject\): } {
     # Let the viewer read the approval panel before answering.
     sleep 2.5
-    send -h -- "$DECISION"
+    send -h -- $env(CRISISMODE_DEMO_DECISION)
     sleep 0.6
     send -- "\r"
   }
@@ -104,10 +149,14 @@ echo "==> recording ${COLS}x${ROWS} -> $RAW_CAST"
 rm -f "$RAW_CAST"
 
 # ANTHROPIC_API_KEY is inherited deliberately: Phase 5 must reach the real API.
+# CRISISMODE_DEMO_* carry the two values the expect driver needs, as data rather
+# than as interpolated Tcl source.
 env TERM=xterm-256color \
     FORCE_COLOR=3 \
     COLUMNS="$COLS" \
     LINES="$ROWS" \
+    CRISISMODE_DEMO_CLI="$REPO_ROOT/dist/cli/index.js" \
+    CRISISMODE_DEMO_DECISION="$DECISION" \
   asciinema rec "$RAW_CAST" \
     --window-size "${COLS}x${ROWS}" \
     --overwrite \

From e904513277f697cbd5f05f5de3a2db071c92b41a Mon Sep 17 00:00:00 2001
From: trs-80 <109326+trs-80@users.noreply.github.com>
Date: Sun, 9 Aug 2026 12:51:14 -0400
Subject: [PATCH 11/17] docs: fix the maturity rule and an unsafe
 cache-eviction example
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Five review findings, all verified against the code before changing anything;
two were narrower than the underlying defect.

The maturity guidance required execute-verified recovery before a contributor
could use `live_validated`, but docs/coverage.md separates diagnosis maturity
from execute-verified recovery: a deployment that validated diagnosis can
legitimately be `live_validated`, and `dry_run_only` covers dry-run-validated
diagnosis. As written it pushed contributors to under-report. The finding named
your-first-agent.md, but the same rule was wrong in CONTRIBUTING.md — the
canonical location the guide links to — so both are fixed.

The playbook example was worse than mislabelled. A step carried the
`cache.expiry.trigger` capability at routine risk while the command scanned `*`
and unlinked the first 1000 keys regardless of TTL, so a contributor copying it
would delete live keys and cause a cache-miss storm. The replacement deletes
nothing itself: it relies on Redis passive expiration through a bounded
1000-key TTL touch, leaving live and persistent keys in place, and it validates
at 13 safety checks through the real CLI. The same example had a broken
three-backtick fence that rendered half of it as body text.

Also: corrects the flag-audit claim in the docs-pass report without rewriting
what was true when it was written, and labels 17 unlabelled code fences
(MD040) — 10 more than the review listed. MD040 is now zero across every file
outside docs/superpowers, and all links and anchors resolve.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 CONTRIBUTING.md                               | 17 ++++++----
 GETTING_STARTED.md                            |  9 ++++--
 QUICKSTART.md                                 |  2 +-
 README.md                                     |  4 +--
 docs/agents/backup-verification.md            |  8 ++---
 docs/architecture.md                          |  2 +-
 docs/cli-reference.md                         | 13 ++++----
 .../2026-08-09-docs-pass-report.md            | 21 ++++++++++--
 docs/guides/creating-a-check-plugin.md        |  4 +--
 docs/guides/creating-a-recovery-agent.md      |  2 +-
 docs/guides/your-first-agent.md               | 27 ++++++++++++----
 docs/playbook-authoring.md                    | 32 +++++++++++++++----
 playbooks/examples/redis-memory-pressure.md   | 10 ++++--
 13 files changed, 105 insertions(+), 46 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 3998924..5e9b63d 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -40,7 +40,7 @@ npx tsx src/cli/index.ts scan        # run the CLI from source
 
 Check plugins are standalone shell scripts. No TypeScript needed.
 
-1. Scaffold with `crisismode init --agent <name>` (creates the directory,
+1. Scaffold with `crisismode init --plugin <name>` (creates the directory,
    `manifest.json`, and a stub `check.sh`), or create a directory in `checks/`
    by hand with a `manifest.json` and a `check.sh`
 2. Test with `crisismode scan`
@@ -86,10 +86,15 @@ best-effort and labels its findings as leads rather than conclusions in operator
 output. That default is the point.
 
 Only claim `live_validated` when the agent has actually been run against a real
-deployment of its target system, and say in the PR description what you ran it
-against. "The live client compiles" is not validation. If you validated diagnosis
-in dry-run but never executed a mutating plan, `dry_run_only` is the accurate
-label.
+deployment of its target system and diagnosed it correctly, and say in the PR
+description what you ran it against. "The live client compiles" is not validation.
+The label describes *diagnosis*: a diagnosis-only agent can be `live_validated`
+without any mutating run — `src/agent/tls/`, `src/agent/disk/`, and
+`src/agent/backup/` are. If your agent has a mutating recovery path and its only
+live exposure was dry-run, `dry_run_only` is the accurate label. Whether a
+mutating plan ran and the fault was verified resolved is a separate, stricter
+claim, tracked under
+[Execute-verified recovery](docs/coverage.md#execute-verified-recovery).
 
 Where each agent currently stands is tracked in
 [docs/coverage.md](docs/coverage.md) — update it in the same PR that changes a
@@ -108,7 +113,7 @@ maturity value.
   // Copyright 2026 CrisisMode Contributors
   ```
 - **Conventional Commits** for all commit messages:
-  ```
+  ```text
   feat(agent): add MySQL recovery agent
   fix(engine): handle timeout in step execution
   test(redis): add memory pressure scenario tests
diff --git a/GETTING_STARTED.md b/GETTING_STARTED.md
index 86e0c2f..5a8d303 100644
--- a/GETTING_STARTED.md
+++ b/GETTING_STARTED.md
@@ -15,8 +15,11 @@ agents against real degraded PostgreSQL.
 - **Node.js** >= 22 (recommended: [fnm](https://github.com/Schniz/fnm) or
   [nvm](https://github.com/nvm-sh/nvm)) — Node 18 and 20 are end-of-life; CI
   tests 22 and 24
-- **pnpm** — `npm install -g pnpm`. The exact version is pinned via
-  `packageManager` in `package.json`
+- **pnpm** — install the version pinned by `packageManager` in `package.json`
+  (currently `pnpm@10.30.3`): `npm install -g pnpm@10.30.3`. A bare
+  `npm install -g pnpm` gets the latest release instead, which can resolve the
+  lockfile differently than CI — CI takes its version from that same
+  `packageManager` field
 - **Podman** — for the containerized test environment:
   `brew install podman && podman machine init && podman machine start`
 - **Git** — `git clone git@github.com:trs-80/crisismode.git`
@@ -173,7 +176,7 @@ see [docs/readiness.md](docs/readiness.md).
 
 Every agent follows the same six-file pattern:
 
-```
+```text
 src/agent/<system>/
   backend.ts        # Interface both simulator and live client implement
   simulator.ts      # In-memory implementation for demos and tests
diff --git a/QUICKSTART.md b/QUICKSTART.md
index e2797fc..adaa400 100644
--- a/QUICKSTART.md
+++ b/QUICKSTART.md
@@ -37,7 +37,7 @@ crisismode
 `scan` is the default command, so bare `crisismode` and `crisismode scan` do the
 same thing.
 
-```
+```text
   Scanning for services...
   Detected services:
     ✓ postgresql at localhost:5432
diff --git a/README.md b/README.md
index c9169c9..64879aa 100644
--- a/README.md
+++ b/README.md
@@ -55,7 +55,7 @@ checks it:
 crisismode                 # zero-config health scan (the default command)
 ```
 
-```
+```text
   System Health Score: 100/100
   Scanned at 2026-08-09T15:09:00.480Z (586ms)
 
@@ -88,7 +88,7 @@ shows you the plan; mutations require an explicit `--execute`.
 Live mode against real PostgreSQL replication lag (local podman test
 environment), abridged:
 
-```
+```text
   Phase 3: Diagnosis (Live — AI-Powered)
   🤖 AI analyzing system state...
      Scenario:    replication_lag_cascade
diff --git a/docs/agents/backup-verification.md b/docs/agents/backup-verification.md
index f2d0d13..3497421 100644
--- a/docs/agents/backup-verification.md
+++ b/docs/agents/backup-verification.md
@@ -41,7 +41,7 @@ crisismode scan
 
 The agent appears in scan results with finding ID prefix `BKUP`:
 
-```
+```text
 BKUP-001  unhealthy  Backup failures detected. Missing or corrupted backups require immediate attention.
 ```
 
@@ -198,7 +198,7 @@ Backups are healthy, but their size means estimated restore time may exceed reco
 
 The agent uses a **strategy pattern** where backup technologies are pluggable providers:
 
-```
+```text
 BackupVerificationAgent (coordinator)
   └── BackupBackend
         └── verifyAll(configs[]) → BackupVerificationReport
@@ -278,7 +278,7 @@ The agent reports four health signals during `assessHealth`:
 
 The live client recognizes these file patterns:
 
-```
+```text
 .sql  .sql.gz  .sql.bz2  .sql.xz  .sql.zst
 .dump  .dump.gz
 .tar  .tar.gz  .tgz  .tar.bz2  .tar.xz  .tar.zst
@@ -387,7 +387,7 @@ Simulator states: `no_backups_found`, `stale_backup`, `size_anomaly`, `integrity
 
 ## File structure
 
-```
+```text
 src/agent/backup/
   backend.ts            # BackupBackend + BackupProvider interfaces
   simulator.ts          # In-memory simulator (7 states, 6 failure scenarios)
diff --git a/docs/architecture.md b/docs/architecture.md
index 4bc7b2e..68ff175 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -130,7 +130,7 @@ A `RecoveryPlan` contains metadata, impact assessment, an ordered list of steps,
 
 Playbooks are Markdown files with YAML frontmatter that describe recovery procedures. They compile to the same `RecoveryPlan` structure used by code-based agents.
 
-```
+```text
 Markdown + YAML frontmatter
         |
         v
diff --git a/docs/cli-reference.md b/docs/cli-reference.md
index 7eb2442..4cb0a2d 100644
--- a/docs/cli-reference.md
+++ b/docs/cli-reference.md
@@ -33,7 +33,7 @@ From a source checkout, substitute `node dist/cli/index.js` (after
 | Command | What it does |
 |---|---|
 | `crisismode init [path]` | Generate `crisismode.yaml` |
-| `crisismode init --agent <name>` | Scaffold a check plugin |
+| `crisismode init --plugin <name>` | Scaffold a check plugin (`--agent` is a deprecated alias) |
 | `crisismode demo` | Simulator demo — full pipeline, no infrastructure |
 | `crisismode webhook` | Start a webhook receiver for Prometheus AlertManager |
 | `crisismode watch` | Continuous shadow observation |
@@ -65,10 +65,11 @@ This is the complete set — there are no per-command flags beyond these.
 | `--config <path>` | all | Path to `crisismode.yaml` |
 | `--target <name>` | all | Target name from config |
 | `--category <kinds>` | `scan` | Comma-separated service kinds to scan |
-| `--agent <name>` | `init` | Scaffold a check plugin instead of a config file |
+| `--plugin <name>` | `init` | Scaffold a check plugin instead of a config file |
+| `--agent <name>` | `init` | Deprecated alias for `--plugin`. Still scaffolds, prints a deprecation notice; `--plugin` wins if both are given |
 | `--execute` | `recover`, `webhook` | Enable mutations. Without it, everything is dry-run |
 | `--health-only` | `recover` | Health check only, no diagnosis |
-| `--local` | `registry install`, `init --agent` | Install to `./checks/` instead of `~/.crisismode/checks/` |
+| `--local` | `registry install` | Install to `./checks/` instead of `~/.crisismode/checks/` |
 | `--force` | `registry install` | Overwrite an existing plugin installation |
 | `--terse` | all | Suppress plain-language explanations and risk framing. Human output only — `--json` always carries the full data |
 | `--json` | all | Machine-readable JSON output |
@@ -104,14 +105,14 @@ Three modes, auto-selected:
 
 A `scan` row has 4 fields:
 
-```
+```text
 scan\t<score>\t<scanned_at>\t<duration_ms>
 ```
 
 Every `finding` row has the same 7 fields, whether or not the finding has a
 remediation guide, so the column count never shifts:
 
-```
+```text
 finding\t<id>\t<service>\t<status>\t<confidence>\t<summary>\t<guide_refs>
 ```
 
@@ -127,7 +128,7 @@ finding\t<id>\t<service>\t<status>\t<confidence>\t<summary>\t<guide_refs>
 
 `triage` uses the same shape with a `triage` row and one `layer` row per probe:
 
-```
+```text
 triage\t<verdict>\t<checked_at>\t<duration_ms>
 layer\t<name>\t<result>\t<evidence>
 ```
diff --git a/docs/guide-verification/2026-08-09-docs-pass-report.md b/docs/guide-verification/2026-08-09-docs-pass-report.md
index b0f7cfb..1a622d2 100644
--- a/docs/guide-verification/2026-08-09-docs-pass-report.md
+++ b/docs/guide-verification/2026-08-09-docs-pass-report.md
@@ -112,9 +112,19 @@ weaker claim.
 Everything documented was checked at the real surface after `pnpm run build`.
 
 - **Flags:** the complete flag set was taken from `node dist/cli/index.js --help`.
-  No invented flags — an audit of every `--flag` across all docs found only
-  `--json`, `--target`, `--agent`, all real. (Subcommand `--help` prints the
-  global help, so the top-level list is authoritative.)
+  No invented flags. (Subcommand `--help` prints the global help, so the top-level
+  list is authoritative.)
+
+  *Correction (same day):* this bullet originally read that an audit of every
+  `--flag` across all docs found only `--json`, `--target`, and `--agent`. Those
+  three are the flags that appear in the *onboarding* docs; `docs/cli-reference.md`
+  documents the full surface. Re-verified against a fresh `pnpm run build`, its
+  flag table matches `--help` exactly, all 15 entries: `--plugin`, `--agent`,
+  `--config`, `--target`, `--category`, `--terse`, `--execute`, `--health-only`,
+  `--local`, `--force`, `--json`, `--no-color`, `--verbose`, `-h`/`--help`,
+  `-v`/`--version`. `--agent` has since become a deprecated alias for `--plugin`
+  (see the superseded note under "Scan suggested a flag that does not exist"
+  below).
 - **Commands run:** `scan`, `scan --category dns`, `scan --json`/pipe, `triage`,
   `down stripe github`, `down --badflag` (exit 2 confirmed), `agent list`,
   `completions zsh`, `init --agent`, `init --plugin`, `playbook validate`,
@@ -165,6 +175,11 @@ recognized: it falls through to the positional path argument and writes a *confi
 file* named `my-check` instead of scaffolding a plugin. Corrected to `--agent`,
 which I verified produces `manifest.json` + an executable `check.sh`.
 
+*Superseded (same day):* `--agent` was the wrong name for a flag that scaffolds a
+check plugin — "agent" means `RecoveryAgent` everywhere else in this codebase.
+`--plugin` is now the canonical flag and `--agent` a deprecated alias, so both the
+scan hint and this fix now read `crisismode init --plugin my-check`.
+
 ### Verification
 
 `pnpm run typecheck`, `pnpm run lint`, and `pnpm test` (3179 passed / 24 skipped,
diff --git a/docs/guides/creating-a-check-plugin.md b/docs/guides/creating-a-check-plugin.md
index 4a991fb..ef34352 100644
--- a/docs/guides/creating-a-check-plugin.md
+++ b/docs/guides/creating-a-check-plugin.md
@@ -20,7 +20,7 @@ Three verbs are supported:
 
 Each check plugin lives in its own directory under `checks/`:
 
-```
+```text
 checks/
   check-mysql-connection/
     manifest.json       # Plugin metadata and capabilities
@@ -410,7 +410,7 @@ Thousands of Nagios/Icinga/Checkmk plugins exist. Wrap any of them:
 
 Nagios plugins receive **no stdin**. They output a status line optionally followed by `|` and performance data:
 
-```
+```text
 OK - Load 0.85 (16 CPUs), up 5d 3h | load=0.85;32;64;0; uptime=445736s;;;;
 ```
 
diff --git a/docs/guides/creating-a-recovery-agent.md b/docs/guides/creating-a-recovery-agent.md
index c5d7efc..08283fe 100644
--- a/docs/guides/creating-a-recovery-agent.md
+++ b/docs/guides/creating-a-recovery-agent.md
@@ -44,7 +44,7 @@ The agent never executes recovery actions directly. It builds a `RecoveryPlan` c
 
 Every agent follows this structure:
 
-```
+```text
 src/agent/<system>/
   backend.ts          # Interface for querying the target system
   simulator.ts        # In-memory implementation for demos and tests
diff --git a/docs/guides/your-first-agent.md b/docs/guides/your-first-agent.md
index 140f64e..28a4f9f 100644
--- a/docs/guides/your-first-agent.md
+++ b/docs/guides/your-first-agent.md
@@ -30,7 +30,7 @@ If you just need to check a port or validate a certificate, a [check plugin](you
 
 Every agent follows this structure:
 
-```
+```text
 src/agent/<system>/
   backend.ts        # Interface for querying the target system
   simulator.ts      # In-memory implementation for demos and tests
@@ -769,12 +769,25 @@ Two rules the helper enforces (and that you must not work around):
   not connect" finding. Never catch a live-client error and silently fall
   back to simulated data — that reports fake health for a real system.
 
-A working live client on its own does **not** change your maturity label. Once you
-have run the agent against a real deployment and confirmed it diagnoses correctly,
-move `plugin.maturity` to `"dry_run_only"` (diagnosis validated, no mutating run
-verified) or `"live_validated"` (a mutating recovery actually ran and the fault
-was verified resolved). Until then it stays `"simulator_only"` and CrisisMode
-labels its findings as leads.
+A working live client on its own does **not** change your maturity label. The label
+tracks how far your **diagnosis** has been proven against real infrastructure:
+
+- `"simulator_only"` — where every new agent starts, and where it stays until you
+  have confirmed diagnosis against a real deployment. CrisisMode labels its
+  findings as leads, not conclusions.
+- `"dry_run_only"` — diagnosis validated only in dry-run against real
+  infrastructure (real reads, mutations logged instead of executed), with the
+  agent's mutating recovery path never exercised live.
+- `"live_validated"` — you have run the agent against a real deployment of its
+  target system and confirmed it diagnoses correctly there. This does **not**
+  require a mutating recovery: several in-tree agents are `live_validated` on
+  diagnosis alone (`src/agent/tls/`, `src/agent/disk/`, `src/agent/backup/`).
+
+Whether a mutating plan actually ran and the fault was verified resolved is a
+separate, stricter claim that the maturity label does not encode — it is tracked
+under [Execute-verified recovery](../coverage.md#execute-verified-recovery), which
+today covers three scenarios. Say in the PR description what you validated
+against, and update [docs/coverage.md](../coverage.md) in the same PR.
 
 ## Distributing as a Plugin
 
diff --git a/docs/playbook-authoring.md b/docs/playbook-authoring.md
index 3d95e8b..caacd13 100644
--- a/docs/playbook-authoring.md
+++ b/docs/playbook-authoring.md
@@ -215,7 +215,7 @@ The rollback section is captured as free-text and included in the compiled plan'
 
 ## Complete Example
 
-```markdown
+````markdown
 ---
 name: "redis-memory-pressure"
 version: "1.0.0"
@@ -251,16 +251,22 @@ redis-cli info memory
 ### 3. Capture state
 - type: checkpoint
 
-### 4. Evict expired keys
+### 4. Reclaim keys already past their TTL
 - type: system_action
 - risk: routine
 - capability: cache.expiry.trigger
 - target: redis-primary
+- preserve: keyspace_before
 - precondition: "Redis is accepting commands"
 - success: "Memory usage below 85%"
 
 ```sh
-redis-cli --scan --pattern '*' | head -1000 | xargs redis-cli unlink
+# Bounded sample of the keyspace. Reading a key that is already past its TTL is
+# what makes Redis reclaim it; keys still inside their TTL, and keys with no TTL
+# at all, are read and left alone.
+redis-cli --scan --count 100 | head -n 1000 | while read -r key; do
+  redis-cli TTL "$key" > /dev/null
+done
 ```
 
 ### 5. Verify recovery
@@ -271,9 +277,21 @@ redis-cli --scan --pattern '*' | head -1000 | xargs redis-cli unlink
 
 ## Rollback
 
-If eviction causes cache miss storms:
-1. Monitor hit rate for 5 minutes
-2. If hit rate drops below 80%, alert the application team
-```
+Reclaiming already-expired keys is not reversible, and does not remove anything
+applications can still read. If memory stays above 85%:
+1. Escalate for `maxmemory` and eviction-policy tuning
+2. Watch the hit rate for 5 minutes before any further change
+````
+
+**Why step 4 is `routine`.** The command only reclaims keys Redis already considers
+expired, and it is bounded to a 1000-key sample, so it cannot cause a cache-miss
+storm. Deleting keys that have *not* expired — what
+`redis-cli --scan --pattern '*' | xargs redis-cli unlink` would do — is a different
+action: it drops live cache entries, so it belongs at `elevated` risk with
+`preserve` declared and a blast radius that admits the impact. That is exactly how
+the built-in Redis agent declares its aggressive-expiry step (`elevated`, with an
+`INFO keyspace` capture — see `src/agent/redis/agent.ts`). Risk labels are read
+under incident pressure; a mislabelled step is how a "routine" playbook takes out a
+cache.
 
 For more playbook examples, see the `playbooks/examples/` directory.
diff --git a/playbooks/examples/redis-memory-pressure.md b/playbooks/examples/redis-memory-pressure.md
index 382e532..abfa917 100644
--- a/playbooks/examples/redis-memory-pressure.md
+++ b/playbooks/examples/redis-memory-pressure.md
@@ -55,13 +55,17 @@ redis-cli DBSIZE
 ### 4. Clear expired keys
 - type: system_action
 - risk: routine
-- description: Force lazy expiration scan to reclaim memory from expired keys
+- description: Reclaim memory from keys already past their TTL by touching a bounded sample of the keyspace
 - target: redis-primary
 - capability: cache.expiry.trigger
 
 ```sh
-redis-cli DEBUG JMAP
-redis-cli SCAN 0 COUNT 10000
+# Reading a key that is already past its TTL is what makes Redis reclaim it
+# (passive expiration). Keys still inside their TTL, and keys with no TTL at all,
+# are read and left alone. Bounded to a 10000-key sample.
+redis-cli --scan --count 100 | head -n 10000 | while read -r key; do
+  redis-cli TTL "$key" > /dev/null
+done
 ```
 
 ### 5. Evaluate memory after cleanup

From f00cf664d201439eceb9b436c740e32dab9be3e5 Mon Sep 17 00:00:00 2001
From: trs-80 <109326+trs-80@users.noreply.github.com>
Date: Sun, 9 Aug 2026 13:18:13 -0400
Subject: [PATCH 12/17] fix(cli): say "no health check plugins" when that is
 what was counted
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Both findings from a local CodeRabbit review of 075a616..e904513, which the
GitHub integration could not review because it was rate limited.

scan.ts reported "No check plugins found", but the count it checks is
healthPlugins — filtered at line 429 to plugins declaring the `health` verb.
A repo with only diagnose-only or plan-only plugins would be told nothing was
found while plugins were in fact discovered.

The docs-pass report also still recorded the scan hint as `init --agent
my-check`, contradicting its own superseding note four lines earlier that says
both now read `--plugin`.

Verified at the real CLI, not only in tests.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 docs/guide-verification/2026-08-09-docs-pass-report.md | 6 +++++-
 src/cli/commands/scan.ts                               | 2 +-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/docs/guide-verification/2026-08-09-docs-pass-report.md b/docs/guide-verification/2026-08-09-docs-pass-report.md
index 1a622d2..9b96d5c 100644
--- a/docs/guide-verification/2026-08-09-docs-pass-report.md
+++ b/docs/guide-verification/2026-08-09-docs-pass-report.md
@@ -190,7 +190,11 @@ scan hint and this fix now read `crisismode init --plugin my-check`.
 - PostgreSQL target on a wrong port → `Investigate: crisismode diagnose prod-db`,
   and `diagnose prod-db` resolves (`Target: prod-db (postgresql)`) while the old
   `diagnose PG-001` still errors.
-- Scan with no plugins discovered → hint now reads `crisismode init --agent my-check`.
+- Scan with no health plugins discovered → hint now reads
+  `crisismode init --plugin my-check`. The message says "No health check plugins
+  found" rather than "No check plugins found", because the count it reports is
+  filtered to plugins declaring the `health` verb — a diagnose-only or plan-only
+  plugin is discovered but not counted here.
 
 ## Noted, not changed
 
diff --git a/src/cli/commands/scan.ts b/src/cli/commands/scan.ts
index e08b6d2..2901871 100644
--- a/src/cli/commands/scan.ts
+++ b/src/cli/commands/scan.ts
@@ -571,7 +571,7 @@ export async function runScan(opts: ScanOptions): Promise<ScanResult> {
 
   // Hint about check plugins when none are discovered
   if (healthPlugins.length === 0) {
-    printInfo('No check plugins found. Add custom checks in ./checks/ or scaffold one with: crisismode init --plugin my-check');
+    printInfo('No health check plugins found. Add custom checks in ./checks/ or scaffold one with: crisismode init --plugin my-check');
   }
 
   return result;

From c3ef2d710c343d2b8f025bd9217afb9827f5b501 Mon Sep 17 00:00:00 2001
From: trs-80 <109326+trs-80@users.noreply.github.com>
Date: Sun, 9 Aug 2026 13:33:41 -0400
Subject: [PATCH 13/17] fix(cli): emit a machine-readable record from ask,
 including truncation
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`crisismode ask --json` reached machine mode but printed the raw answer with
console.log, while the truncation notice went through printWarning/printInfo —
both of which return early when the output mode is machine (output.ts:460 and
:470). A machine consumer therefore received a partial answer with no marker.
In practice it was worse than reported: the command emitted no JSON at all.

That defeats the point of the truncation work earlier in this PR. A cut-off
answer must never be presentable as a complete one, and an automated caller is
the one least able to notice.

Both single-shot and REPL paths now emit one
{"type":"ask",question,answer,source,truncated} JSONL record per turn through
the existing jsonOut() convention, matching what down, triage and readiness
already produce. Human and pipe output are byte-identical and the warning
wording is untouched.

11 hermetic tests with @anthropic-ai/sdk mocked, including a guard proven to
fail if the marker is suppressed again.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 src/__tests__/ask-machine-output.test.ts | 298 +++++++++++++++++++++++
 src/cli/commands/ask.ts                  |  95 ++++++--
 2 files changed, 374 insertions(+), 19 deletions(-)
 create mode 100644 src/__tests__/ask-machine-output.test.ts

diff --git a/src/__tests__/ask-machine-output.test.ts b/src/__tests__/ask-machine-output.test.ts
new file mode 100644
index 0000000..a9264f7
--- /dev/null
+++ b/src/__tests__/ask-machine-output.test.ts
@@ -0,0 +1,298 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 CrisisMode Contributors
+
+/**
+ * Regression: `ask --json` must not present a cut-off answer as a complete one.
+ *
+ * The truncation notice both `ask` modes print goes through `printWarning` and
+ * `printInfo`, which return early when the output mode is `machine`. The answer
+ * itself went out through a bare `console.log`. So `--json` handed back a
+ * partial answer with nothing marking it as partial — to the one consumer least
+ * able to notice, since it cannot read the prose and judge for itself.
+ *
+ * The fix is a `{ type: 'ask', ... }` JSONL record carrying `truncated`, in the
+ * same shape `down`, `triage`, and `readiness` emit via `jsonOut`. These tests
+ * pin the field, pin that the whole machine stream stays parseable, and pin
+ * that human mode still says exactly what it said before.
+ *
+ * No test in this file touches the network.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import type * as AnthropicSdk from '@anthropic-ai/sdk';
+import type * as NodeFs from 'node:fs';
+
+const { createMock, lines } = vi.hoisted(() => ({
+  createMock: vi.fn(),
+  lines: { queue: [] as string[] },
+}));
+
+vi.mock('@anthropic-ai/sdk', async (importOriginal) => {
+  const actual = await importOriginal<typeof AnthropicSdk>();
+  return {
+    ...actual,
+    default: class {
+      messages = { create: createMock };
+    },
+  };
+});
+
+vi.mock('../framework/network-profile.js', () => ({
+  getNetworkProfile: vi.fn(() => null),
+  isInternetAvailable: vi.fn(() => true),
+}));
+
+// Scripted line queue instead of stdin, as in ask-token-budget.test.ts.
+vi.mock('node:readline', () => ({
+  createInterface: () => ({
+    prompt: () => {},
+    close: () => {},
+    async *[Symbol.asyncIterator]() {
+      for (const line of lines.queue) yield line;
+    },
+  }),
+}));
+
+// Without this the REPL would read a real ~/.crisismode/watch-state.json on a
+// developer machine but not in CI.
+vi.mock('node:fs', async (importOriginal) => {
+  const actual = await importOriginal<typeof NodeFs>();
+  return { ...actual, existsSync: () => false, default: { ...actual, existsSync: () => false } };
+});
+
+import { runAsk, runAskRepl } from '../cli/commands/ask.js';
+import { configure } from '../cli/output.js';
+
+/**
+ * A truncated answer that ends on a period and reads as finished — the case no
+ * text heuristic can catch, and the reason `truncated` has to be carried
+ * explicitly rather than inferred downstream.
+ */
+const TRUNCATED_BUT_READS_FINISHED =
+  'Check whether the pooler is leaking connections:\n' +
+  '```sql\nSELECT count(*), state FROM pg_stat_activity GROUP BY state;\n```\n' +
+  '- If idle-in-transaction dominates (connection leak), restart the offending service/pod rather than the DB.';
+
+const COMPLETE_ANSWER =
+  'HIGH urgency. Start by separating "cannot keep up" from "cannot receive":\n' +
+  '```sql\nSELECT client_addr, write_lag, replay_lag FROM pg_stat_replication;\n```\n' +
+  'Report back what that shows and I will narrow it down.';
+
+function reply(text: string, stopReason = 'end_turn') {
+  return { content: [{ type: 'text', text }], stop_reason: stopReason };
+}
+
+interface AskRecord {
+  type: string;
+  question: string;
+  answer: string;
+  source: string;
+  truncated: boolean;
+}
+
+describe('ask machine output', () => {
+  let originalApiKey: string | undefined;
+  let logged: string[];
+
+  beforeEach(() => {
+    originalApiKey = process.env.ANTHROPIC_API_KEY;
+    process.env.ANTHROPIC_API_KEY = 'test-key';
+    createMock.mockReset();
+    lines.queue = [];
+    logged = [];
+    vi.spyOn(console, 'log').mockImplementation((...args: unknown[]) => {
+      logged.push(args.join(' '));
+    });
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+    configure({ json: true });
+  });
+
+  afterEach(() => {
+    // Module-level output state: leave it as the CLI's default so ordering
+    // between describe blocks in this file cannot change what they assert.
+    configure({ json: false, mode: 'human' });
+    vi.restoreAllMocks();
+    if (originalApiKey !== undefined) {
+      process.env.ANTHROPIC_API_KEY = originalApiKey;
+    } else {
+      delete process.env.ANTHROPIC_API_KEY;
+    }
+  });
+
+  /** Every emitted line parsed as JSON. Throws — loudly — on any non-JSON line. */
+  const records = (): AskRecord[] =>
+    logged.filter((l) => l !== '').map((l) => JSON.parse(l) as AskRecord);
+
+  it('marks a truncated single-shot answer with truncated: true', async () => {
+    createMock.mockResolvedValue(reply(TRUNCATED_BUT_READS_FINISHED, 'max_tokens'));
+
+    await runAsk('my database connections are maxed out');
+
+    const [record] = records();
+    expect(record).toMatchObject({
+      type: 'ask',
+      question: 'my database connections are maxed out',
+      answer: TRUNCATED_BUT_READS_FINISHED,
+      source: 'ai',
+      truncated: true,
+    });
+  });
+
+  /**
+   * The guard. If the truncation marker is ever suppressed in machine mode
+   * again — by reverting to a bare `console.log(answer)` plus a `printWarning`
+   * that machine mode drops — the answer arrives as raw prose, `JSON.parse`
+   * throws on it, and no `truncated: true` field exists to find. Both halves
+   * fail here rather than reaching a machine consumer.
+   */
+  it('would fail if the truncation marker were suppressed again', async () => {
+    createMock.mockResolvedValue(reply(TRUNCATED_BUT_READS_FINISHED, 'max_tokens'));
+
+    await runAsk('my database connections are maxed out');
+
+    // Nothing in the answer text says it is partial, so the field is the whole
+    // signal — the operator-facing sentence never reaches a machine consumer.
+    expect(TRUNCATED_BUT_READS_FINISHED.endsWith('.')).toBe(true);
+    expect(logged.join('\n')).not.toContain('cut off');
+
+    expect(() => records()).not.toThrow();
+    expect(records().some((r) => r.truncated === true)).toBe(true);
+  });
+
+  it('emits nothing but JSON — no banner, blank lines, or prose', async () => {
+    createMock.mockResolvedValue(reply(TRUNCATED_BUT_READS_FINISHED, 'max_tokens'));
+
+    await runAsk('my database connections are maxed out');
+
+    expect(logged.filter((l) => l === '')).toHaveLength(0);
+    for (const line of logged) {
+      expect(() => JSON.parse(line)).not.toThrow();
+    }
+    expect(logged).toHaveLength(1);
+  });
+
+  it('reports truncated: false for a complete single-shot answer', async () => {
+    createMock.mockResolvedValue(reply(COMPLETE_ANSWER, 'end_turn'));
+
+    await runAsk('my postgres replica is lagging');
+
+    expect(records()[0]).toMatchObject({ source: 'ai', truncated: false });
+  });
+
+  /**
+   * "AI diagnosis unavailable. Showing basic guidance." is another warning
+   * machine mode drops. The record carries it as `source`, so a consumer can
+   * tell a model answer from locally generated fallback text.
+   */
+  it('names a fallback answer as a fallback', async () => {
+    createMock.mockRejectedValue(new Error('overloaded_error'));
+
+    await runAsk('my postgres replica is lagging');
+
+    expect(records()[0]).toMatchObject({ source: 'fallback', truncated: false });
+  });
+
+  it('marks a truncated REPL turn with truncated: true', async () => {
+    lines.queue = ['give me the full remediation sequence', '/exit'];
+    createMock.mockResolvedValue(reply(TRUNCATED_BUT_READS_FINISHED, 'max_tokens'));
+
+    await runAskRepl();
+
+    expect(records()).toEqual([
+      {
+        type: 'ask',
+        question: 'give me the full remediation sequence',
+        answer: TRUNCATED_BUT_READS_FINISHED,
+        source: 'ai',
+        truncated: true,
+      },
+    ]);
+  });
+
+  it('emits one record per REPL turn, each carrying its own truncated flag', async () => {
+    lines.queue = ['my postgres replica is lagging', 'give me the full sequence', '/exit'];
+    createMock
+      .mockResolvedValueOnce(reply(COMPLETE_ANSWER, 'end_turn'))
+      .mockResolvedValueOnce(reply(TRUNCATED_BUT_READS_FINISHED, 'max_tokens'));
+
+    await runAskRepl();
+
+    expect(records().map((r) => r.truncated)).toEqual([false, true]);
+  });
+
+  it('reports a REPL error as a JSON error record rather than silence', async () => {
+    lines.queue = ['my postgres replica is lagging', '/exit'];
+    createMock.mockRejectedValue(new Error('overloaded_error'));
+
+    await runAskRepl();
+
+    expect(logged.map((l) => JSON.parse(l))).toEqual([
+      { type: 'error', message: 'AI error: overloaded_error' },
+    ]);
+  });
+});
+
+describe('ask human output is unchanged by the machine record', () => {
+  let originalApiKey: string | undefined;
+  let logged: string[];
+
+  beforeEach(() => {
+    originalApiKey = process.env.ANTHROPIC_API_KEY;
+    process.env.ANTHROPIC_API_KEY = 'test-key';
+    createMock.mockReset();
+    lines.queue = [];
+    logged = [];
+    vi.spyOn(console, 'log').mockImplementation((...args: unknown[]) => {
+      logged.push(args.join(' '));
+    });
+    configure({ json: false, mode: 'human' });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    if (originalApiKey !== undefined) {
+      process.env.ANTHROPIC_API_KEY = originalApiKey;
+    } else {
+      delete process.env.ANTHROPIC_API_KEY;
+    }
+  });
+
+  // The wording of these two sentences is deliberate; they are asserted
+  // verbatim so the machine path cannot be "unified" by rewriting them.
+  const SINGLE_SHOT_NOTICE =
+    'This answer is cut off — it hit the response length limit, so the last point above is incomplete.';
+
+  it('still prints the single-shot truncation notice verbatim, and no JSON', async () => {
+    createMock.mockResolvedValue(reply(TRUNCATED_BUT_READS_FINISHED, 'max_tokens'));
+
+    await runAsk('my database connections are maxed out');
+    const out = logged.join('\n');
+
+    expect(out).toContain(SINGLE_SHOT_NOTICE);
+    expect(out).toContain('Ask a narrower question to get a complete answer.');
+    expect(out).toContain(TRUNCATED_BUT_READS_FINISHED);
+    expect(out).not.toContain('"type":"ask"');
+  });
+
+  it('still prints the REPL truncation notice verbatim, and no JSON', async () => {
+    lines.queue = ['give me the full remediation sequence', '/exit'];
+    createMock.mockResolvedValue(reply(TRUNCATED_BUT_READS_FINISHED, 'max_tokens'));
+
+    await runAskRepl();
+    const out = logged.join('\n');
+
+    expect(out).toContain(SINGLE_SHOT_NOTICE);
+    expect(out).toContain('Type "continue" to pick up where it stopped, or ask something narrower.');
+    expect(out).not.toContain('"type":"ask"');
+  });
+
+  it('still says nothing about truncation when the answer is complete', async () => {
+    createMock.mockResolvedValue(reply(COMPLETE_ANSWER, 'end_turn'));
+
+    await runAsk('my postgres replica is lagging');
+    const out = logged.join('\n');
+
+    expect(out).toContain('HIGH urgency');
+    expect(out).not.toContain('cut off');
+  });
+});
diff --git a/src/cli/commands/ask.ts b/src/cli/commands/ask.ts
index 05239a5..0c01f42 100644
--- a/src/cli/commands/ask.ts
+++ b/src/cli/commands/ask.ts
@@ -16,7 +16,7 @@
 import { createInterface } from 'node:readline';
 import { sanitizeInput } from '../../framework/ai-diagnosis.js';
 import { getNetworkProfile } from '../../framework/network-profile.js';
-import { printBanner, printInfo, printWarning } from '../output.js';
+import { getOutputMode, jsonOut, printBanner, printInfo, printWarning } from '../output.js';
 import { missingEnvVar } from '../errors.js';
 import { defaultAiModel } from '../../framework/ai-model.js';
 import { callClaudeDetailed } from '../../framework/ai-client.js';
@@ -90,6 +90,34 @@ Guidelines:
 Supported systems: PostgreSQL, Redis, etcd, Kafka, Kubernetes, Ceph, Flink.
 Cross-system awareness: consider cascade failures, shared root causes, and upstream/downstream dependencies.`;
 
+// ── Machine output ──
+
+/**
+ * One JSONL record per answer, in the CLI's standard `{ type, ... }` shape.
+ *
+ * `ask` used to print the answer with a bare `console.log` and route the
+ * truncation notice through `printWarning`/`printInfo`, both of which return
+ * early in machine mode. A `--json` consumer therefore received a partial
+ * answer with nothing marking it as partial — the one caller least able to
+ * notice, since it cannot read the prose and judge.
+ *
+ * `truncated` is a field rather than a warning because that is the only form a
+ * machine consumer can act on: `.truncated` is checkable, a suppressed human
+ * sentence is not. `answer` carries the partial text unchanged — it is still
+ * the most useful thing we have — but never on its own.
+ */
+function emitAskRecord(
+  question: string,
+  result: { response: string; source: 'ai' | 'fallback'; truncated: boolean },
+): void {
+  jsonOut('ask', {
+    question,
+    answer: result.response,
+    source: result.source,
+    truncated: result.truncated,
+  });
+}
+
 // ── Single-shot mode (backward compatible) ──
 
 export async function runAsk(question: string): Promise<void> {
@@ -99,12 +127,23 @@ export async function runAsk(question: string): Promise<void> {
     throw missingEnvVar('ANTHROPIC_API_KEY', 'required for AI-powered diagnosis');
   }
 
-  printInfo(`Question: ${question}`);
-  console.log('');
+  const machine = getOutputMode() === 'machine';
+
+  if (!machine) {
+    printInfo(`Question: ${question}`);
+    console.log('');
+  }
 
   const { universalAiDiagnosis } = await import('../../framework/ai-diagnosis-universal.js');
   const result = await universalAiDiagnosis({ question });
 
+  // Machine mode emits the record instead of the prose: the blank lines and the
+  // bare answer below would otherwise sit in the stream as non-JSON lines.
+  if (machine) {
+    emitAskRecord(question, result);
+    return;
+  }
+
   if (result.source === 'ai') {
     console.log(result.response);
   } else {
@@ -132,17 +171,25 @@ export async function runAskRepl(): Promise<void> {
     throw missingEnvVar('ANTHROPIC_API_KEY', 'required for interactive diagnosis');
   }
 
+  const machine = getOutputMode() === 'machine';
+
   const profile = getNetworkProfile();
   if (profile && profile.internet.status === 'unavailable') {
-    printWarning('No internet connectivity — AI diagnosis requires network access.');
+    const message = 'No internet connectivity — AI diagnosis requires network access.';
+    // Same reason as the truncation record: printWarning is a no-op in machine
+    // mode, so a --json REPL would otherwise exit having emitted nothing at all.
+    if (machine) jsonOut('error', { message });
+    else printWarning(message);
     return;
   }
 
-  printInfo('Interactive diagnosis session. Type your question, or:');
-  printInfo('  /context   — show accumulated context');
-  printInfo('  /clear     — reset conversation history');
-  printInfo('  /exit      — end session');
-  console.log('');
+  if (!machine) {
+    printInfo('Interactive diagnosis session. Type your question, or:');
+    printInfo('  /context   — show accumulated context');
+    printInfo('  /clear     — reset conversation history');
+    printInfo('  /exit      — end session');
+    console.log('');
+  }
 
   const ctx: ReplContext = {
     history: [],
@@ -154,7 +201,9 @@ export async function runAskRepl(): Promise<void> {
 
   const rl = createInterface({
     input: process.stdin,
-    output: process.stdout,
+    // No output stream in machine mode: readline would write "crisismode> " into
+    // the middle of the JSONL stream. Nothing else in this loop prints there.
+    output: machine ? undefined : process.stdout,
     prompt: 'crisismode> ',
     terminal: process.stdin.isTTY === true,
   });
@@ -183,18 +232,26 @@ export async function runAskRepl(): Promise<void> {
     // Send question to AI with conversation history
     try {
       const turn = await sendWithHistory(ctx, input);
-      console.log('');
-      console.log(turn.text);
-      console.log('');
-      if (turn.truncated) {
-        printWarning(
-          'This answer is cut off — it hit the response length limit, so the last point above is incomplete.',
-        );
-        printInfo('Type "continue" to pick up where it stopped, or ask something narrower.');
+      if (machine) {
+        // One record per exchange, same shape as single-shot: a REPL consumer
+        // reading JSONL gets `truncated` on the turn it belongs to.
+        emitAskRecord(input, { response: turn.text, source: 'ai', truncated: turn.truncated });
+      } else {
         console.log('');
+        console.log(turn.text);
+        console.log('');
+        if (turn.truncated) {
+          printWarning(
+            'This answer is cut off — it hit the response length limit, so the last point above is incomplete.',
+          );
+          printInfo('Type "continue" to pick up where it stopped, or ask something narrower.');
+          console.log('');
+        }
       }
     } catch (err) {
-      printWarning(`AI error: ${err instanceof Error ? err.message : String(err)}`);
+      const message = `AI error: ${err instanceof Error ? err.message : String(err)}`;
+      if (machine) jsonOut('error', { message });
+      else printWarning(message);
     }
 
     rl.prompt();

From 80308da4dc163db339cf135eda1854d525b4bee9 Mon Sep 17 00:00:00 2001
From: trs-80 <109326+trs-80@users.noreply.github.com>
Date: Sun, 9 Aug 2026 13:33:47 -0400
Subject: [PATCH 14/17] fix(playbooks): propagate Redis failures instead of
 reporting success
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The cache-eviction example replaced earlier in this PR fixed the safety
problem — it no longer deletes keys — but its exit status came from the final
`while` loop rather than the Redis commands. Reproduced with a fake redis-cli
on PATH: the pipeline exits 0 both when SCAN fails outright with a connection
refused, and when an intermediate TTL fails before a later success. A recovery
step that silently succeeds after its cleanup failed is worse than one that
fails loudly, because the engine proceeds believing memory pressure was
handled.

`set -o pipefail` is not the fix and was verified not to be: with it, a
HEALTHY Redis exits 141 from head's SIGPIPE, trading a silent success for a
spurious failure.

Both files now carry an identical cursor-driven, bounded SCAN loop with no
pipeline at all. Each SCAN reply is fed through a here-document and every
redis-cli exit status is tested directly, so a SCAN or TTL failure exits 1.
The safety property is preserved: read-only SCAN and TTL only, no DEL, UNLINK
or EXPIRE, capped at 1000 keys and 50 scan rounds.

Verified through the real CLI: both the checked-in example and the docs
Complete Example report 13 safety checks passed, dry-run compiles 8 steps with
step 4 still routine, and shellcheck -s sh is clean.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 docs/playbook-authoring.md                  | 49 +++++++++++++++++++--
 playbooks/examples/redis-memory-pressure.md | 41 ++++++++++++++---
 2 files changed, 82 insertions(+), 8 deletions(-)

diff --git a/docs/playbook-authoring.md b/docs/playbook-authoring.md
index caacd13..7fb0629 100644
--- a/docs/playbook-authoring.md
+++ b/docs/playbook-authoring.md
@@ -263,10 +263,41 @@ redis-cli info memory
 ```sh
 # Bounded sample of the keyspace. Reading a key that is already past its TTL is
 # what makes Redis reclaim it; keys still inside their TTL, and keys with no TTL
-# at all, are read and left alone.
-redis-cli --scan --count 100 | head -n 1000 | while read -r key; do
-  redis-cli TTL "$key" > /dev/null
+# at all, are read and left alone. This step deletes nothing itself.
+# Every redis-cli call is checked, so a failed SCAN or TTL fails the step rather
+# than reporting a cleanup that never happened.
+set -u
+limit=1000
+cursor=0
+scanned=0
+rounds=0
+
+while [ "$scanned" -lt "$limit" ] && [ "$rounds" -lt 50 ]; do
+  rounds=$((rounds + 1))
+  if ! reply=$(redis-cli SCAN "$cursor" COUNT 100); then
+    echo "SCAN failed at cursor $cursor" >&2
+    exit 1
+  fi
+
+  # First line of a SCAN reply is the next cursor; the rest are keys.
+  first=1
+  while IFS= read -r key; do
+    if [ "$first" -eq 1 ]; then cursor=$key; first=0; continue; fi
+    [ -n "$key" ] || continue
+    if ! redis-cli TTL "$key" > /dev/null; then
+      echo "TTL failed for key: $key" >&2
+      exit 1
+    fi
+    scanned=$((scanned + 1))
+    [ "$scanned" -lt "$limit" ] || break
+  done <<EOF
+$reply
+EOF
+
+  [ "$cursor" != "0" ] || break
 done
+
+echo "touched $scanned keys, deleted none"
 ```
 
 ### 5. Verify recovery
@@ -294,4 +325,16 @@ the built-in Redis agent declares its aggressive-expiry step (`elevated`, with a
 under incident pressure; a mislabelled step is how a "routine" playbook takes out a
 cache.
 
+**Why step 4 checks every command.** The obvious one-liner —
+`redis-cli --scan --count 100 | head -n 1000 | while read -r key; do redis-cli TTL "$key"; done`
+— exits `0` even when the `SCAN` never connected, because a pipeline reports the status of
+its *last* command and a `while` loop reports the status of its *final* iteration. The
+engine would record step 4 as a success and move on to step 5 believing memory pressure
+had been addressed. Reaching for `set -o pipefail` trades that for the opposite bug:
+`head` closes the pipe after 1000 lines, `redis-cli` dies of `SIGPIPE`, and a perfectly
+healthy Redis reports exit 141. The loop above has no pipeline at all — it feeds the
+`SCAN` reply in through a here-document and tests each `redis-cli` exit status directly,
+so any failure fails the step and a clean run is the only way to exit 0. A step that
+silently succeeds after its cleanup failed is worse than one that fails loudly.
+
 For more playbook examples, see the `playbooks/examples/` directory.
diff --git a/playbooks/examples/redis-memory-pressure.md b/playbooks/examples/redis-memory-pressure.md
index abfa917..c0693ec 100644
--- a/playbooks/examples/redis-memory-pressure.md
+++ b/playbooks/examples/redis-memory-pressure.md
@@ -60,12 +60,43 @@ redis-cli DBSIZE
 - capability: cache.expiry.trigger
 
 ```sh
-# Reading a key that is already past its TTL is what makes Redis reclaim it
-# (passive expiration). Keys still inside their TTL, and keys with no TTL at all,
-# are read and left alone. Bounded to a 10000-key sample.
-redis-cli --scan --count 100 | head -n 10000 | while read -r key; do
-  redis-cli TTL "$key" > /dev/null
+# Bounded sample of the keyspace. Reading a key that is already past its TTL is
+# what makes Redis reclaim it; keys still inside their TTL, and keys with no TTL
+# at all, are read and left alone. This step deletes nothing itself.
+# Every redis-cli call is checked, so a failed SCAN or TTL fails the step rather
+# than reporting a cleanup that never happened.
+set -u
+limit=1000
+cursor=0
+scanned=0
+rounds=0
+
+while [ "$scanned" -lt "$limit" ] && [ "$rounds" -lt 50 ]; do
+  rounds=$((rounds + 1))
+  if ! reply=$(redis-cli SCAN "$cursor" COUNT 100); then
+    echo "SCAN failed at cursor $cursor" >&2
+    exit 1
+  fi
+
+  # First line of a SCAN reply is the next cursor; the rest are keys.
+  first=1
+  while IFS= read -r key; do
+    if [ "$first" -eq 1 ]; then cursor=$key; first=0; continue; fi
+    [ -n "$key" ] || continue
+    if ! redis-cli TTL "$key" > /dev/null; then
+      echo "TTL failed for key: $key" >&2
+      exit 1
+    fi
+    scanned=$((scanned + 1))
+    [ "$scanned" -lt "$limit" ] || break
+  done <<EOF
+$reply
+EOF
+
+  [ "$cursor" != "0" ] || break
 done
+
+echo "touched $scanned keys, deleted none"
 ```
 
 ### 5. Evaluate memory after cleanup

From e37b14275f6e25f3f23305cfa23eb9a5e6f9526a Mon Sep 17 00:00:00 2001
From: trs-80 <109326+trs-80@users.noreply.github.com>
Date: Sun, 9 Aug 2026 13:33:47 -0400
Subject: [PATCH 15/17] fix(cli): treat only undefined as an absent init flag

pluginNameFrom returned early on `value === false`, so runInit(undefined,
{ plugin: false }) was read as "flag not given" and wrote crisismode.yaml
instead of reporting invalid input.

Checked why the case existed before removing it: --plugin and --agent are
registered as { type: 'string' } with no default, so under parseArgs an
omitted flag is always undefined, a valueless flag is true, --plugin= is "",
and --no-plugin lands on its own key. Verified against real node:util
parseArgs on node v26.5.1. The false branch guarded an unreachable state, so
dropping it cannot break the ordinary omitted-flag path, and no change is
needed at the parse level.

Adds 5 regression tests, including parser-level ones pinning the behaviour the
fix depends on.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 src/__tests__/init-plugin-flag.test.ts | 41 ++++++++++++++++++++++++++
 src/cli/commands/init.ts               |  6 +++-
 2 files changed, 46 insertions(+), 1 deletion(-)

diff --git a/src/__tests__/init-plugin-flag.test.ts b/src/__tests__/init-plugin-flag.test.ts
index 2db3f7e..c61f54a 100644
--- a/src/__tests__/init-plugin-flag.test.ts
+++ b/src/__tests__/init-plugin-flag.test.ts
@@ -127,6 +127,26 @@ describe('crisismode init — plugin scaffolding flags', () => {
     expect(existsSync(join(tmpDir, 'checks'))).toBe(false);
   });
 
+  // `false` is not something the parser can produce — `--plugin`/`--agent` are
+  // registered as string options with no default, so an omitted flag is
+  // `undefined`. Treating `false` as "omitted" would let a caller with a bad
+  // value quietly get a crisismode.yaml instead of a usage error.
+  it('rejects plugin: false as bad input rather than treating it as absent', async () => {
+    await expect(runInit(undefined, { plugin: false })).rejects.toThrow(
+      'crisismode init --plugin my-check',
+    );
+    expect(existsSync(join(tmpDir, 'checks'))).toBe(false);
+    expect(existsSync(join(tmpDir, 'crisismode.yaml'))).toBe(false);
+  });
+
+  it('rejects agent: false as bad input rather than treating it as absent', async () => {
+    await expect(runInit(undefined, { agent: false })).rejects.toThrow(
+      'crisismode init --agent my-check',
+    );
+    expect(existsSync(join(tmpDir, 'checks'))).toBe(false);
+    expect(existsSync(join(tmpDir, 'crisismode.yaml'))).toBe(false);
+  });
+
   it('rejects a plugin name that would escape checks/', async () => {
     await expect(runInit(undefined, { plugin: '../../evil' })).rejects.toThrow('Invalid plugin name');
     expect(existsSync(join(tmpDir, 'checks'))).toBe(false);
@@ -167,6 +187,27 @@ describe('crisismode init — CLI flag registration', () => {
     expect(positionals).toEqual([]);
   });
 
+  // The reachable value set is what licenses runInit treating *only* `undefined`
+  // as "flag omitted": string options carry no default, so absence is
+  // `undefined`, a valueless flag is `true`, and `--no-plugin` lands on its own
+  // key. `false` is not reachable, so rejecting it cannot break an ordinary run.
+  it('yields undefined, not false, when the flags are omitted', () => {
+    const { values } = parseArgs({ ...parseOpts, args: [] });
+    expect(values.plugin).toBeUndefined();
+    expect(values.agent).toBeUndefined();
+  });
+
+  it('yields true, not false, for a valueless flag', () => {
+    expect(parseArgs({ ...parseOpts, args: ['--plugin'] }).values.plugin).toBe(true);
+    expect(parseArgs({ ...parseOpts, args: ['--agent'] }).values.agent).toBe(true);
+  });
+
+  it('never routes --no-plugin onto the plugin value', () => {
+    const { values } = parseArgs({ ...parseOpts, args: ['--no-plugin', '--no-agent'] });
+    expect(values.plugin).toBeUndefined();
+    expect(values.agent).toBeUndefined();
+  });
+
   it('registers both flags in the real parseArgs config', () => {
     expect(INDEX_SOURCE).toContain('plugin: { type: \'string\' }');
     expect(INDEX_SOURCE).toContain('agent: { type: \'string\' }');
diff --git a/src/cli/commands/init.ts b/src/cli/commands/init.ts
index 93126d6..cefde40 100644
--- a/src/cli/commands/init.ts
+++ b/src/cli/commands/init.ts
@@ -30,7 +30,11 @@ export interface InitOptions {
 const PLUGIN_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
 
 function pluginNameFrom(flag: 'plugin' | 'agent', value: string | boolean | undefined): string | undefined {
-  if (value === undefined || value === false) return undefined;
+  // Only `undefined` means "flag omitted". The parser registers these as string
+  // options with no default, so an absent flag is always `undefined` and never
+  // `false` — anything else, including `false`, is bad input and gets a usage
+  // error rather than silently falling through to writing crisismode.yaml.
+  if (value === undefined) return undefined;
   if (typeof value !== 'string' || value.trim() === '') {
     throw new Error(`--${flag} requires a plugin name, e.g. crisismode init --${flag} my-check`);
   }

From ed13396ceafd3b7dc6b868ae6bf32f1adc0e7f71 Mon Sep 17 00:00:00 2001
From: trs-80 <109326+trs-80@users.noreply.github.com>
Date: Sun, 9 Aug 2026 13:55:46 -0400
Subject: [PATCH 16/17] fix(playbooks): make redis-cli report Redis-level
 errors

Checking redis-cli's exit status was not enough. Without -e, redis-cli exits 0
even when Redis returns an error reply, so the step reported success under
NOAUTH, NOPERM, WRONGTYPE or an unknown command. Reproduced against a real
redis-server 8.8.0: with requirepass set, the checked-in snippet printed
"touched 0 keys, deleted none" and exited 0 while every command returned
NOAUTH; an ACL-restricted --user reproduced it with NOPERM.

The elevated step is the one that matters most, and it did not need an auth
failure to fail silently at all: `CONFIG SET maxmemory 8gigabytes` exits 0
without -e on a healthy authenticated Redis, so a bad unit alone made an
elevated step report the memory ceiling raised when nothing had changed.

-e alone was also insufficient for the INFO/DBSIZE step, because runtime.ts
compiles an sh block into a single structured_command and only the last line's
status is reported. Proved with an ACL user granted +dbsize but not +info:
exit 0 with -e alone, exit 1 once set -e is added.

Two prose snippets deliberately keep no -e: one is the destructive anti-pattern
the page argues against, and the other is the broken pipeline one-liner that -e
would not fix anyway.

Also corrects a paragraph that claimed "a clean run is the only way to exit 0",
which was not true before this change.

Healthy path re-verified per command (INFO bulk string, DBSIZE integer 0,
CONFIG SET +OK, empty keyspace, TTL -1 and -2, non-string types, and a 1500-key
keyspace still stopping at 1000). The shared step-4 block stays byte-identical
across both files. playbook validate reports 13 safety checks passed on both,
dry-run 13 checks over 8 steps with step 4 routine and step 7 elevated, and
shellcheck -s sh is clean on all 5 extracted blocks.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 docs/playbook-authoring.md                  | 40 ++++++++++++++++-----
 playbooks/examples/redis-memory-pressure.md | 25 ++++++++-----
 2 files changed, 49 insertions(+), 16 deletions(-)

diff --git a/docs/playbook-authoring.md b/docs/playbook-authoring.md
index 7fb0629..0975430 100644
--- a/docs/playbook-authoring.md
+++ b/docs/playbook-authoring.md
@@ -240,7 +240,7 @@ estimated_duration: "15m"
 - target: redis-primary
 
 ```sh
-redis-cli info memory
+redis-cli -e info memory
 ```
 
 ### 2. Notify on-call
@@ -264,8 +264,9 @@ redis-cli info memory
 # Bounded sample of the keyspace. Reading a key that is already past its TTL is
 # what makes Redis reclaim it; keys still inside their TTL, and keys with no TTL
 # at all, are read and left alone. This step deletes nothing itself.
-# Every redis-cli call is checked, so a failed SCAN or TTL fails the step rather
-# than reporting a cleanup that never happened.
+# Every redis-cli call runs with -e and is checked, so a failed SCAN or TTL fails
+# the step rather than reporting a cleanup that never happened. Without -e,
+# redis-cli exits 0 even when Redis answers with an error reply such as NOAUTH.
 set -u
 limit=1000
 cursor=0
@@ -274,7 +275,7 @@ rounds=0
 
 while [ "$scanned" -lt "$limit" ] && [ "$rounds" -lt 50 ]; do
   rounds=$((rounds + 1))
-  if ! reply=$(redis-cli SCAN "$cursor" COUNT 100); then
+  if ! reply=$(redis-cli -e SCAN "$cursor" COUNT 100); then
     echo "SCAN failed at cursor $cursor" >&2
     exit 1
   fi
@@ -284,7 +285,7 @@ while [ "$scanned" -lt "$limit" ] && [ "$rounds" -lt 50 ]; do
   while IFS= read -r key; do
     if [ "$first" -eq 1 ]; then cursor=$key; first=0; continue; fi
     [ -n "$key" ] || continue
-    if ! redis-cli TTL "$key" > /dev/null; then
+    if ! redis-cli -e TTL "$key" > /dev/null; then
       echo "TTL failed for key: $key" >&2
       exit 1
     fi
@@ -333,8 +334,31 @@ engine would record step 4 as a success and move on to step 5 believing memory p
 had been addressed. Reaching for `set -o pipefail` trades that for the opposite bug:
 `head` closes the pipe after 1000 lines, `redis-cli` dies of `SIGPIPE`, and a perfectly
 healthy Redis reports exit 141. The loop above has no pipeline at all — it feeds the
-`SCAN` reply in through a here-document and tests each `redis-cli` exit status directly,
-so any failure fails the step and a clean run is the only way to exit 0. A step that
-silently succeeds after its cleanup failed is worse than one that fails loudly.
+`SCAN` reply in through a here-document and tests each `redis-cli` exit status directly.
+
+Testing the exit status is only half of it, because `redis-cli` exits `0` even when Redis
+answers with an error reply — a `NOAUTH` on a password-protected instance, a `NOPERM` from
+an ACL-restricted `--user`, a `WRONGTYPE`, an unknown command. The step would print
+`touched 0 keys` and succeed having run nothing. `-e` is what makes an error reply an exit
+code (`redis-cli --help`: "Return exit error code when command execution fails"), so every
+call in the loop carries it. `-e` reacts to error *replies* only: an empty `SCAN` result,
+a missing key, and a `TTL` of `-1` or `-2` are ordinary replies, so a healthy Redis still
+exits `0`. A step that silently succeeds after its cleanup failed is worse than one that
+fails loudly.
+
+**The rule is not specific to step 4.** Every `redis-cli` call in a playbook carries `-e`,
+including the read-only `INFO` in step 1: a diagnosis that could not reach the instance
+should fail rather than hand the following steps an empty reading. It matters most on
+mutating steps. `redis-cli CONFIG SET maxmemory 8gb` exits `0` when Redis *rejects* the
+value — a bad unit is enough, no auth failure required — so an `elevated` step would report
+that the memory ceiling had been raised when nothing changed, and the plan would carry on
+under that belief. That is the failure this framework exists to prevent, so the mutating
+step gets `-e` even more than the read-only one does.
+
+**A block is one command to the engine.** The runtime compiles each step's `sh` block into
+a single `structured_command`, so a block's exit status is its *last* line's. `-e` alone is
+not enough where a step runs several commands: step 1's block opens with `set -e` so a
+failing `INFO` aborts it instead of being overwritten by a successful `DBSIZE`. Step 4 does
+not need `set -e` — it tests every status itself and exits explicitly.
 
 For more playbook examples, see the `playbooks/examples/` directory.
diff --git a/playbooks/examples/redis-memory-pressure.md b/playbooks/examples/redis-memory-pressure.md
index c0693ec..b70cd4b 100644
--- a/playbooks/examples/redis-memory-pressure.md
+++ b/playbooks/examples/redis-memory-pressure.md
@@ -38,9 +38,14 @@ high eviction rates, or approaching maxmemory limits.
 - target: redis-primary
 
 ```sh
-redis-cli INFO memory
-redis-cli INFO stats
-redis-cli DBSIZE
+# -e turns a Redis error reply into a nonzero exit, and set -e stops the block on
+# the first failure — the whole block is one command to the engine, so without it
+# only the last line's status would be reported. A diagnosis that could not read
+# the instance must fail here rather than hand later steps an empty reading.
+set -e
+redis-cli -e INFO memory
+redis-cli -e INFO stats
+redis-cli -e DBSIZE
 ```
 
 ### 2. Notify operations team
@@ -63,8 +68,9 @@ redis-cli DBSIZE
 # Bounded sample of the keyspace. Reading a key that is already past its TTL is
 # what makes Redis reclaim it; keys still inside their TTL, and keys with no TTL
 # at all, are read and left alone. This step deletes nothing itself.
-# Every redis-cli call is checked, so a failed SCAN or TTL fails the step rather
-# than reporting a cleanup that never happened.
+# Every redis-cli call runs with -e and is checked, so a failed SCAN or TTL fails
+# the step rather than reporting a cleanup that never happened. Without -e,
+# redis-cli exits 0 even when Redis answers with an error reply such as NOAUTH.
 set -u
 limit=1000
 cursor=0
@@ -73,7 +79,7 @@ rounds=0
 
 while [ "$scanned" -lt "$limit" ] && [ "$rounds" -lt 50 ]; do
   rounds=$((rounds + 1))
-  if ! reply=$(redis-cli SCAN "$cursor" COUNT 100); then
+  if ! reply=$(redis-cli -e SCAN "$cursor" COUNT 100); then
     echo "SCAN failed at cursor $cursor" >&2
     exit 1
   fi
@@ -83,7 +89,7 @@ while [ "$scanned" -lt "$limit" ] && [ "$rounds" -lt 50 ]; do
   while IFS= read -r key; do
     if [ "$first" -eq 1 ]; then cursor=$key; first=0; continue; fi
     [ -n "$key" ] || continue
-    if ! redis-cli TTL "$key" > /dev/null; then
+    if ! redis-cli -e TTL "$key" > /dev/null; then
       echo "TTL failed for key: $key" >&2
       exit 1
     fi
@@ -125,7 +131,10 @@ temporarily to prevent further evictions while the team investigates.
   max_downtime_seconds: 0
 
 ```sh
-redis-cli CONFIG SET maxmemory 8gb
+# -e is what makes a rejected CONFIG SET fail this step. Without it redis-cli exits
+# 0 after Redis refuses the value — a bad unit is enough — and the plan continues
+# to step 8 reporting that maxmemory was raised when nothing changed.
+redis-cli -e CONFIG SET maxmemory 8gb
 ```
 
 ### 8. Recovery complete

From 2197e6febd2079edf7356fabd6304d3380fc2fcc Mon Sep 17 00:00:00 2001
From: trs-80 <109326+trs-80@users.noreply.github.com>
Date: Sun, 9 Aug 2026 14:14:51 -0400
Subject: [PATCH 17/17] chore: exclude vendored site assets from the
 code-intelligence index
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

.cbmignore is not a gitignore — everything it lists stays tracked, shipped and
required at runtime. It only keeps site/assets/ out of the codebase-memory
knowledge graph: the minified asciinema-player bundle contributes hundreds of
single-letter symbols ($, $A, $e, $t, ...) that outrank real source in
full-text search, and no structural query about this codebase should resolve
into third-party minified output.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .cbmignore | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 .cbmignore

diff --git a/.cbmignore b/.cbmignore
new file mode 100644
index 0000000..bfee505
--- /dev/null
+++ b/.cbmignore
@@ -0,0 +1,13 @@
+# Exclusions for the codebase-memory knowledge graph only.
+#
+# This file is NOT a gitignore. Everything listed here is tracked, shipped, and
+# required at runtime — it simply has no business in a code-intelligence index.
+# Syntax is gitignore syntax; the indexer reads .gitignore, .git/info/exclude
+# and this file.
+
+# Vendored asciinema-player bundle and the demo recording assets for the landing
+# page. The minified bundle alone contributes hundreds of single-letter symbols
+# ($, $A, $e, $t, ...) that outrank real source in BM25 full-text search, and no
+# structural query about this codebase should ever resolve into third-party
+# minified output. Regenerated by scripts/record-demo.sh, never hand-edited.
+site/assets/