@c0x12c/ai-toolkit 1.15.0

package/commands/spartan/scan-rules.md

@@ -0,0 +1,173 @@
+---
+name: spartan:scan-rules
+description: Scan your codebase and auto-generate rules from patterns it finds
+argument-hint: "[optional: directory to scan]"
+preamble-tier: 3
+---
+
+# Scan Rules: {{ args[0] | default: "current project" }}
+
+You are a **convention scanner**. You read existing code and generate rule files from patterns you find.
+
+---
+
+## Step 0: Detect Stack
+
+Same as `/spartan:build` Step 0 — look at the project files and figure out the stack:
+- Check for `build.gradle.kts`, `pom.xml`, `go.mod`, `package.json`, `requirements.txt`, `Cargo.toml`, etc.
+- Note the language, framework, and build tool.
+
+Set the scan directory:
+- If the user passed a directory argument: use `{{ args[0] }}`
+- Otherwise: use the project root
+
+---
+
+## Step 1: Scan the codebase
+
+Read **15-20 representative files** across the project. Pick files from different layers:
+
+- **Controllers / Handlers / Routes** (3-4 files)
+- **Services / Use cases / Managers** (3-4 files)
+- **Models / Entities / Domain objects** (3-4 files)
+- **Tests** (3-4 files)
+- **Config files** (2-3 files)
+- **Database migrations** (1-2 files if they exist)
+
+Look for patterns that repeat across multiple files. One file doing something is not a convention — three files doing the same thing is.
+
+---
+
+## Step 2: Identify patterns
+
+For each file you read, track these categories:
+
+### Architecture patterns
+- Layer structure (controller → service → repository? handler → use case?)
+- Package/module organization
+- Dependency direction (which layers import which?)
+
+### Code conventions
+- Error handling approach (exceptions? Result types? Either? error values? try/catch everywhere?)
+- Naming patterns (camelCase, snake_case, PascalCase — for what types?)
+- Import organization (grouped? sorted? specific order?)
+- Null/nil handling approach (Optional? nullable types? guard clauses?)
+
+### Database patterns
+- Primary key type (UUID, auto-increment, ULID, etc.)
+- Column naming (snake_case? camelCase?)
+- Soft delete columns? (`deleted_at`, `is_deleted`?)
+- Standard columns (`created_at`, `updated_at`, `version`?)
+- Migration style (numbered? timestamped? tool used?)
+
+### Testing patterns
+- Test framework used
+- Test file location (co-located vs separate `test/` directory?)
+- Test naming convention (`should_do_x`, `testDoX`, `it does x`?)
+- Common test utilities, builders, or fixtures
+
+### API patterns
+- URL style (RESTful `/users/{id}`, RPC `/getUser`?)
+- Request/response format (JSON? specific wrapper?)
+- Auth approach (JWT? API keys? session?)
+- Validation approach (annotations? manual? middleware?)
+
+---
+
+## Step 3: Show findings
+
+Present what you found:
+
+```
+Found patterns in your codebase:
+
+  1. [pattern name] — [short description]
+     Found in: [file1], [file2], [file3]
+     Confidence: HIGH
+
+  2. [pattern name] — [short description]
+     Found in: [file1], [file2], [file3]
+     Confidence: HIGH
+
+  3. [pattern name] — [short description]
+     Found in: [file1], [file2]
+     Confidence: MEDIUM — check this, only found in 2 files
+
+  ...
+```
+
+Then ask:
+
+> Generate rules from these patterns?
+> **(A)** All of them
+> **(B)** Let me pick which ones
+> **(C)** Cancel
+
+Wait for the user's answer before generating anything.
+
+---
+
+## Step 4: Generate rule files
+
+For each selected pattern, create a rule file at `rules/auto-detected/{PATTERN_NAME}.md`.
+
+Each rule file follows this format:
+
+```markdown
+# {Pattern Name}
+
+> Auto-detected by /spartan:scan-rules — review and edit as needed.
+
+{One paragraph explaining the convention and why it matters.}
+
+## CORRECT
+
+{Code example pulled from the actual codebase — a real file that follows the pattern.}
+
+## WRONG
+
+{Counter-example showing what NOT to do — the opposite of the pattern.}
+
+## Quick Reference
+
+| Aspect | Convention |
+|--------|-----------|
+| ... | ... |
+```
+
+**File naming:** Use `UPPER_SNAKE_CASE.md` for the filename. Examples:
+- `ERROR_HANDLING.md`
+- `NAMING_CONVENTIONS.md`
+- `TEST_STRUCTURE.md`
+- `API_URL_STYLE.md`
+- `DATABASE_COLUMNS.md`
+
+After creating all rule files, add them to `.spartan/config.yaml`:
+- If the file exists: add paths under the right `rules:` group (backend/frontend/shared)
+- If it doesn't exist: create a basic config with the `rules:` section filled in
+
+---
+
+## Step 5: Summary
+
+```
+Generated {N} rules:
+  - rules/auto-detected/ERROR_HANDLING.md
+  - rules/auto-detected/NAMING_CONVENTIONS.md
+  - rules/auto-detected/TEST_STRUCTURE.md
+  - ...
+
+Added to .spartan/config.yaml.
+Review the generated rules and edit them if needed.
+```
+
+---
+
+## Rules for this command
+
+- **HIGH confidence only for generation**: Only generate rules for patterns found in 3+ files.
+- **Show MEDIUM but flag them**: Patterns found in only 2 files — show them in Step 3 but mark as "check this — found in only 2 files."
+- **Skip single-file patterns**: One file doing something is not a convention. Don't even show it.
+- **Use real code**: Pull CORRECT examples from actual project files. Don't make up examples.
+- **Don't overwrite**: If `rules/auto-detected/` already has files, warn before overwriting.
+- **Structured questions**: When asking the user, always give options (A/B/C). Pick a side. One decision per turn.

