remove .claude/ and dist/ from repository

These directories are already in .gitignore but were committed
before the ignore rules were added. Removed from tracking while
keeping local files intact.

.claude/agents.toml

···
-# Project Subagents Configuration
-# Domain-specific agents for working on different parts of the codebase.
-#
-# When working on a specific domain, spawn a Task with subagent_type="Explore" or
-# "general-purpose" and include the relevant agent's context in the prompt.
-#
-# Customize this file for YOUR project's structure. The domains below are examples.
-
-# Example: Backend/Core agent
-# [agents.backend]
-# name = "Backend Agent"
-# description = "API routes, database models, business logic"
-# file_patterns = [
-#     "src/**/*.rs",
-#     "src/**/*.py",
-#     "app/**/*.py"
-# ]
-# focus_areas = [
-#     "Database operations",
-#     "API endpoints",
-#     "Business logic"
-# ]
-# instructions = """
-# When working on backend:
-# - Run tests before and after changes
-# - Follow existing patterns for new endpoints
-# - Maintain backwards compatibility
-# """
-
-# Example: Frontend agent
-# [agents.frontend]
-# name = "Frontend Agent"
-# description = "UI components, state management, styling"
-# file_patterns = [
-#     "web/src/**/*.ts",
-#     "web/src/**/*.tsx",
-#     "src/components/**"
-# ]
-# focus_areas = [
-#     "React components",
-#     "State management",
-#     "Styling and layout"
-# ]
-# instructions = """
-# When working on frontend:
-# - Test in browser after changes
-# - Follow component patterns
-# - Keep accessibility in mind
-# """
-
-# Example: Infrastructure agent
-# [agents.infra]
-# name = "Infrastructure Agent"
-# description = "CI/CD, deployment, configuration"
-# file_patterns = [
-#     ".github/workflows/**",
-#     "Dockerfile",
-#     "docker-compose.yml",
-#     "scripts/**"
-# ]
-# focus_areas = [
-#     "GitHub Actions",
-#     "Docker configuration",
-#     "Deployment scripts"
-# ]
-# instructions = """
-# When working on infrastructure:
-# - Test workflows locally when possible
-# - Keep builds fast with caching
-# - Document any manual steps
-# """

.claude/commands/deciduous.decision.md

