create-battle-plan 1.0.0

package/bin/cli.js

@@ -0,0 +1,434 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+function ask(question) {
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => resolve(answer.trim()));
+  });
+}
+
+function slugify(text) {
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-|-$/g, '');
+}
+
+function metricKey(text) {
+  return text
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '_')
+    .replace(/^_|_$/g, '');
+}
+
+function capitalize(text) {
+  return text.charAt(0).toUpperCase() + text.slice(1);
+}
+
+function copyDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const GREEN = '\x1b[32m';
+const CYAN = '\x1b[36m';
+const YELLOW = '\x1b[33m';
+const WHITE = '\x1b[37m';
+const RESET = '\x1b[0m';
+
+function banner() {
+  console.log('');
+  console.log(`${BOLD}${WHITE}    ___  ____ ___ ___ _    ____${RESET}`);
+  console.log(`${BOLD}${WHITE}    |__] |__|  |   |  |    |___${RESET}`);
+  console.log(`${BOLD}${WHITE}    |__] |  |  |   |  |___ |___${RESET}`);
+  console.log('');
+  console.log(`${BOLD}${WHITE}   ___  _    ____ _  _${RESET}`);
+  console.log(`${BOLD}${WHITE}   |__] |    |__| |\\ |${RESET}`);
+  console.log(`${BOLD}${WHITE}   |    |___ |  | | \\|${RESET}`);
+  console.log('');
+  console.log(`${DIM}   A markdown-based context system${RESET}`);
+  console.log(`${DIM}   for LLM-powered projects${RESET}`);
+  console.log('');
+  console.log(`${DIM}   ─────────────────────────────${RESET}`);
+  console.log('');
+}
+
+function cascadeDiagram(domains, metrics) {
+  const domainStr = domains.slice(0, 3).join('  ');
+  const dots = domains.length > 3 ? '  ...' : '';
+  const metricStr = metrics.slice(0, 3).map((m) => metricKey(m)).join(', ');
+
+  console.log(`${DIM}   Your cascade:${RESET}`);
+  console.log('');
+  console.log(`${CYAN}      new info ──→ ${WHITE}metrics.yml${RESET}`);
+  console.log(`${DIM}                       │${RESET}`);
+  console.log(`${DIM}                       ▼${RESET}`);
+  console.log(`${CYAN}                ${WHITE}battle-plan.md${RESET}`);
+  console.log(`${DIM}                  /    |    \\${RESET}`);
+  console.log(`${CYAN}              ${WHITE}${domainStr}${dots}${RESET}`);
+  console.log(`${DIM}                       │${RESET}`);
+  console.log(`${DIM}                       ▼${RESET}`);
+  console.log(`${GREEN}              verify-cascade.sh ${BOLD}✓${RESET}`);
+  console.log('');
+}
+
+async function main() {
+  banner();
+
+  // Question 1: Project name
+  const projectName = await ask(`${DIM}[1/6]${RESET} ${BOLD}What's your project in one sentence?${RESET}\n> `);
+  if (!projectName) {
+    console.log('Project name is required.');
+    process.exit(1);
+  }
+  console.log('');
+
+  // Question 2: Time horizon
+  const horizon = await ask(
+    `${DIM}[2/6]${RESET} ${BOLD}What's your time horizon?${RESET} ${DIM}(e.g., "3 weeks to demo day", "6 months to launch", "ongoing")${RESET}\n> `
+  );
+  console.log('');
+
+  // Question 3: Metrics
+  const metricsRaw = await ask(
+    `${DIM}[3/6]${RESET} ${BOLD}What are the 3-5 key metrics you want to track?${RESET} ${DIM}(comma-separated, e.g., "outreach sent, calls booked, LOIs signed")${RESET}\n> `
+  );
+  if (!metricsRaw) {
+    console.log('At least one metric is required.');
+    process.exit(1);
+  }
+  const metrics = metricsRaw.split(',').map((m) => m.trim()).filter(Boolean);
+  console.log('');
+
+  // Question 4: Domains
+  const suggestedDomains = suggestDomains(projectName);
+  const domainsRaw = await ask(
+    `${DIM}[4/6]${RESET} ${BOLD}What domains does your work cover?${RESET} ${DIM}(comma-separated)\nSuggested based on your project: ${suggestedDomains}${RESET}\n> `
+  );
+  if (!domainsRaw) {
+    console.log('At least one domain is required.');
+    process.exit(1);
+  }
+  const domains = domainsRaw.split(',').map((d) => d.trim().toLowerCase()).filter(Boolean);
+  console.log('');
+
+  // Question 5: People
+  const peopleRaw = await ask(
+    `${DIM}[5/6]${RESET} ${BOLD}Who are the key people you'll be working with?${RESET} ${DIM}(format: "Name:Role, Name:Role" — or press enter to skip)${RESET}\n> `
+  );
+  const people = peopleRaw
+    ? peopleRaw.split(',').map((p) => {
+        const [name, role] = p.split(':').map((s) => s.trim());
+        return { name: name || '', role: role || '' };
+      }).filter((p) => p.name)
+    : [];
+  console.log('');
+
+  // Question 6: Where to install
+  const defaultDir = `./${slugify(projectName) || 'my-battle-plan'}`;
+  const dirAnswer = await ask(
+    `${DIM}[6/6]${RESET} ${BOLD}Where do you want to install it?${RESET} ${DIM}(default: ${defaultDir})${RESET}\n> `
+  );
+  const targetDir = path.resolve(dirAnswer || defaultDir);
+  console.log('');
+
+  rl.close();
+
+  // --- Scaffold ---
+  console.log(`${DIM}   ─────────────────────────────${RESET}`);
+  console.log('');
+  console.log(`${CYAN}   Scaffolding...${RESET}`);
+  console.log('');
+
+  if (fs.existsSync(targetDir) && fs.readdirSync(targetDir).length > 0) {
+    console.log(`${YELLOW}Warning: ${targetDir} already exists and is not empty.${RESET}`);
+    process.exit(1);
+  }
+
+  // Copy template
+  const templateDir = path.join(__dirname, '..', 'template');
+  copyDir(templateDir, targetDir);
+  console.log(`${DIM}   + CLAUDE.md (system prompt)${RESET}`);
+  console.log(`${DIM}   + tools/ (verification scripts)${RESET}`);
+  console.log(`${DIM}   + .claude/commands/ (slash commands)${RESET}`);
+  console.log(`${DIM}   + .githooks/pre-commit${RESET}`);
+
+  // Make shell scripts executable
+  const toolsDir = path.join(targetDir, 'tools');
+  if (fs.existsSync(toolsDir)) {
+    for (const f of fs.readdirSync(toolsDir)) {
+      if (f.endsWith('.sh')) {
+        fs.chmodSync(path.join(toolsDir, f), 0o755);
+      }
+    }
+  }
+  const hookFile = path.join(targetDir, '.githooks', 'pre-commit');
+  if (fs.existsSync(hookFile)) {
+    fs.chmodSync(hookFile, 0o755);
+  }
+
+  const today = new Date().toISOString().split('T')[0];
+
+  // Create domain directories and docs
+  for (const domain of domains) {
+    const domainDir = path.join(targetDir, 'docs', domain);
+    fs.mkdirSync(domainDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(domainDir, `${domain}-overview.md`),
+      `# ${capitalize(domain)} Overview
+
+**Last Updated:** ${today}
+**Status:** Draft
+**Role:** cascade-target
+**Compression:** amended
+
+**TL;DR:** Initial ${domain} document for ${projectName}. To be filled in as the project progresses.
+
+---
+
+## Notes
+
+_Start adding content here._
+`
+    );
+  }
+
+  console.log(`${DIM}   + docs/ (${domains.length} domain${domains.length > 1 ? 's' : ''})${RESET}`);
+
+  // Create metrics.yml
+  const metricsContent = [
+    `# metrics.yml — project-wide metrics registry for ${projectName}`,
+    '# The LLM updates this file FIRST in any cascade, before touching docs.',
+    '# Scripts verify all (→ metrics.yml#field) references against these values.',
+    '',
+    `last_updated: ${today}`,
+    '',
+    ...metrics.map((m) => `${metricKey(m)}: 0`),
+    '',
+  ].join('\n');
+  fs.writeFileSync(path.join(targetDir, 'metrics.yml'), metricsContent);
+  console.log(`${DIM}   + metrics.yml (${metrics.length} metric${metrics.length > 1 ? 's' : ''})${RESET}`);
+
+  // Create battle plan
+  const metricsTable = metrics
+    .map((m) => `| ${m} | _set target_ | **0** (→ metrics.yml#${metricKey(m)}) |`)
+    .join('\n');
+
+  fs.writeFileSync(
+    path.join(targetDir, 'docs', 'battle-plan.md'),
+    `# Battle Plan — ${projectName}
+
+**Last Updated:** ${today}
+**Status:** Active
+**Role:** source-of-truth
+**Compression:** chronological
+
+**TL;DR:** ${projectName} — just initialized. Time horizon: ${horizon || 'not set'}. All metrics at 0. First priority: fill in the battle plan with real tasks and targets.
+
+---
+
+## Rules for This Document
+
+1. Every task has an assigned date — no "sometime this week"
+2. Tasks move, never disappear — if slipped, add new date + reason
+3. New info updates the battle plan FIRST, before any other doc
+4. Everything links — tasks reference the doc they depend on or produce
+
+---
+
+## Key Metrics
+
+| Metric | Target | Current |
+|--------|--------|---------|
+${metricsTable}
+
+---
+
+## Today's Priorities
+
+- [ ] Set targets for each metric
+- [ ] Fill in this week's tasks
+- [ ] Record any existing conversations in external-insights.md
+
+---
+
+## This Week
+
+_Add day-by-day tasks here._
+
+---
+
+## Daily Log
+
+_Append-only. Three lines per day._
+`
+  );
+
+  // Create external-insights.md
+  const peopleSections = people.length
+    ? people.map((p) => `### ${p.name} — ${p.role}\n_No sessions recorded yet._\n`).join('\n')
+    : '_Add key people here as you start conversations._\n';
+
+  fs.writeFileSync(
+    path.join(targetDir, 'docs', 'external-insights.md'),
+    `# External Insights
+
+**Last Updated:** ${today}
+**Status:** Active
+**Role:** cascade-target
+**Compression:** chronological
+
+**TL;DR:** All external conversations, calls, and meetings for ${projectName}. 0 sessions recorded so far.
+
+---
+
+## How to Use This Document
+
+Every conversation gets appended as a dated session. Record everything — even "small" chats contain signal.
+
+### Template
+
+\`\`\`markdown
+## Session N (YYYY-MM-DD) — [Person Name], [Role/Company]
+
+### Context
+[Why this conversation happened]
+
+### Key insights
+1. **Insight title.** Detail. \`Confidence: [level]\`
+
+### Raw quotes (if available)
+> "Quote here"
+
+### Action items
+- [ ] Follow-up X
+\`\`\`
+
+---
+
+## People
+
+${peopleSections}
+`
+  );
+
+  console.log(`${DIM}   + docs/battle-plan.md${RESET}`);
+  console.log(`${DIM}   + docs/external-insights.md${RESET}`);
+
+  // Save onboarding answers for Claude to read on first /good-morning
+  fs.writeFileSync(
+    path.join(targetDir, '.battle-plan-onboarding.json'),
+    JSON.stringify(
+      {
+        project_name: projectName,
+        horizon,
+        metrics,
+        domains,
+        people,
+        installed_at: today,
+      },
+      null,
+      2
+    ) + '\n'
+  );
+
+  // Mark as initialized
+  fs.writeFileSync(path.join(targetDir, '.battle-plan-initialized'), `Initialized on ${today}\n`);
+
+  console.log('');
+
+  // Initialize git repo
+  try {
+    const { execSync } = require('child_process');
+    execSync('git init', { cwd: targetDir, stdio: 'pipe' });
+    execSync('git config core.hooksPath .githooks', { cwd: targetDir, stdio: 'pipe' });
+    execSync('git add -A', { cwd: targetDir, stdio: 'pipe' });
+    execSync('git commit -m "Initial battle plan scaffold"', {
+      cwd: targetDir,
+      stdio: 'pipe',
+      env: { ...process.env, GIT_AUTHOR_NAME: 'Battle Plan', GIT_AUTHOR_EMAIL: 'noreply@battleplan.dev', GIT_COMMITTER_NAME: 'Battle Plan', GIT_COMMITTER_EMAIL: 'noreply@battleplan.dev' },
+    });
+    console.log(`${DIM}   + git repo initialized${RESET}`);
+  } catch {
+    // git not available or failed — not critical
+  }
+
+  // --- Done ---
+  console.log('');
+  console.log(`${DIM}   ─────────────────────────────${RESET}`);
+  console.log('');
+  console.log(`${GREEN}${BOLD}   Ready.${RESET}`);
+  console.log('');
+  console.log(`${BOLD}   Project:${RESET}  ${projectName}`);
+  console.log(`${BOLD}   Location:${RESET} ${targetDir}`);
+  console.log(`${BOLD}   Horizon:${RESET}  ${horizon || 'not set'}`);
+  console.log(`${BOLD}   Metrics:${RESET}  ${metrics.join(', ')}`);
+  console.log(`${BOLD}   Domains:${RESET}  ${domains.join(', ')}`);
+  if (people.length) {
+    console.log(`${BOLD}   People:${RESET}   ${people.map((p) => `${p.name} (${p.role})`).join(', ')}`);
+  }
+  console.log('');
+
+  cascadeDiagram(domains, metrics);
+
+  console.log(`${DIM}   ─────────────────────────────${RESET}`);
+  console.log('');
+  console.log(`${CYAN}${BOLD}   Next steps:${RESET}`);
+  console.log('');
+  console.log(`   ${BOLD}cd ${path.relative(process.cwd(), targetDir)}${RESET}`);
+  console.log(`   ${BOLD}claude${RESET}`);
+  console.log('');
+  console.log(`   Then type ${GREEN}${BOLD}/good-morning${RESET} to start`);
+  console.log(`   your first session.`);
+  console.log('');
+  console.log(`${DIM}   Claude already knows your project, metrics,`);
+  console.log(`   and team. Just dump context into the chat —`);
+  console.log(`   call transcripts, research, meeting notes,`);
+  console.log(`   replies — it'll cascade into the right docs.${RESET}`);
+  console.log('');
+}
+
+function suggestDomains(projectDescription) {
+  const desc = projectDescription.toLowerCase();
+  const suggestions = [];
+
+  if (/market|customer|user|audience|segment|icp/.test(desc)) suggestions.push('market');
+  if (/valid|test|hypothes|experiment|interview/.test(desc)) suggestions.push('validation');
+  if (/strat|position|compete|pricing|business/.test(desc)) suggestions.push('strategy');
+  if (/research|learn|study|paper|domain/.test(desc)) suggestions.push('research');
+  if (/content|write|blog|newsletter|social/.test(desc)) suggestions.push('content');
+  if (/logist|ops|supply|shipping|fulfil/.test(desc)) suggestions.push('logistics');
+  if (/product|feature|build|ship|release/.test(desc)) suggestions.push('product');
+  if (/sales|outreach|pipeline|deal|close/.test(desc)) suggestions.push('sales');
+  if (/fund|invest|pitch|raise|capital/.test(desc)) suggestions.push('fundraising');
+
+  if (suggestions.length === 0) {
+    suggestions.push('market', 'validation', 'strategy', 'research');
+  }
+
+  return suggestions.join(', ');
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "create-battle-plan",
+  "version": "1.0.0",
+  "description": "Scaffold a Battle Plan project — a markdown-based context system for LLM-powered project management",
+  "bin": {
+    "create-battle-plan": "./bin/cli.js"
+  },
+  "files": [
+    "bin/",
+    "template/"
+  ],
+  "keywords": [
+    "claude",
+    "claude-code",
+    "llm",
+    "project-management",
+    "markdown",
+    "battle-plan",
+    "context",
+    "ai"
+  ],
+  "author": "Paul von Kunhardt",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/paulkunhardt/battle-plan"
+  },
+  "engines": {
+    "node": ">=16"
+  }
+}