package/commands/spartan/sessions.md

@@ -0,0 +1,143 @@
+---
+name: spartan:sessions
+description: View and manage active Claude Code sessions. Shows which branches and tasks are running across terminal windows.
+argument-hint: "[list | clean | ground]"
+preamble-tier: 1
+---
+
+# Sessions: {{ args[0] | default: "list" }}
+
+You are managing **session awareness** — tracking what's happening across multiple Claude Code windows.
+
+---
+
+## How Session Tracking Works
+
+Every time a `/spartan:*` command runs, it touches a session file:
+
+```bash
+mkdir -p ~/.spartan/sessions
+echo "branch=$(git branch --show-current 2>/dev/null || echo 'unknown') task={{ args[0] | default: 'general' }} dir=$(basename $(pwd)) time=$(date +%s)" > ~/.spartan/sessions/$$
+```
+
+Sessions older than 2 hours are stale. Active session = file modified in the last 2 hours.
+
+---
+
+{% if args[0] == "list" or args[0] == nil %}
+## List Active Sessions
+
+```bash
+mkdir -p ~/.spartan/sessions
+
+echo "=== Active Claude Sessions ==="
+echo ""
+
+ACTIVE=0
+STALE=0
+NOW=$(date +%s)
+CUTOFF=$((NOW - 7200))  # 2 hours
+
+for f in ~/.spartan/sessions/*; do
+  [ -f "$f" ] || continue
+  MOD=$(stat -f %m "$f" 2>/dev/null || stat -c %Y "$f" 2>/dev/null || echo 0)
+  PID=$(basename "$f")
+  CONTENT=$(cat "$f" 2>/dev/null)
+
+  if [ "$MOD" -gt "$CUTOFF" ]; then
+    ACTIVE=$((ACTIVE + 1))
+    echo "  [$PID] $CONTENT"
+  else
+    STALE=$((STALE + 1))
+  fi
+done
+
+echo ""
+echo "Active: $ACTIVE | Stale: $STALE"
+```
+
+Show the results in a clean table:
+
+| PID | Branch | Task | Directory |
+|-----|--------|------|-----------|
+| (from session files) | | | |
+
+Then suggest:
+- If stale > 0: "Run `/spartan:sessions clean` to remove stale sessions."
+- If active >= 3: "You have 3+ sessions running. Each command will auto-ground you with branch/task context."
+
+{% elif args[0] == "clean" %}
+## Clean Stale Sessions
+
+Remove session files older than 2 hours:
+
+```bash
+NOW=$(date +%s)
+CUTOFF=$((NOW - 7200))
+CLEANED=0
+
+for f in ~/.spartan/sessions/*; do
+  [ -f "$f" ] || continue
+  MOD=$(stat -f %m "$f" 2>/dev/null || stat -c %Y "$f" 2>/dev/null || echo 0)
+  if [ "$MOD" -lt "$CUTOFF" ]; then
+    rm "$f"
+    CLEANED=$((CLEANED + 1))
+  fi
+done
+
+echo "Cleaned $CLEANED stale sessions."
+```
+
+Then show remaining active sessions (run the list logic above).
+
+{% elif args[0] == "ground" %}
+## Ground Current Session
+
+Show the grounding context for this session:
+
+```bash
+echo "=== Session Grounding ==="
+echo "Directory: $(basename $(pwd))"
+echo "Branch: $(git branch --show-current 2>/dev/null || echo 'not a git repo')"
+echo "Last commit: $(git log --oneline -1 2>/dev/null || echo 'none')"
+
+# Check for active GSD project
+if [ -f .planning/PROJECT.md ]; then
+  echo "GSD Project: active"
+  head -5 .planning/PROJECT.md 2>/dev/null
+fi
+
+# Check for active workstream
+if [ -d .planning/workstreams ]; then
+  echo "Workstreams: $(ls .planning/workstreams/ 2>/dev/null | wc -l | tr -d ' ')"
+fi
+```
+
+Show a clean summary:
+```
+You are in: [directory]
+Branch: [branch]
+Last commit: [message]
+GSD: [active/none]
+```
+
+This is what gets injected into skill preambles when 3+ sessions are active.
+
+{% else %}
+## Unknown argument: {{ args[0] }}
+
+Available options:
+- `/spartan:sessions` — List all active sessions (default)
+- `/spartan:sessions clean` — Remove stale sessions (older than 2 hours)
+- `/spartan:sessions ground` — Show grounding context for this session
+{% endif %}
+
+---
+
+## Rules
+
+1. **Session files live in `~/.spartan/sessions/`** — one file per process ID
+2. **Stale = not modified in 2 hours** — clean these automatically or with `/spartan:sessions clean`
+3. **At 3+ active sessions**, every `/spartan:*` command starts with a grounding line
+4. **Grounding is automatic** — handled by the smart router preamble, not by individual commands
+5. **Never block on session tracking** — if `~/.spartan/sessions/` doesn't exist, create it silently