···
----
-description: Manage decision graph - track algorithm choices and reasoning
-allowed-tools: Bash(deciduous:*)
-argument-hint: <action> [args...]
----
-
-# Decision Graph Management
-
-**Log decisions IN REAL-TIME as you work, not retroactively.**
-
-## When to Use This
-
-| You're doing this... | Log this type | Command |
-|---------------------|---------------|---------|
-| Starting a new feature | `goal` **with -p** | `/decision add goal "Add user auth" -p "user request"` |
-| Choosing between approaches | `decision` | `/decision add decision "Choose auth method"` |
-| Considering an option | `option` | `/decision add option "JWT tokens"` |
-| About to write code | `action` | `/decision add action "Implementing JWT"` |
-| Noticing something | `observation` | `/decision add obs "Found existing auth code"` |
-| Finished something | `outcome` | `/decision add outcome "JWT working"` |
-
-## Quick Commands
-
-Based on $ARGUMENTS:
-
-### View Commands
-- `nodes` or `list` -> `deciduous nodes`
-- `edges` -> `deciduous edges`
-- `graph` -> `deciduous graph`
-- `commands` -> `deciduous commands`
-
-### Create Nodes (with optional metadata)
-- `add goal <title>` -> `deciduous add goal "<title>" -c 90`
-- `add decision <title>` -> `deciduous add decision "<title>" -c 75`
-- `add option <title>` -> `deciduous add option "<title>" -c 70`
-- `add action <title>` -> `deciduous add action "<title>" -c 85`
-- `add obs <title>` -> `deciduous add observation "<title>" -c 80`
-- `add outcome <title>` -> `deciduous add outcome "<title>" -c 90`
-
-### Optional Flags for Nodes
-- `-c, --confidence <0-100>` - Confidence level
-- `-p, --prompt "..."` - Store the user prompt that triggered this node
-- `-f, --files "src/main.py,lib/utils.js"` - Associate files with this node
-- `-b, --branch <name>` - Git branch (auto-detected by default)
-- `--no-branch` - Skip branch auto-detection
-- `--commit <hash|HEAD>` - Link to a git commit (use HEAD for current commit)
-
-### ⚠️ CRITICAL: Link Commits to Actions/Outcomes
-
-**After every git commit, link it to the decision graph!**
-
-```bash
-git commit -m "feat: add auth"
-deciduous add action "Implemented auth" -c 90 --commit HEAD
-deciduous link <goal_id> <action_id> -r "Implementation"
-```
-
-## CRITICAL: Capture VERBATIM User Prompts
-
-**Prompts must be the EXACT user message, not a summary.** When a user request triggers new work, capture their full message word-for-word.
-
-**BAD - summaries are useless for context recovery:**
-```bash
-# DON'T DO THIS - this is a summary, not a prompt
-deciduous add goal "Add auth" -p "User asked: add login to the app"
-```
-
-**GOOD - verbatim prompts enable full context recovery:**
-```bash
-# Use --prompt-stdin for multi-line prompts
-deciduous add goal "Add auth" -c 90 --prompt-stdin << 'EOF'
-I need to add user authentication to the app. Users should be able to sign up
-with email/password, and we need OAuth support for Google and GitHub. The auth
-should use JWT tokens with refresh token rotation.
-EOF
-
-# Or use the prompt command to update existing nodes
-deciduous prompt 42 << 'EOF'
-The full verbatim user message goes here...
-EOF
-```
-
-**When to capture prompts:**
-- Root `goal` nodes: YES - the FULL original request
-- Major direction changes: YES - when user redirects the work
-- Routine downstream nodes: NO - they inherit context via edges
-
-**Updating prompts on existing nodes:**
-```bash
-deciduous prompt <node_id> "full verbatim prompt here"
-cat prompt.txt | deciduous prompt <node_id>  # Multi-line from stdin
-```
-
-Prompts are viewable in the TUI detail panel (`deciduous tui`) and web viewer.
-
-## Branch-Based Grouping
-
-**Nodes are automatically tagged with the current git branch.** This enables filtering by feature/PR.
-
-### How It Works
-- When you create a node, the current git branch is stored in `metadata_json`
-- Configure which branches are "main" in `.deciduous/config.toml`:
-  ```toml
-  [branch]
-  main_branches = ["main", "master"]  # Branches not treated as "feature branches"
-  auto_detect = true                    # Auto-detect branch on node creation
-  ```
-- Nodes on feature branches (anything not in `main_branches`) can be grouped/filtered
-
-### CLI Filtering
-```bash
-# Show only nodes from specific branch
-deciduous nodes --branch main
-deciduous nodes --branch feature-auth
-deciduous nodes -b my-feature
-
-# Override auto-detection when creating nodes
-deciduous add goal "Feature work" -b feature-x  # Force specific branch
-deciduous add goal "Universal note" --no-branch  # No branch tag
-```
-
-### Web UI Branch Filter
-The graph viewer shows a branch dropdown in the stats bar:
-- "All branches" shows everything
-- Select a specific branch to filter all views (Chains, Timeline, Graph, DAG)
-
-### When to Use Branch Grouping
-- **Feature work**: Nodes created on `feature-auth` branch auto-grouped
-- **PR context**: Filter to see only decisions for a specific PR
-- **Cross-cutting concerns**: Use `--no-branch` for universal notes
-- **Retrospectives**: Filter by branch to see decision history per feature
-
-### Create Edges
-- `link <from> <to> [reason]` -> `deciduous link <from> <to> -r "<reason>"`
-
-### Sync Graph
-- `sync` -> `deciduous sync`
-
-### Multi-User Sync (Diff/Patch)
-- `diff export -o <file>` -> `deciduous diff export -o <file>` (export nodes as patch)
-- `diff export --nodes 1-10 -o <file>` -> export specific nodes
-- `diff export --branch feature-x -o <file>` -> export nodes from branch
-- `diff apply <file>` -> `deciduous diff apply <file>` (apply patch, idempotent)
-- `diff apply --dry-run <file>` -> preview without applying
-- `diff status` -> `deciduous diff status` (list patches in .deciduous/patches/)
-- `migrate` -> `deciduous migrate` (add change_id columns for sync)
-
-### Export & Visualization
-- `dot` -> `deciduous dot` (output DOT to stdout)
-- `dot --png` -> `deciduous dot --png -o graph.dot` (generate PNG)
-- `dot --nodes 1-11` -> `deciduous dot --nodes 1-11` (filter nodes)
-- `writeup` -> `deciduous writeup` (generate PR writeup)
-- `writeup -t "Title" --nodes 1-11` -> filtered writeup
-
-## Node Types
-
-| Type | Purpose | Example |
-|------|---------|---------|
-| `goal` | High-level objective | "Add user authentication" |
-| `decision` | Choice point with options | "Choose auth method" |
-| `option` | Possible approach | "Use JWT tokens" |
-| `action` | Something implemented | "Added JWT middleware" |
-| `outcome` | Result of action | "JWT auth working" |
-| `observation` | Finding or data point | "Existing code uses sessions" |
-
-## Edge Types
-
-| Type | Meaning |
-|------|---------|
-| `leads_to` | Natural progression |
-| `chosen` | Selected option |
-| `rejected` | Not selected (include reason!) |
-| `requires` | Dependency |
-| `blocks` | Preventing progress |
-| `enables` | Makes something possible |
-
-## Graph Integrity - CRITICAL
-
-**Every node MUST be logically connected.** Floating nodes break the graph's value.
-
-### Connection Rules
-| Node Type | MUST connect to | Example |
-|-----------|----------------|---------|
-| `outcome` | The action/goal it resolves | "JWT working" → links FROM "Implementing JWT" |
-| `action` | The decision/goal that spawned it | "Implementing JWT" → links FROM "Add auth" |
-| `option` | Its parent decision | "Use JWT" → links FROM "Choose auth method" |
-| `observation` | Related goal/action/decision | "Found existing code" → links TO relevant node |
-| `decision` | Parent goal (if any) | "Choose auth" → links FROM "Add auth feature" |
-| `goal` | Can be a root (no parent needed) | Root goals are valid orphans |
-
-### Audit Checklist
-Ask yourself after creating nodes:
-1. Does every **outcome** link back to what caused it?
-2. Does every **action** link to why you did it?
-3. Does every **option** link to its decision?
-4. Are there **dangling outcomes** with no parent action/goal?
-
-### Find Disconnected Nodes
-```bash
-# List nodes with no incoming edges (potential orphans)
-deciduous edges | cut -d'>' -f2 | cut -d' ' -f2 | sort -u > /tmp/has_parent.txt
-deciduous nodes | tail -n+3 | awk '{print $1}' | while read id; do
-  grep -q "^$id$" /tmp/has_parent.txt || echo "CHECK: $id"
-done
-```
-Note: Root goals are VALID orphans. Outcomes/actions/options usually are NOT.
-
-### Fix Missing Connections
-```bash
-deciduous link <parent_id> <child_id> -r "Retroactive connection - <why>"
-```
-
-### When to Audit
-- Before every `deciduous sync`
-- After creating multiple nodes quickly
-- At session end
-- When the web UI graph looks disconnected
-
-## Multi-User Sync
-
-**Problem**: Multiple users work on the same codebase, each with a local `.deciduous/deciduous.db` (gitignored). How to share decisions?
-
-**Solution**: jj-inspired dual-ID model. Each node has:
-- `id` (integer): Local database primary key, different per machine
-- `change_id` (UUID): Globally unique, stable across all databases
-
-### Export Workflow
-```bash
-# Export nodes from your branch as a patch file
-deciduous diff export --branch feature-x -o .deciduous/patches/alice-feature.json
-
-# Or export specific node IDs
-deciduous diff export --nodes 172-188 -o .deciduous/patches/alice-feature.json --author alice
-```
-
-### Apply Workflow
-```bash
-# Apply patches from teammates (idempotent - safe to re-apply)
-deciduous diff apply .deciduous/patches/*.json
-
-# Preview what would change
-deciduous diff apply --dry-run .deciduous/patches/bob-refactor.json
-```
-
-### PR Workflow
-1. Create nodes locally while working
-2. Export: `deciduous diff export --branch my-feature -o .deciduous/patches/my-feature.json`
-3. Commit the patch file (NOT the database)
-4. Open PR with patch file included
-5. Teammates pull and apply: `deciduous diff apply .deciduous/patches/my-feature.json`
-6. **Idempotent**: Same patch applied twice = no duplicates
-
-### Patch Format (JSON)
-```json
-{
-  "version": "1.0",
-  "author": "alice",
-  "branch": "feature/auth",
-  "nodes": [{ "change_id": "uuid...", "title": "...", ... }],
-  "edges": [{ "from_change_id": "uuid1", "to_change_id": "uuid2", ... }]
-}
-```
-
-## The Rule
-
-```
-LOG BEFORE YOU CODE, NOT AFTER.
-CONNECT EVERY NODE TO ITS PARENT.
-AUDIT FOR ORPHANS REGULARLY.
-SYNC BEFORE YOU PUSH.
-EXPORT PATCHES FOR YOUR TEAMMATES.
-```
-
-**Live graph**: https://notactuallytreyanastasio.github.io/deciduous/