package/template/.cascaderc.example

@@ -0,0 +1,6 @@
+# Battle Plan configuration
+# Copy this file to .cascaderc and edit as needed.
+
+# Set to 1 to block commits when verify-cascade.sh finds issues.
+# Default (0): warn but allow the commit.
+CASCADE_STRICT=0

package/template/.claude/commands/distill.md

@@ -0,0 +1,186 @@
+---
+description: Distill a long doc — compress older content into a thorough summary, archive verbatim raw content, lose nothing.
+argument-hint: <path/to/doc.md> [keep:N]
+---
+
+You are running the `/distill` command. The user wants to compress a doc that's grown too long by **distilling** older sections into a thorough summary while archiving the verbatim raw content into `docs/archive/`. **Distilling preserves essence — never lose information.** The full raw content always survives in the archive.
+
+## Arguments
+
+- **Doc path** (required): `$1` — relative path from repo root to the doc to distill
+- **Keep count** (optional): `keep:N` — how many of the most recent dated entries to keep verbatim. Default: 2.
+
+If `$ARGUMENTS` is empty, ask the user which doc to distill and how many entries to keep.
+
+## Step 0: Read frontmatter — choose mode by `Compression:` field
+
+Read the target doc's frontmatter. The `Compression:` field determines how `/distill` operates:
+
+| Compression mode | What `/distill` does |
+|---|---|
+| `chronological` | Doc is an append-only log with dated section headings (`## Session N (YYYY-MM-DD)`, `## YYYY-MM-DD`, etc.). Distill keeps the N most recent dated sections verbatim, archives the rest, replaces them with a thorough summary. |
+| `amended` | Doc is a living reference with in-place `> **[UPDATE YYYY-MM-DD]**` amendment blocks above claims. Distill collapses old amendment blocks (older than a cutoff or beyond the most recent N per section) into the body text, archives the raw amendment blocks. |
+| `none` | Doc is a static thesis/reference. **Refuse to run.** Tell the user: "This doc is `Compression: none` — it's not designed for distillation. Edits to static docs are version-controlled by git. If you think this doc should be compressible, change its frontmatter first." |
+| _missing_ | **Refuse to run.** Tell the user: "No `Compression:` field in frontmatter. Add one of `chronological`, `amended`, or `none` per CLAUDE.md before distilling." |
+
+Then proceed to the appropriate workflow below.
+
+---
+
+## Workflow A — `Compression: chronological`
+
+### Step 1: Identify dated sections
+
+Read the doc. Find headings that contain a date (`## Session N (YYYY-MM-DD)`, `### YYYY-MM-DD`, `## DD Month YYYY`, etc.). List them with their timestamps.
+
+**Default split:** Keep the N most recent dated sections verbatim, archive everything before them. N defaults to 2 unless `keep:N` was passed.
+
+**Confirm with user before proceeding** — unless they explicitly said "go" or "do it" in the original prompt.
+
+### Step 2: Determine archive path
+
+Archive lives at `docs/archive/<same-relative-path>` mirroring the doc's location.
+
+Example: `docs/validation/sven-moritz-insights.md` → `docs/archive/validation/sven-moritz-insights.md`
+
+If the archive file does NOT exist, create the parent directory (`mkdir -p`) and initialize it with this header (always include the frontmatter so verify-cascade skips it cleanly):
+
+```markdown
+# Archive: <Original Doc Title>
+
+**Last Updated:** YYYY-MM-DD
+**Status:** Archived
+**Role:** cascade-target
+**Compression:** none
+
+Raw content archived from `<original/path.md>`. Append-only — most recent archives at the top.
+
+---
+```
+
+If the archive file exists, prepend the new dated section above existing archived content (newest at top).
+
+### Step 3: Append the new archive section (verbatim)
+
+```markdown
+## Archived YYYY-MM-DD — <description of what's being archived>
+
+> Sections moved here from `<original/path.md>` on YYYY-MM-DD. These were the verbatim contents at time of archive.
+
+<EXACT verbatim content of the older sections — copy them with zero changes>
+
+---
+```
+
+Description should be specific: "Sessions 1-4 (2026-03-26 to 2026-03-30)" or "Daily logs from Jan-Mar 2026".
+
+### Step 4: Replace the archived sections in the original doc
+
+In the original doc, remove the older sections you just archived. Replace them with:
+
+1. **Archive notice** at the position where the archived sections used to be:
+
+```markdown
+> **📦 Distilled history:** <Description of what was archived> — full raw content in [archive](../archive/<relative-path>.md). Last distillation: YYYY-MM-DD.
+```
+
+The relative path needs to navigate from the doc's location to `docs/archive/`. Use `../` as needed.
+
+2. **A thorough summary** of the archived sections, immediately after the notice. The summary must:
+   - Be substantive — capture key insights, decisions, evidence, quotes future readers (or LLMs) need
+   - Preserve all numbers, names, dates, and concrete claims
+   - Use clear subheadings if covering multiple sessions/topics
+   - Reference the archive for verbatim details: e.g. "_See full transcript in [archive](../archive/...md#session-1-2026-03-26)._"
+   - Be marked clearly as a summary, not original content
+
+```markdown
+## Summary of <description> (distilled YYYY-MM-DD)
+
+[Thorough summary here. Preserve key insights, quotes, numbers. Cross-link to archive for verbatim.]
+
+---
+```
+
+Leave the kept verbatim sections completely untouched.
+
+---
+
+## Workflow B — `Compression: amended`
+
+### Step 1: Identify amendment blocks
+
+Read the doc. Find all `> **[UPDATE YYYY-MM-DD · Source: ...]**` blocks. Group them by their parent section/claim.
+
+Show the user the list and propose which ones to collapse. **Default rule:** within each section, keep the N most recent amendments inline; collapse the older ones into the main body text and archive the raw blocks.
+
+**Confirm with user before proceeding.**
+
+### Step 2: Create/update the archive file
+
+Same path scheme as Workflow A. Same archive frontmatter.
+
+### Step 3: Append the new archive section (verbatim)
+
+```markdown
+## Archived YYYY-MM-DD — Collapsed amendments from <doc>
+
+> Amendment blocks moved here from `<original/path.md>` on YYYY-MM-DD. These were the verbatim `[UPDATE]` blocks at time of distillation.
+
+### Section: <name of section the amendments belonged to>
+
+<EXACT verbatim copy of the old `> **[UPDATE ...]**` blocks, preserving order and source citations>
+
+---
+```
+
+### Step 4: Rewrite the original doc body
+
+For each collapsed amendment, **integrate its content into the main claim text** (not a separate block). The main body should now read as the current consensus state, with the amendment evidence absorbed. Then add a single notice at the section level:
+
+```markdown
+> **📦 Distilled history:** <N> older amendments collapsed into body — see [archive](../archive/<relative-path>.md#section-...) for raw blocks. Last distillation: YYYY-MM-DD.
+```
+
+Keep the most recent N amendment blocks inline as-is.
+
+**Critical:** never silently drop a claim. If two old amendments contradict, preserve both as "[date X said A; date Y said B; current view: ...]" in the body.
+
+---
+
+## Step 5 (both workflows): Update dates and verify
+
+```bash
+tools/touch-date.sh <original-doc> <archive-doc>
+tools/verify-cascade.sh
+```
+
+Fix any errors verify-cascade reports.
+
+## Step 6: Report
+
+Tell the user:
+- Mode used (`chronological` or `amended`)
+- What was distilled (sections/amendments + date range)
+- Where the archive lives (path)
+- What stayed verbatim
+- Line count of original doc (before vs after)
+- Any verification warnings
+
+Offer to commit:
+```
+git add <original-doc> <archive-doc>
+git commit -m "distill: compress <doc-name> — moved <description> to archive"
+```
+
+## Important rules
+
+- **Never lose data.** Full verbatim content goes to the archive — exactly as it was.
+- **Preserve metric references.** Keep `[**N**](metrics.yml#field)` links intact in both archive and summary.
+- **Don't touch the TL;DR or frontmatter** — those stay on the main doc (the TL;DR may reference distilled summaries, but is current-state, not history).
+- **Don't distill the most recent sections** — they're the active context.
+- **The summary must be useful enough that an LLM reading only the main doc has full context for current decisions.** The archive is for the rare case when something old becomes relevant again.
+- **If `Compression:` is missing or `none`, refuse to run.** Don't guess.
+
+## Arguments passed
+
+$ARGUMENTS