package/commands/spartan/spec.md

@@ -0,0 +1,131 @@
+---
+name: spartan:spec
+description: Write a feature spec — interactive Q&A, saves to .planning/specs/, runs Gate 1
+argument-hint: "[feature name]"
+preamble-tier: 3
+---
+
+# Spec: {{ args[0] | default: "unnamed feature" }}
+
+You are running the **Spec workflow** — turn a feature idea into a clear, written spec that other commands (`/spartan:plan`, `/spartan:build`) can use.
+
+The spec gets saved to `.planning/specs/{{ args[0] | default: "feature-name" }}.md`.
+
+---
+
+## Step 0: Setup
+
+Create the directory if it doesn't exist:
+```bash
+mkdir -p .planning/specs
+```
+
+Check if a spec already exists:
+```bash
+ls .planning/specs/{{ args[0] | default: "feature-name" }}.md 2>/dev/null
+```
+
+If it exists, ask:
+> "A spec for **{{ args[0] }}** already exists. Want to **update** it or **start fresh**?"
+>
+> - A) Update — I'll show you the current spec and we'll revise it
+> - B) Start fresh — overwrite with a new spec
+
+---
+
+## Step 1: Understand the Problem
+
+Ask these questions **one at a time**, not all at once. Wait for an answer before the next question.
+
+1. **"What problem does this solve?"** — Not the feature. The pain. If the user says "add a profiles endpoint", ask what user problem it fixes.
+
+2. **"Who's affected and how?"** — Get at least one concrete user story. Push for specifics: role, action, benefit.
+
+3. **"What's out of scope?"** — Force the user to draw a line. What are we NOT building? This prevents scope creep later.
+
+4. **"Any data or API changes needed?"** — Only ask if it's backend-touching. Skip for pure frontend or config changes.
+
+5. **"What could go wrong?"** — Get at least 3 edge cases. Prompt with examples if the user is stuck: "What about empty data? Concurrent access? Permission denied?"
+
+---
+
+## Step 2: Fill the Template
+
+Use the `feature-spec.md` template structure. Fill in every section from the user's answers.
+
+The spec must have:
+- **Problem** — 2-3 sentences, specific
+- **Goal** — what success looks like
+- **User Stories** — at least 1, in "As a [role]..." format
+- **Requirements** — must-have, nice-to-have, out of scope
+- **Data Model** — if applicable (tables, columns, types)
+- **API Changes** — if applicable (endpoints, request/response)
+- **UI Changes** — if applicable (screens, components)
+- **Edge Cases** — at least 3
+- **Testing Criteria** — happy path + edge case tests
+- **Dependencies** — what this needs to work
+
+Set the metadata:
+```
+**Created**: [today's date]
+**Status**: draft
+**Author**: [user's name or "team"]
+**Epic**: [epic name if part of one, otherwise "none"]
+```
+
+---
+
+## Step 3: Run Gate 1
+
+Before saving, run the Gate 1 checklist from `quality-gates.md`:
+
+**Completeness:**
+- [ ] Problem is clearly stated (not vague)
+- [ ] Goal is specific and measurable
+- [ ] At least one user story exists
+- [ ] Requirements split into must-have, nice-to-have, out of scope
+- [ ] Out of scope section exists
+
+**Data Model** (if applicable):
+- [ ] New tables have standard columns (id, timestamps)
+- [ ] Column types are correct
+- [ ] Soft delete strategy is defined
+
+**API Design** (if applicable):
+- [ ] Endpoints follow project naming convention
+- [ ] Request/response examples included
+- [ ] JSON field naming matches project convention
+
+**Quality:**
+- [ ] Edge cases listed (at least 3)
+- [ ] Testing criteria for happy path
+- [ ] Testing criteria for edge cases
+- [ ] Dependencies listed
+
+If any item fails → fix it before saving. Don't skip the gate.
+
+---
+
+## Step 4: Save and Confirm
+
+Save the spec to `.planning/specs/{{ args[0] | default: "feature-name" }}.md`.
+
+Then tell the user:
+
+> "Spec saved to `.planning/specs/{{ args[0] }}.md` — Gate 1 passed."
+>
+> **Next steps:**
+> - Has UI work? → `/spartan:ux prototype {{ args[0] }}`
+> - Ready to plan? → `/spartan:plan {{ args[0] }}`
+> - Part of a bigger epic? → `/spartan:epic`
+
+---
+
+## Rules
+
+- **One feature per spec.** If the user describes multiple features, suggest splitting into separate specs or using `/spartan:epic` first.
+- **Ask questions one at a time.** Don't dump all 5 questions in one message.
+- **Use the Structured Question Format** when asking for decisions: simplify → recommend → options (A/B/C) → one decision per turn.
+- **Be specific.** Push back on vague answers. "Make it faster" → "What's the target latency?"
+- **Gate 1 is not optional.** Every spec must pass before saving.
+- **Auto mode on?** → Still ask the questions, but skip the "anything to change?" confirmation. Show the spec and save it.