.claude/commands/deciduous.recover.md

···
----
-description: Recover context from decision graph and recent activity - USE THIS ON SESSION START
-allowed-tools: Bash(deciduous:*, git:*, cat:*, tail:*)
-argument-hint: [focus-area]
----
-
-# Context Recovery
-
-**RUN THIS AT SESSION START.** The decision graph is your persistent memory.
-
-## Step 1: Query the Graph
-
-```bash
-# See all decisions (look for recent ones and pending status)
-deciduous nodes
-
-# Filter by current branch (useful for feature work)
-deciduous nodes --branch $(git rev-parse --abbrev-ref HEAD)
-
-# See how decisions connect
-deciduous edges
-
-# What commands were recently run?
-deciduous commands
-```
-
-**Branch-scoped context**: If working on a feature branch, filter nodes to see only decisions relevant to this branch. Main branch nodes are tagged with `[branch: main]`.
-
-## Step 1.5: Audit Graph Integrity
-
-**CRITICAL: Check that all nodes are logically connected.**
-
-```bash
-# Find nodes with no incoming edges (potential missing connections)
-deciduous edges | cut -d'>' -f2 | cut -d' ' -f2 | sort -u > /tmp/has_parent.txt
-deciduous nodes | tail -n+3 | awk '{print $1}' | while read id; do
-  grep -q "^$id$" /tmp/has_parent.txt || echo "CHECK: $id"
-done
-```
-
-**Review each flagged node:**
-- Root `goal` nodes are VALID without parents
-- `outcome` nodes MUST link back to their action/goal
-- `action` nodes MUST link to their parent goal/decision
-- `option` nodes MUST link to their parent decision
-
-**Fix missing connections:**
-```bash
-deciduous link <parent_id> <child_id> -r "Retroactive connection - <reason>"
-```
-
-## Step 2: Check Git State
-
-```bash
-git status
-git log --oneline -10
-git diff --stat
-```
-
-## Step 3: Check Session Log
-
-```bash
-cat git.log | tail -30
-```
-
-## After Gathering Context, Report:
-
-1. **Current branch** and pending changes
-2. **Branch-specific decisions** (filter by branch if on feature branch)
-3. **Recent decisions** (especially pending/active ones)
-4. **Last actions** from git log and command log
-5. **Open questions** or unresolved observations
-6. **Suggested next steps**
-
-### Branch Configuration
-
-Check `.deciduous/config.toml` for branch settings:
-```toml
-[branch]
-main_branches = ["main", "master"]  # Which branches are "main"
-auto_detect = true                    # Auto-detect branch on node creation
-```
-
----
-
-## REMEMBER: Real-Time Logging Required
-
-After recovering context, you MUST follow the logging workflow:
-
-```
-EVERY USER REQUEST → Log goal/decision first
-BEFORE CODE CHANGES → Log action
-AFTER CHANGES → Log outcome, link nodes
-BEFORE GIT PUSH → deciduous sync
-```
-
-**The user is watching the graph live.** Log as you go, not after.
-
-### Quick Logging Commands
-
-```bash
-# Root goal with user prompt (capture what the user asked for)
-deciduous add goal "What we're trying to do" -c 90 -p "User asked: <their request>"
-
-deciduous add action "What I'm about to implement" -c 85
-deciduous add outcome "What happened" -c 95
-deciduous link FROM TO -r "Connection reason"
-
-# Capture prompt when user redirects mid-stream
-deciduous add action "Switching approach" -c 85 -p "User said: use X instead"
-
-deciduous sync  # Do this frequently!
-```
-
-**When to use `--prompt`:** On root goals (always) and when user gives new direction mid-stream. Downstream nodes inherit context via edges.
-
----
-
-## Focus Areas
-
-If $ARGUMENTS specifies a focus, prioritize context for:
-
-- **auth**: Authentication-related decisions
-- **ui** / **graph**: UI and graph viewer state
-- **cli**: Command-line interface changes
-- **api**: API endpoints and data structures
-
----
-
-## The Memory Loop
-
-```
-SESSION START
-    ↓
-Run /recover → See past decisions
-    ↓
-AUDIT → Fix any orphan nodes first!
-    ↓
-DO WORK → Log BEFORE each action
-    ↓
-CONNECT → Link new nodes immediately
-    ↓
-AFTER CHANGES → Log outcomes, observations
-    ↓
-AUDIT AGAIN → Any new orphans?
-    ↓
-BEFORE PUSH → deciduous sync
-    ↓
-PUSH → Live graph updates
-    ↓
-SESSION END → Final audit
-    ↓
-(repeat)
-```
-
-**Live graph**: https://notactuallytreyanastasio.github.io/deciduous/
-
----
-
-## Multi-User Sync
-
-If working in a team, check for and apply patches from teammates:
-
-```bash
-# Check for unapplied patches
-deciduous diff status
-
-# Apply all patches (idempotent - safe to run multiple times)
-deciduous diff apply .deciduous/patches/*.json
-
-# Preview before applying
-deciduous diff apply --dry-run .deciduous/patches/teammate-feature.json
-```
-
-Before pushing your branch, export your decisions for teammates:
-
-```bash
-# Export your branch's decisions as a patch
-deciduous diff export --branch $(git rev-parse --abbrev-ref HEAD) \
-  -o .deciduous/patches/$(whoami)-$(git rev-parse --abbrev-ref HEAD).json
-
-# Commit the patch file
-git add .deciduous/patches/
-```
-
-## Why This Matters
-
-- Context loss during compaction loses your reasoning
-- The graph survives - query it early, query it often
-- Retroactive logging misses details - log in the moment
-- The user sees the graph live - show your work
-- Patches share reasoning with teammates

.claude/skills/deciduous/SKILL.md

···
----
-name: deciduous
-description: Plan, implement, track, and reflect on your work goals and decisions.
----
-
-# Planning & Decision Graph Logging
-
-Track every goal, decision, and outcome in the decision graph. This creates persistent memory that survives context loss.
-
-- ALWAYS LOG BEFORE YOU CODE, NOT AFTER.
-- Log at the granularity of TODOs or task items.
-- When drafting a plan create the GOAL node.
-- User Decisions should be tracked
-
-## When to Log (Automatic Triggers)
-
-| Situation | Node Type | Example |
-|-----------|-----------|---------|
-| In plan mode  | `goal` | "Add user authentication" |
-| TODO / Task Item | `action` | "Implementing JWT auth middleware" |
-| User requests new feature | `goal` | "Add user authentication" |
-| Choosing between approaches | `decision` | "Choose between JWT vs sessions" |
-| Considering an option | `option` | "Use JWT with refresh tokens" |
-| About to write/edit code | `action` | "Implementing JWT auth middleware" |
-| Work completed or failed | `outcome` | "JWT auth working" or "JWT approach failed" |
-| Important observation | `observation` | "Existing code uses cookie-based sessions" |
-
-## Commands
-
-```bash
-# Create nodes (always include confidence -c)
-deciduous add goal "Title" -c 90 -p "User's exact request"
-deciduous add decision "Title" -c 75
-deciduous add action "Title" -c 85
-deciduous add outcome "Title" -c 90
-deciduous add observation "Title" -c 80
-
-# CRITICAL: Link nodes immediately after creation
-deciduous link <parent_id> <child_id> -r "Reason for connection"
-
-# After git commits, link to the graph
-deciduous add action "Committed feature X" -c 90 --commit HEAD
-
-# View the graph
-deciduous nodes
-deciduous edges
-```
-
-## Rules
-
-1. **Log BEFORE acting** - Create the action node before writing code
-2. **Link IMMEDIATELY** - Every node except root goals must have a parent
-3. **Capture verbatim prompts** - Use `-p` with the user's exact words for goals
-4. **Include confidence** - Always use `-c` flag (0-100)
-5. **Log outcomes** - Both successes AND failures get logged
-
-## Confidence Guidelines
-
-- 90-100: Certain, verified, tested
-- 75-89: High confidence, likely correct
-- 50-74: Moderate confidence, some uncertainty
-- Below 50: Experimental, speculative
-
-## The Memory Loop
-
-```
-User Request → Log goal with -p
-    ↓
-Choose Approach → Log decision + options
-    ↓
-Start Coding → Log action FIRST
-    ↓
-Complete Work → Log outcome, link to parent
-    ↓
-Git Commit → Log with --commit HEAD
-```
-
-**Remember**: The decision graph is your persistent memory. Log as you work, not after.