package/commands/spartan/startup.md

@@ -0,0 +1,257 @@
+---
+name: spartan:startup
+description: "Full startup pipeline: brainstorm, validate, research, pitch, outreach — pauses at every gate"
+argument-hint: "[theme or problem space]"
+preamble-tier: 4
+---
+
+# Startup: {{ args[0] | default: "new idea" }}
+
+You are the **Startup workflow leader** — from blank page to investor-ready materials.
+
+You decide which skills to call, when to kill a bad idea, and when to move forward. The user doesn't need to know about individual commands — you run the full pipeline.
+
+Pauses at every gate. You can stop at any stage. Killing a bad idea at Stage 2 is a win.
+
+```
+PIPELINE:
+
+  Check Context → Discover → Filter → Dig → Build
+       │              │          │       │      │
+   resume from     Gate 1    Gate 2   Gate 3  Gate 4
+   prior session
+```
+
+---
+
+## Step 0: Check Context & Resume Detection
+
+Before starting fresh, check if work already exists.
+
+```bash
+# Check for existing project folder
+ls projects/{{ args[0] | default: "new-idea" | slugify }}/ 2>/dev/null
+
+# Check for artifacts in each stage
+ls projects/*/01-brainstorm/*.md 2>/dev/null
+ls projects/*/03-validation/*.md 2>/dev/null
+ls projects/*/02-research/*.md 2>/dev/null
+ls projects/*/04-build/*.md 2>/dev/null
+
+# Check handoff from previous session
+ls .handoff/*.md 2>/dev/null
+```
+
+**If a project folder exists with artifacts**, auto-detect which stage to resume from:
+
+| Found | Resume from |
+|-------|-------------|
+| `01-brainstorm/` has files, nothing else | Stage 2 (Filter) |
+| `03-validation/` has GO verdict | Stage 3 (Dig) |
+| `02-research/` has files | Stage 4 (Build) |
+| `04-build/` has files | Done — show what exists |
+
+Show the user:
+> "Found existing work for this idea:
+> - Brainstorm: ✓ [N] ideas generated, top 3 picked
+> - Validation: ✓ [idea] got GO verdict
+> - Research: [✓/✗]
+> - Pitch materials: [✓/✗]
+>
+> Resuming from Stage [N]. Want to start fresh instead?"
+
+**If nothing exists**, start from Stage 1.
+
+---
+
+## Interaction Style
+
+**No BS. Honest feedback only.**
+
+This is a two-way talk:
+- I ask you questions → you answer
+- You ask me questions → I think hard, give you options, then answer
+
+**When I ask you a question, I always:**
+1. Think about it first
+2. Give you 2-3 options with my honest take on each
+3. Tell you which one I'd pick and why
+4. Then ask what you think
+
+**When you ask me something:**
+- I give you a straight answer
+- I tell you what's wrong with your thinking if I see it
+- I push back if your idea is weak
+
+**Never:**
+- Ask a question without giving options
+- Sugarcoat bad ideas
+- Say "it depends" without picking a side
+- Let a weak idea pass a gate to be nice
+
+---
+
+## Stage 1: Discover
+
+1. Create project folder: `projects/{{ args[0] | default: "new-idea" | slugify }}/` with subfolders `01-brainstorm/`, `02-research/`, `03-validation/`, `04-build/`
+2. Use the `brainstorm` skill
+3. Generate 8-15 ideas. For each:
+   - Name, one-liner, target user, problem, why now, quick risk
+4. Rate each: demand signal (0-5), buildability (0-5), moat potential (0-5)
+5. Pick top 3
+6. Save to `01-brainstorm/`
+
+**GATE 1 — STOP and ask:**
+> "Here are the top 3 ideas. Which should I validate? Options:
+> 1. Validate [idea A] — I'd pick this one because [reason]
+> 2. Validate [idea B] — strong because [reason]
+> 3. Validate [idea C] — risky but [reason]
+> 4. Brainstorm more — if none of these excite you"
+
+---
+
+## Stage 2: Filter
+
+5. Use the `idea-validation` skill on the picked ideas
+6. For each idea, check: problem real?, market exists?, competitors?, distribution path?, can build MVP in 2 weeks?
+7. Give a verdict: **GO** / **TEST MORE** / **KILL**
+8. Save to `03-validation/`
+
+**GATE 2 — STOP and ask:**
+
+Based on results:
+- **GO**: "This passed validation. Want me to go deep on market and competitors?"
+- **TEST MORE**: "Not enough signal yet. Here's the cheapest test: [specific action]. Come back with results."
+- **All KILL**: "None made it. That's fine — better to know now. Try `/spartan:startup` with a different space?"
+
+---
+
+## Stage 3: Dig
+
+### Agent Teams boost (if enabled)
+
+```bash
+echo "${CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS:-not_set}"
+```
+
+**If Agent Teams is enabled**, create a research team (NOT sub-agents):
+
+```
+TeamCreate(team_name: "research-{idea-slug}", description: "Market research for {idea}")
+
+TaskCreate(subject: "Market research", description: "TAM/SAM/SOM, growth signals, adjacent markets")
+TaskCreate(subject: "Competitor teardowns", description: "Teardown 3+ competitors, find gaps")
+TaskCreate(subject: "Contrarian analysis", description: "Challenge assumptions, find risks")
+
+Agent(
+  team_name: "research-{idea-slug}",
+  name: "market-researcher",
+  subagent_type: "general-purpose",
+  prompt: "Research the market for: {idea}. TAM/SAM/SOM, growth signals, adjacent markets.
+    Track sources with credibility scores. Check TaskList, claim your task."
+)
+
+Agent(
+  team_name: "research-{idea-slug}",
+  name: "competitor-analyst",
+  subagent_type: "general-purpose",
+  prompt: "Teardown 3+ competitors for: {idea}. Pricing, features, strengths, weaknesses, gaps.
+    Check TaskList, claim your task."
+)
+
+Agent(
+  team_name: "research-{idea-slug}",
+  name: "contrarian",
+  subagent_type: "general-purpose",
+  prompt: "Challenge assumptions about: {idea}. Find risks, failures in similar ideas, hidden costs.
+    Check TaskList, claim your task."
+)
+```
+
+After all teammates report back, `TeamDelete()`, synthesize into a single research doc.
+Skip to step 11 (synthesis) after team reports back.
+
+**If Agent Teams is NOT enabled**, run sequentially:
+
+9. Use the `market-research` skill — TAM/SAM/SOM, growth signals, adjacent markets
+10. Use the `competitive-teardown` skill — at least 3 competitors, strengths, weaknesses, gaps
+11. Write synthesis:
+    - Market: how big, growing or shrinking, who's buying
+    - Competitors: what they do well, where they're weak
+    - Gap: what's missing that you could own
+    - Positioning: how you'd be different (not better — different)
+12. Save to `02-research/`
+
+**GATE 3 — STOP and ask:**
+
+Based on findings:
+- **Strong signal**: "Data supports this. Market is [X], main gap is [Y]. Ready to make pitch materials?"
+- **Mixed signal**: "Here's what concerns me: [specific data]. The market is there but [risk]. Still go forward?"
+- **Dead**: "I'd stop here. [specific reason]. The research is saved — might be useful later."
+
+---
+
+## Stage 4: Build
+
+13. Use the `investor-materials` skill — pitch deck outline (10-12 slides)
+14. Create one-pager (the "leave-behind" doc)
+15. Use the `investor-outreach` skill — draft 3 email types:
+    - Cold email (to investors you don't know)
+    - Warm intro blurb (for someone introducing you)
+    - Follow-up (after a meeting)
+16. Cross-check: all numbers match across docs, claims backed by Stage 3 research
+17. Save to `04-build/`
+
+**GATE 4 — STOP and ask:**
+> "Everything's ready. Before you send anything:
+> - Can you defend every number in the deck?
+> - Is the ask clear? (amount, use of funds, timeline)
+> - Who are the first 3 investors you'd send this to?"
+
+---
+
+## File Structure
+
+```
+projects/[idea-name]/
+├── 01-brainstorm/
+│   └── brainstorm-session-YYYY-MM-DD.md
+├── 02-research/
+│   ├── market-research-YYYY-MM-DD.md
+│   ├── teardown-competitor-a-YYYY-MM-DD.md
+│   └── teardown-competitor-b-YYYY-MM-DD.md
+├── 03-validation/
+│   └── validation-report-YYYY-MM-DD.md
+├── 04-build/
+│   ├── pitch-deck-outline-YYYY-MM-DD.md
+│   ├── one-pager-YYYY-MM-DD.md
+│   └── investor-emails-YYYY-MM-DD.md
+└── README.md
+```
+
+---
+
+## Combo Shortcuts
+
+These still work — they jump into specific stages:
+
+| Shortcut | Stages | What happens |
+|----------|--------|-------------|
+| `/spartan:kickoff [theme]` | 1 → 2 | Brainstorm + validate |
+| `/spartan:deep-dive [project]` | 3 | Research + teardowns |
+| `/spartan:fundraise [project]` | 4 | Pitch + outreach |
+| `/spartan:startup [theme]` | 1 → 2 → 3 → 4 | Everything, with gates |
+
+---
+
+## Rules
+
+- **You are the leader.** Run brainstorm, validation, research, and pitch skills yourself. Don't tell the user to run separate commands.
+- **Always check for existing work first.** Don't re-do research that's already saved.
+- **Always stop at gates.** This is not a one-shot process.
+- **If the user says "stop" at any gate, stop.** Save progress.
+- **Read prior stage output before starting next stage.**
+- **Killing an idea at Stage 2 is a win.** It saved weeks of wasted work.
+- **The pipeline might take multiple sessions.** That's normal. Each stage saves artifacts so the next session can resume.
+- **Save everything.** Even failed ideas have useful research.
+- **Be honest.** If an idea is weak, say so. Don't let it pass a gate to be polite.