dist/404.html

···
-<!DOCTYPE html>
-<html>
-  <head>
-    <meta http-equiv="refresh" content="0; url=/" />
-  </head>
-  <body></body>
-</html>

dist/index.html

···
-<!doctype html>
-<html lang="en">
-    <head>
-        <meta charset="UTF-8" />
-        <link rel="manifest" href="/site.webmanifest" />
-        <link
-            rel="apple-touch-icon"
-            sizes="180x180"
-            href="/apple-touch-icon.png"
-        />
-        <link
-            rel="icon"
-            type="image/x-icon"
-            sizes="32x32"
-            href="/favicon.ico"
-        />
-        <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
-
-        <meta
-            name="viewport"
-            content="width=device-width, initial-scale=1.0, viewport-fit=cover"
-        />
-        <meta name="apple-mobile-web-app-capable" content="yes" />
-        <meta
-            name="apple-mobile-web-app-status-bar-style"
-            content="black-translucent"
-        />
-        <title>ATLast: Find Your People in the ATmosphere</title>
-      <script type="module" crossorigin src="/assets/index-Dmqml0tf.js"></script>
-      <link rel="stylesheet" crossorigin href="/assets/index-DHzBkxZQ.css">
-    </head>
-    <body>
-        <div id="root"></div>
-    </body>
-</html>