chore(claude): delete deprecated Claude command docs and related hooks

2026-11-02 19:32:43 +00:00 · 2026-10-07 12:45:18 -04:00
1 parent e3e474da6c
commit d63da34aef
@@ -1,118 +0,0 @@
 ---
 description: Recursively implement all pending beads issues until every one is closed with tests passing, builds succeeding, requirements met, and blockers cleared
 argument-hint: [optional: priority filter e.g. "p0-p2" | epic id | "dry-run"]
 allowed-tools: Bash(bd:*), Bash(git:*), Bash(go:*), Bash(pnpm:*), Bash(cargo:*), Bash(make:*), Read, Write, Edit, Glob, Grep, Task
 ---
 # /bd-drain — Recursive Beads Completion Workflow
 Drain the beads backlog to zero. Work every ready issue to full completion, unblock dependent issues as they clear, and repeat until no open, actionable work remains. Arguments: `$ARGUMENTS` (optional priority filter like `p0-p2`, an epic ID to scope to, or `dry-run` to plan without executing).
 ## Phase 0 — Session Bootstrap
 1. Run `bd dolt pull` to sync beads state from remote.
 2. Run `bd prime` if context was compacted or this is a fresh session.
 3. Run `bd doctor` — if sync problems or missing hooks are reported, fix them before proceeding.
 4. Run `bd stats` and record the baseline: open / in_progress / blocked counts. This is the burn-down target.
 5. Run `bd memories drain` and `bd memories <project keyword>` to load any prior insights about this workflow or codebase gotchas.
 6. Detect the project's verification commands by inspecting the repo (Makefile, Taskfile, turbo.json, package.json scripts, go.mod, Cargo.toml). Record:
   - **TEST_CMD** (e.g. `go test ./...`, `pnpm turbo test`, `cargo test`)
   - **BUILD_CMD** (e.g. `go build ./...`, `pnpm turbo build`)
   - **LINT_CMD** if present (e.g. `golangci-lint run`, `pnpm lint`)
 7. Run TEST_CMD and BUILD_CMD once **before touching anything** to establish a green baseline. If the baseline is already red, create a P0 bug with `bd create` describing the pre-existing failure and fix it first — never build on a broken base.
 If `$ARGUMENTS` contains `dry-run`: execute Phase 1's triage, print the planned execution order as a dependency-sorted list, and STOP.
 ## Phase 1 — Triage & Ordering
 1. Run `bd ready` for actionable issues (respect `$ARGUMENTS` priority/epic filter if given).
 2. Run `bd blocked` and `bd show <id>` on each blocked issue to map the dependency graph.
 3. Run `bd orphans` — repair or flag any broken dependencies (`bd dep add` / `bd human <id>`).
 4. Build a topologically-sorted work queue: priority order (P0 → P4) within dependency order. Issues whose completion unblocks the most downstream work get tie-breaker preference.
 5. Run `bd lint` on the queue. For issues with missing/vague requirements, attempt to infer acceptance criteria from the description and codebase, update via `bd update <id> --acceptance="..."`. If requirements are genuinely undecidable, run `bd human <id>` with a specific question and skip it (do not guess on ambiguous product decisions).
 ## Phase 2 — The Drain Loop
 Repeat until the exit condition in Phase 3 is met. For **each** issue in the queue:
 ### 2a. Claim
 ```bash
 bd show <id>            # re-read full details, dependencies, acceptance criteria
 bd update <id> --claim  # mark in_progress
 ```
 ### 2b. Implement
 - Read the acceptance criteria, design notes, and any linked issues before writing code.
 - Locate the relevant code with Glob/Grep; understand existing patterns before adding new ones.
 - Implement the minimal complete change that satisfies the requirements. Follow existing repo conventions.
 - If the issue is a `feature` without tests specified, write tests anyway — untested features do not count as done.
 - If during implementation you discover necessary sub-work, create it immediately: `bd create --title="..." --description="..." --type=task --priority=<match parent>` then `bd dep add <new-id> <current-id>` as appropriate. Never leave discovered work untracked.
 ### 2c. Verify (hard gates — ALL must pass)
 ```bash
 <TEST_CMD>    # full test suite, not just new tests
 <BUILD_CMD>   # full build
 <LINT_CMD>    # if present
 ```
 - ✅ All tests pass (including pre-existing ones — no regressions)
 - ✅ Build succeeds cleanly
 - ✅ Every acceptance criterion on the issue is demonstrably met
 - ✅ No new warnings/lint errors introduced
 On failure: fix and re-verify. After **3 failed fix attempts** on the same root cause, stop thrashing — record findings with `bd update <id> --notes="<what was tried, error output, hypothesis>"`, run `bd human <id>` if it needs a decision, revert the working tree to the last green state, and move to the next issue.
 ### 2d. Close & Checkpoint
 ```bash
 bd close <id> --reason="<one-line summary of what was done>" --suggest-next
 bd remember "<any non-obvious insight learned: gotcha, pattern, decision>"
 git add <changed files>
 git commit -m "<type>(<scope>): <summary> (closes <id>)"
 ```
 - Commit per issue, not in batches — each commit should be independently green.
 - `--suggest-next` output feeds Phase 2e.
 ### 2e. Re-plan
 - Newly unblocked issues from `--suggest-next` are inserted into the queue in priority order.
 - Every **5 closed issues**, re-run `bd ready` and `bd blocked` to catch drift (issues added by hooks, remote changes), and re-run the full test suite even if the last issue didn't touch shared code.
 ### Parallelism
 When the queue contains **independent** issues (no shared files, no dependency relation), dispatch up to 3 in parallel via the Task tool (subagents), each following 2a–2d in isolation. Serialize anything touching shared modules, migrations, or config. Merge subagent commits sequentially and re-run TEST_CMD after each merge.
 ## Phase 3 — Exit Conditions & Escalation
 The loop terminates when **one** of these holds:
 1. **Success**: `bd ready` is empty AND `bd blocked` is empty (within the `$ARGUMENTS` scope) AND the final full TEST_CMD + BUILD_CMD run is green.
 2. **Human-gated**: remaining issues are all flagged via `bd human` — report them with the specific decision needed for each.
 3. **Externally blocked**: remaining blockers depend on things outside this repo (third-party, credentials, other teams) — document each with `bd update <id> --notes` and report.
 Never terminate by silently skipping issues. Every open issue at exit must be either human-flagged or externally blocked with notes explaining why.
 ## Phase 4 — Session Close Protocol (MANDATORY)
 ```bash
 [ ] git status              # confirm nothing unstaged/untracked left behind
 [ ] git add <files>         # stage any stragglers
 [ ] bd dolt pull            # pull beads updates from main
 [ ] git commit -m "..."     # final commit if anything staged
 [ ] bd stats                # final counts
 ```
 Then produce the **Drain Report**:
 - **Burn-down**: baseline vs final counts (open / in_progress / blocked / closed this session)
 - **Closed**: each issue ID + one-line summary + commit SHA
 - **Escalated**: each `bd human` flag with the exact decision needed
 - **Externally blocked**: each with the external dependency named
 - **Discovered work**: new issues created during the drain
 - **Insights recorded**: `bd remember` entries added
 - **Final verification**: test suite result, build result, lint result
 ## Hard Rules
 - Use beads for ALL tracking. Never TodoWrite, TaskCreate, or markdown task files.
 - Never `bd edit` (blocks on $EDITOR).
 - Never close an issue whose acceptance criteria aren't verifiably met — a passing build is necessary, not sufficient.
 - Never commit with a red test suite.
 - Priority values are numeric (0–4 / P0–P4), never "high"/"medium"/"low".
 - Persistence you don't need beats lost context: over-record notes, insights, and reasons.
@@ -1,140 +0,0 @@
 ---
 description: Extract insight-type learnings from claude-mem and record them into beads memories
 ---
 # Sync claude-mem insights → beads memories
 <!--toc:start-->
 - [Sync claude-mem insights → beads memories](#sync-claude-mem-insights-beads-memories)
  - [Scope (read carefully)](#scope-read-carefully)
  - [Phase 0 — Preflight](#phase-0-preflight)
  - [Phase 1 — Enumerate ALL learnings (the loop)](#phase-1-enumerate-all-learnings-the-loop)
  - [Phase 2 — Triage & record (per-item loop)](#phase-2-triage-record-per-item-loop)
  - [Phase 3 — Finalize](#phase-3-finalize)
  - [Guardrails](#guardrails)
 <!--toc:end-->
 You are migrating **durable insights** from **claude-mem** (the session memory store)
 into **beads** (`bd remember`) for this repository. Work autonomously through a loop
 until every relevant observation has been triaged. Do not invent learnings — only
 persist what claude-mem actually returns.
 ## Scope (read carefully)
 - **Record ONLY insights / decisions / gotchas** → `bd remember`.
 - **Ignore actionable learnings** (bugs to fix, tech debt, follow-ups, TODOs).
  Do **not** create them as beads issues. A separate command will later pull those
  from claude-mem and feed them into **Linear** for PM; beads then syncs from Linear.
 - This command therefore **never calls `bd create`** and never writes beads issues.
  The only write to beads is `bd remember`. Leave actionable items untouched in
  claude-mem so the future Linear command can pick them up.
 ---
 ## Phase 0 — Preflight
 1. Confirm beads is live in this repo: `bd ready` (and `bd doctor` if it errors).
 2. Snapshot existing memories for dedup: `bd memories ""` (plus a few broad keyword
   `bd memories <term>` lookups) and keep the gist in mind.
 3. Set up a **local progress file** for resumability (so compaction/re-runs skip done
   work) — NOT a beads issue:
   ```
   ./.claude-mem-sync/processed.json    # { "processed": [<cmem ids>], "skipped_actionable": <count> }
   ```
   Create it if missing; load it if present. Add `.claude-mem-sync/` to `.gitignore`
   if it isn't already.
 ---
 ## Phase 1 — Enumerate ALL learnings (the loop)
 claude-mem search is query-based, so a single call won't surface everything. Build a
 **complete, de-duplicated set of observation IDs** by sweeping across angles, then
 walking chronologically. Track seen IDs in a set; never process the same ID twice.
 Use `/claude-mem:mem-search` for every query below, following claude-mem's 3-layer
 pattern — pull the compact **index** first, only fetch full details for IDs you keep.
 **1a. Type sweep** — one broad query per observation type, high limit:
 ```
 /claude-mem:mem-search  (type=insight)
 /claude-mem:mem-search  (type=decision)
 /claude-mem:mem-search  (type=bugfix)        # scan for the *lesson learned*, not the fix-task
 /claude-mem:mem-search  (type=architecture)
 /claude-mem:mem-search  (type=feature)       # plus any other types this project uses
 ```
 > You still scan every type — a bugfix or feature observation often contains a durable
 > *insight* ("X breaks when Y") even though its actionable part is ignored here.
 **1b. Topic sweep** — queries for the repo's recurring themes (infer from the codebase:
 auth, deploy, config, performance, gotchas, "why we", "decided", "learned", "don't").
 Each adds new IDs to the set.
 **1c. Chronological walk** — to catch what the sweeps missed, seed `timeline` from your
 earliest and latest known observations and step through history, collecting any IDs not
 already in the set. Stop when the timeline yields no new IDs in either direction.
 Result: a deduplicated list of candidate observation IDs. Print the count.
 ---
 ## Phase 2 — Triage & record (per-item loop)
 Process candidate IDs in batches. For each batch:
 1. **Fetch details** once: `get_observations(ids=[...])` (batch IDs — never one-at-a-time).
 2. For **each** observation, classify:
   - **Actionable** (a thing to *do*: unfixed bug, tech debt, follow-up, TODO) →
     **IGNORE**. Increment `skipped_actionable` in the progress file and move on.
     It stays in claude-mem for the Linear command.
   - **Insight / decision / gotcha** (durable knowledge about *how things are*) →
     record it:
     - **Dedup check** first: `bd memories <key terms>`. If beads already captures it, skip.
     - Then:
       ```
       bd remember "<one-line durable insight, self-contained, no session context> [cmem #<id>]"
       ```
       Keep it atomic and reusable. Include the source `cmem #<id>` so it traces back
       to http://localhost:37777/api/observation/<id>.
   - **Noise** (one-off output, ephemeral state, trivially obvious, duplicate) → skip silently.
 3. Append processed IDs to `./.claude-mem-sync/processed.json`.
 Repeat until the candidate set is exhausted.
 ---
 ## Phase 3 — Finalize
 1. Sanity pass: `bd memories ""` — confirm new insights landed and read cleanly.
 2. Sync beads memories to remote: `bd dolt push`.
 3. **Session close protocol** — if any code/files changed (e.g. `.gitignore`):
   ```
   git status
   git add <files>
   git commit -m "chore: record claude-mem insights into beads"
   git push
   ```
 ---
 ## Guardrails
 - **Insights only.** Never `bd create`, never write a beads issue. Actionable items are
  ignored and left in claude-mem for the Linear sync command.
 - **Idempotent.** Re-running must not duplicate — always dedup against `bd memories` and
  the local progress file before writing.
 - **Atomic memories.** One insight per `bd remember`, self-contained, no "in this session"
  phrasing.
 - **Cite the source.** Every entry carries its `cmem #<id>` for traceability.
 - **No `bd edit`** — it opens an editor and blocks.
 - **Don't fabricate** — if a sweep returns nothing, say so and move on.
 - For large sets, run the type/topic sweeps and `bd memories` dedup lookups with
  **parallel subagents** for speed.
 When done, report: total observations scanned, how many insights were recorded, how many
 were skipped as **actionable** (this is the backlog the Linear command will handle), and
 how many were skipped as noise/duplicates.
@@ -1,179 +0,0 @@
 ---
 description: Extract actionable learnings from claude-mem into beads tasks and push them up to Linear for PM
 ---
 # Sync claude-mem actionable learnings → beads → Linear
 <!--toc:start-->
 - [Sync claude-mem actionable learnings → beads → Linear](#sync-claude-mem-actionable-learnings-beads-linear)
  - [Scope (read carefully)](#scope-read-carefully)
  - [Sync model (no linear-cli needed)](#sync-model-no-linear-cli-needed)
  - [Phase 0 — Preflight](#phase-0-preflight)
  - [Phase 1 — Enumerate ALL learnings (the loop)](#phase-1-enumerate-all-learnings-the-loop)
  - [Phase 2 — Triage & create (per-item loop)](#phase-2-triage-create-per-item-loop)
  - [Phase 3 — Push to Linear](#phase-3-push-to-linear)
  - [Phase 4 — Finalize](#phase-4-finalize)
  - [Guardrails](#guardrails)
 <!--toc:end-->
 You are turning **actionable learnings** from **claude-mem** (the session memory store)
 into **beads** (`bd`) tasks, then pushing the new ones up to **Linear** for PM. Work
 autonomously through a loop until every relevant observation has been triaged. Do not
 invent learnings — only persist what claude-mem actually returns.
 ## Scope (read carefully)
 - **Record ONLY actionable learnings** — things to *do*: unfixed bugs, tech debt,
  follow-ups, TODOs, missing tests, planned refactors. Each becomes a `bd create` task.
 - **Ignore insights / decisions / gotchas** (durable knowledge about *how things are*).
  A separate command records those as `bd remember` memories — do **not** touch them here.
  Leave them in claude-mem untouched.
 - A single observation may legitimately contain both an insight *and* an action item; the
  two commands are independent, so it's fine if this one creates a task while the other
  records a memory from the same `cmem #<id>`.
 ## Sync model (no linear-cli needed)
 Beads-first, push up, bidirectional thereafter:
 1. Create tasks in beads (`bd create`).
 2. Push the new ones to Linear with `bd linear push <ids>` — this creates the Linear
   issues and writes `external_ref` back onto each bead (`--update-refs` is default true).
 3. From then on, `bd linear sync` is bidirectional: PM edits in Linear pull back into beads.
 `linear-cli` is **not** used. All Linear interaction goes through native `bd linear`.
 ---
 ## Phase 0 — Preflight
 1. Confirm beads is live: `bd ready` (and `bd doctor` if it errors).
 2. Confirm Linear is wired up: `bd linear status`. If it errors / unconfigured, stop and
   tell the user to set `linear.api_key` + team (`bd linear teams` to find the team UUID).
   Note whether **multiple teams** are configured (`linear.team_ids`) — if so, push needs
   an explicit `--team <ID>`; ask the user which team these tasks belong to.
 3. Dedup snapshot: `bd list --status=open` and a few `bd search <term>` lookups so you can
   recognize existing tasks (including ones already pulled from Linear).
 4. Local progress file for resumability — NOT a beads issue:
   ```
   ./.claude-mem-sync/processed-actions.json   # { "processed": [<cmem ids>], "created": [<bead ids>], "skipped_insights": <n> }
   ```
   Create if missing, load if present. Ensure `.claude-mem-sync/` is in `.gitignore`.
 ---
 ## Phase 1 — Enumerate ALL learnings (the loop)
 claude-mem search is query-based, so one call won't surface everything. Build a
 **complete, de-duplicated set of observation IDs** by sweeping across angles, then walking
 chronologically. Track seen IDs in a set; never process the same ID twice.
 Use `/claude-mem:mem-search` for every query below, following claude-mem's 3-layer pattern
 — pull the compact **index** first, only fetch full details for IDs you keep.
 **1a. Type sweep** — one broad query per observation type, high limit:
 ```
 /claude-mem:mem-search  (type=bugfix)
 /claude-mem:mem-search  (type=feature)
 /claude-mem:mem-search  (type=insight)        # scan for the *action item* buried inside, not the insight
 /claude-mem:mem-search  (type=decision)
 /claude-mem:mem-search  (type=architecture)   # plus any other types this project uses
 ```
 > Scan every type — even an `insight` observation often ends with "…so we should do X",
 > which is the action item you extract here while ignoring the insight itself.
 **1b. Topic sweep** — queries for action-shaped language the codebase tends to record:
 "TODO", "should", "need to", "fix", "broken", "flaky", "refactor", "tech debt", "later",
 "workaround", "temporary", "follow up". Each adds new IDs to the set.
 **1c. Chronological walk** — seed `timeline` from your earliest and latest known
 observations and step through history, collecting any IDs not already in the set. Stop when
 the timeline yields no new IDs in either direction.
 Result: a deduplicated list of candidate observation IDs. Print the count.
 ---
 ## Phase 2 — Triage & create (per-item loop)
 Process candidate IDs in batches. For each batch:
 1. **Fetch details** once: `get_observations(ids=[...])` (batch IDs — never one-at-a-time).
 2. For **each** observation, classify:
   - **Insight / decision / gotcha** (knowledge, nothing to *do*) → **IGNORE**. Increment
     `skipped_insights` and move on. It's the other command's job.
   - **Noise** (one-off output, ephemeral state, trivially obvious, duplicate) → skip silently.
   - **Actionable** → create a task:
     - **Dedup first:** `bd search "<key terms>"` and `bd search "cmem #<id>"`. If a matching
       task already exists (locally or pulled from Linear), skip — this keeps re-runs idempotent.
     - Then:
       ```
       bd create --title="<imperative summary>" \
         --description="<what + why, ending with: Source: cmem #<id>>" \
         --type=bug|task|feature \
         --priority=<0-4>
       ```
       - Priority is `0-4` / `P0-P4` (0=critical … 4=backlog) — never high/medium/low.
         bd maps this to Linear priority on push.
       - Optionally add `--acceptance="<done criteria>"` when the observation implies one.
       - If two items depend on each other: `bd dep add <issue> <depends-on>`.
     - Record the new bead id and the `cmem #<id>` in the progress file.
 Repeat until the candidate set is exhausted.
 ---
 ## Phase 3 — Push to Linear
 1. Review what's queued: `bd linear status` (shows issues pending push, i.e. no external_ref).
 2. Push **only the tasks you just created**, by id, so you don't drag along unrelated pending work:
   ```
   bd linear push <new-bead-id-1> <new-bead-id-2> ...
   ```
   - Add `--team <ID>` if multiple teams are configured (from Phase 0).
   - Run `--dry-run` first if the user wants a preview.
   - This creates the Linear issues and sets `external_ref` on each bead (default `--update-refs`).
   - Alternative for bulk: `bd linear sync --push --create-only` (+ `--team`), but prefer the
     explicit id list for precision.
 3. Confirm linkage: re-run `bd linear status` and spot-check a couple of beads now carry an
   `external_ref` to Linear.
 > Steady state: after this seeding push, a scheduled or manual `bd linear sync` keeps both
 > sides aligned — PM's changes in Linear pull back down to beads. You don't push again for
 > these; you only push *newly created* tasks on future runs.
 ---
 ## Phase 4 — Finalize
 1. Sync beads to its Dolt remote: `bd dolt push`.
 2. **Session close protocol** — if any code/files changed (e.g. `.gitignore`):
   ```
   git status
   git add <files>
   git commit -m "chore: extract claude-mem action items into beads + Linear"
   git push
   ```
 ---
 ## Guardrails
 - **Actionable only.** Never `bd remember` here. Insights are ignored and left in claude-mem
  for the insights command.
 - **No linear-cli.** All Linear interaction is native `bd linear`.
 - **Idempotent.** Re-running must not duplicate — dedup against `bd search` (including
  `bd search "cmem #<id>"`) and the progress file before creating, and push only new ids.
 - **Cite the source.** Every task description ends with `Source: cmem #<id>`
  (traceable at http://localhost:37777/api/observation/<id>).
 - **No `bd edit`** — it opens an editor and blocks. Use inline `--` flags on create/update.
 - **Multiple teams → explicit `--team`** on push; ask the user if ambiguous.
 - **Don't fabricate** — if a sweep returns nothing, say so and move on.
 - For large sets, run the type/topic sweeps and `bd search` dedup lookups with **parallel
  subagents** for speed (but run `bd create` / `bd linear push` serially to keep ids ordered).
 When done, report: total observations scanned, how many tasks were created (with bead ids),
 how many pushed to Linear (with external_refs), how many skipped as **insights** (the other
 command's backlog), and how many skipped as noise/duplicates.
@@ -1,102 +0,0 @@
 ---
 description: Plan a task by decomposing it into beads issues with dependencies, acceptance criteria, and priorities
 argument-hint: <task description or goal>
 allowed-tools: Bash(bd:*), Bash(git log:*), Bash(git status:*), Bash(rg:*), Task
 ---
 # /create-task — Plan work into beads
 <!--toc:start-->
 - [/create-task — Plan work into beads](#create-task-plan-work-into-beads)
  - [Current workspace state](#current-workspace-state)
  - [Task to plan](#task-to-plan)
  - [Instructions](#instructions)
    - [1. Understand before creating](#1-understand-before-creating)
    - [2. Decompose](#2-decompose)
    - [3. Create issues](#3-create-issues)
    - [4. Wire dependencies](#4-wire-dependencies)
    - [5. Report the plan](#5-report-the-plan)
 <!--toc:end-->
 ## Current workspace state
 - Ready work: !`bd ready 2>/dev/null | head -30`
 - In progress: !`bd list --status=in_progress 2>/dev/null | head -15`
 - Recently closed (dedup check): !`bd list --status=closed 2>/dev/null | head -10`
 - Stats: !`bd stats 2>/dev/null`
 - Relevant memories: !`bd memories "$ARGUMENTS" 2>/dev/null | head -40`
 ## Task to plan
 $ARGUMENTS
 ## Instructions
 You are planning this task using **beads as the sole tracker**. Do NOT use TodoWrite, TaskCreate, or markdown checklists. Do NOT write any code in this command — output is a set of beads issues forming an executable plan.
 ### 1. Understand before creating
 - Search for prior art first: `bd search "<keywords>"` — the task (or part of it) may already exist. Per repo convention, `contracts-*`/`backend-*`/`core-*` beads mirror Linear CORE-* and share ID suffixes across sibling repos; if something looks missing, check sibling repo beads and `git log` before assuming it needs a new issue.
 - Check the injected memories above for constraints, gotchas, and prior decisions that shape the plan (e.g., root-file serialization, generated-file rules, runtime conventions).
 - If the request is ambiguous on scope, ask ONE clarifying question, then proceed.
 ### 2. Decompose
 Break the task into issues sized for a single focused session (roughly ≤ half a day each). For each issue decide:
 - **type**: `feature` (new capability), `task` (chore/refactor/infra), `bug` (defect)
 - **priority**: numeric only — `0` critical / `1` high / `2` medium / `3` low / `4` backlog. Never "high"/"medium"/"low".
 - **description**: WHY the issue exists + WHAT done looks like. Never a bare title restatement.
 - **acceptance criteria**: concrete, verifiable (tests pass, command output, deployed address updated, etc.)
 - **design** (when a decision was made): record it so future sessions don't re-litigate.
 If the plan touches shared root files (`turbo.json`, `pnpm-workspace.yaml`, `pnpm-lock.yaml`, root Biome/tsconfig), note it in the issue and **serialize those issues with dependencies** — they cannot run in parallel.
 ### 3. Create issues
 Use the full quality flags:
 ```bash
 bd create \
  --title="<imperative summary>" \
  --description="<why + what>" \
  --type=<task|bug|feature> \
  --priority=<0-4> \
  --acceptance="<verifiable criteria>" \
  --design="<decisions, if any>" \
  --notes="<gotchas from memories, file paths, related beads/Linear IDs>" \
  --validate
 ```
 - **3+ issues → spawn parallel subagents**, one `bd create` batch each, then collect the returned IDs.
 - Quote every string flag (descriptions contain `&`, `$`, backticks).
 - NEVER use `bd edit` (opens $EDITOR and blocks). Amend with `bd update <id> --description/--notes/--design`.
 ### 4. Wire dependencies
 ```bash
 bd dep add <dependent> <blocker>   # dependent depends on blocker
 ```
 - Model the real execution order: tests depend on implementation, redeploys depend on ABI changes, root-file edits form a chain.
 - Verify with `bd blocked` and `bd show <id>` that the graph matches intent — no cycles, no orphans (`bd orphans`).
 ### 5. Report the plan
 Output a concise summary:
 1. **Created issues** — table of `id | title | type | priority`
 2. **Dependency graph** — short text sketch of the ordering (e.g. `x8y → oto → 53x`)
 3. **Entry point** — which issue(s) show in `bd ready` right now, i.e., where work starts
 4. **Deferred/skipped** — anything that already existed (with the existing ID) or was intentionally left out
 Then persist and finish:
 ```bash
 bd ready          # confirm entry points are unblocked
 git status        # beads auto-commits to Dolt; push if session ends here
 ```
 If planning surfaced a durable insight (a constraint, a decision, a gotcha), store it: `bd remember "<insight>"` — never a MEMORY.md file.
 Do NOT start implementing any issue. Planning ends when the graph is created, validated, and reported. Implementation begins in a later session via `bd ready` → `bd update <id> --claim`.
@@ -1,104 +0,0 @@
 ---
 description: Run accessibility and visual design review
 ---
 # Rams Design Review
 You are Rams, an expert design engineer reviewing code for accessibility and visual design issues.
 ## Mode
 If `$ARGUMENTS` is provided, analyze that specific file.
 If `$ARGUMENTS` is empty, ask the user which file(s) to review, or offer to scan the project for component files.
 ---
 ## 1. Accessibility Review (WCAG 2.1)
 ### Critical (Must Fix)
 | Check | WCAG | What to look for |
 |-------|------|------------------|
 | Images without alt | 1.1.1 | `<img>` without `alt` attribute |
 | Icon-only buttons | 4.1.2 | `<button>` with only SVG/icon, no `aria-label` |
 | Form inputs without labels | 1.3.1 | `<input>`, `<select>`, `<textarea>` without associated `<label>` or `aria-label` |
 | Non-semantic click handlers | 2.1.1 | `<div onClick>` or `<span onClick>` without `role`, `tabIndex`, `onKeyDown` |
 | Missing link destination | 2.1.1 | `<a>` without `href` using only `onClick` |
 ### Serious (Should Fix)
 | Check | WCAG | What to look for |
 |-------|------|------------------|
 | Focus outline removed | 2.4.7 | `outline-none` or `outline: none` without visible focus replacement |
 | Missing keyboard handlers | 2.1.1 | Interactive elements with `onClick` but no `onKeyDown`/`onKeyUp` |
 | Color-only information | 1.4.1 | Status/error indicated only by color (no icon/text) |
 | Touch target too small | 2.5.5 | Clickable elements smaller than 44x44px |
 ### Moderate (Consider Fixing)
 | Check | WCAG | What to look for |
 |-------|------|------------------|
 | Heading hierarchy | 1.3.1 | Skipped heading levels (h1 → h3) |
 | Positive tabIndex | 2.4.3 | `tabIndex` > 0 (disrupts natural tab order) |
 | Role without required attributes | 4.1.2 | `role="button"` without `tabIndex="0"` |
 ---
 ## 2. Visual Design Review
 ### Layout & Spacing
 - Inconsistent spacing values
 - Overflow issues, alignment problems
 - Z-index conflicts
 ### Typography
 - Mixed font families, weights, or sizes
 - Line height issues
 - Missing font fallbacks
 ### Color & Contrast
 - Contrast ratio below 4.5:1
 - Missing hover/focus states
 - Dark mode inconsistencies
 ### Components
 - Missing button states (disabled, loading, hover, active, focus)
 - Missing form field states (error, success, disabled)
 - Inconsistent borders, shadows, or icon sizing
 ---
 ## Output Format
 ```
 ═══════════════════════════════════════════════════
 RAMS DESIGN REVIEW: [filename]
 ═══════════════════════════════════════════════════
 CRITICAL (X issues)
 ───────────────────
 [A11Y] Line 24: Button missing accessible name
  <button><CloseIcon /></button>
  Fix: Add aria-label="Close"
  WCAG: 4.1.2
 SERIOUS (X issues)
 ──────────────────
 ...
 ═══════════════════════════════════════════════════
 SUMMARY: X critical, X serious, X moderate
 Score: XX/100
 ═══════════════════════════════════════════════════
 ```
 ---
 ## Guidelines
 1. Read the file(s) first before making assessments
 2. Be specific with line numbers and code snippets
 3. Provide fixes, not just problems
 4. Prioritize critical accessibility issues first
 If asked, offer to fix the issues directly.
@@ -1,180 +0,0 @@
 ---
 description: Review UI code for Vercel Web Interface Guidelines compliance
 argument-hint: <file-or-pattern>
 ---
 # Web Interface Guidelines
 Review these files for compliance: $ARGUMENTS
 Read files, check against rules below. Output concise but comprehensive—sacrifice grammar for brevity. High signal-to-noise.
 ## Rules
 ### Accessibility
 - Icon-only buttons need `aria-label`
 - Form controls need `<label>` or `aria-label`
 - Interactive elements need keyboard handlers (`onKeyDown`/`onKeyUp`)
 - `<button>` for actions, `<a>`/`<Link>` for navigation (not `<div onClick>`)
 - Images need `alt` (or `alt=""` if decorative)
 - Decorative icons need `aria-hidden="true"`
 - Async updates (toasts, validation) need `aria-live="polite"`
 - Use semantic HTML (`<button>`, `<a>`, `<label>`, `<table>`) before ARIA
 - Headings hierarchical `<h1>`–`<h6>`; include skip link for main content
 - `scroll-margin-top` on heading anchors
 ### Focus States
 - Interactive elements need visible focus: `focus-visible:ring-*` or equivalent
 - Never `outline-none` / `outline: none` without focus replacement
 - Use `:focus-visible` over `:focus` (avoid focus ring on click)
 - Group focus with `:focus-within` for compound controls
 ### Forms
 - Inputs need `autocomplete` and meaningful `name`
 - Use correct `type` (`email`, `tel`, `url`, `number`) and `inputmode`
 - Never block paste (`onPaste` + `preventDefault`)
 - Labels clickable (`htmlFor` or wrapping control)
 - Disable spellcheck on emails, codes, usernames (`spellCheck={false}`)
 - Checkboxes/radios: label + control share single hit target (no dead zones)
 - Submit button stays enabled until request starts; spinner during request
 - Errors inline next to fields; focus first error on submit
 - Placeholders end with `…` and show example pattern
 - `autocomplete="off"` on non-auth fields to avoid password manager triggers
 - Warn before navigation with unsaved changes (`beforeunload` or router guard)
 ### Animation
 - Honor `prefers-reduced-motion` (provide reduced variant or disable)
 - Animate `transform`/`opacity` only (compositor-friendly)
 - Never `transition: all`—list properties explicitly
 - Set correct `transform-origin`
 - SVG: transforms on `<g>` wrapper with `transform-box: fill-box; transform-origin: center`
 - Animations interruptible—respond to user input mid-animation
 ### Typography
 - `…` not `...`
 - Curly quotes `"` `"` not straight `"`
 - Non-breaking spaces: `10&nbsp;MB`, `⌘&nbsp;K`, brand names
 - Loading states end with `…`: `"Loading…"`, `"Saving…"`
 - `font-variant-numeric: tabular-nums` for number columns/comparisons
 - Use `text-wrap: balance` or `text-pretty` on headings (prevents widows)
 ### Content Handling
 - Text containers handle long content: `truncate`, `line-clamp-*`, or `break-words`
 - Flex children need `min-w-0` to allow text truncation
 - Handle empty states—don't render broken UI for empty strings/arrays
 - User-generated content: anticipate short, average, and very long inputs
 ### Images
 - `<img>` needs explicit `width` and `height` (prevents CLS)
 - Below-fold images: `loading="lazy"`
 - Above-fold critical images: `priority` or `fetchpriority="high"`
 ### Performance
 - Large lists (>50 items): virtualize (`virtua`, `content-visibility: auto`)
 - No layout reads in render (`getBoundingClientRect`, `offsetHeight`, `offsetWidth`, `scrollTop`)
 - Batch DOM reads/writes; avoid interleaving
 - Prefer uncontrolled inputs; controlled inputs must be cheap per keystroke
 - Add `<link rel="preconnect">` for CDN/asset domains
 - Critical fonts: `<link rel="preload" as="font">` with `font-display: swap`
 ### Navigation & State
 - URL reflects state—filters, tabs, pagination, expanded panels in query params
 - Links use `<a>`/`<Link>` (Cmd/Ctrl+click, middle-click support)
 - Deep-link all stateful UI (if uses `useState`, consider URL sync via nuqs or similar)
 - Destructive actions need confirmation modal or undo window—never immediate
 ### Touch & Interaction
 - `touch-action: manipulation` (prevents double-tap zoom delay)
 - `-webkit-tap-highlight-color` set intentionally
 - `overscroll-behavior: contain` in modals/drawers/sheets
 - During drag: disable text selection, `inert` on dragged elements
 - `autoFocus` sparingly—desktop only, single primary input; avoid on mobile
 ### Safe Areas & Layout
 - Full-bleed layouts need `env(safe-area-inset-*)` for notches
 - Avoid unwanted scrollbars: `overflow-x-hidden` on containers, fix content overflow
 - Flex/grid over JS measurement for layout
 ### Dark Mode & Theming
 - `color-scheme: dark` on `<html>` for dark themes (fixes scrollbar, inputs)
 - `<meta name="theme-color">` matches page background
 - Native `<select>`: explicit `background-color` and `color` (Windows dark mode)
 ### Locale & i18n
 - Dates/times: use `Intl.DateTimeFormat` not hardcoded formats
 - Numbers/currency: use `Intl.NumberFormat` not hardcoded formats
 - Detect language via `Accept-Language` / `navigator.languages`, not IP
 - Brand names, code tokens, identifiers: wrap with `translate="no"` to prevent garbled auto-translation
 ### Hydration Safety
 - Inputs with `value` need `onChange` (or use `defaultValue` for uncontrolled)
 - Date/time rendering: guard against hydration mismatch (server vs client)
 - `suppressHydrationWarning` only where truly needed
 ### Hover & Interactive States
 - Buttons/links need `hover:` state (visual feedback)
 - Interactive states increase contrast: hover/active/focus more prominent than rest
 ### Content & Copy
 - Active voice: "Install the CLI" not "The CLI will be installed"
 - Title Case for headings/buttons (Chicago style)
 - Numerals for counts: "8 deployments" not "eight"
 - Specific button labels: "Save API Key" not "Continue"
 - Error messages include fix/next step, not just problem
 - Second person; avoid first person
 - `&` over "and" where space-constrained
 ### Anti-patterns (flag these)
 - `user-scalable=no` or `maximum-scale=1` disabling zoom
 - `onPaste` with `preventDefault`
 - `transition: all`
 - `outline-none` without focus-visible replacement
 - Inline `onClick` navigation without `<a>`
 - `<div>` or `<span>` with click handlers (should be `<button>`)
 - Images without dimensions
 - Large arrays `.map()` without virtualization
 - Form inputs without labels
 - Icon buttons without `aria-label`
 - Hardcoded date/number formats (use `Intl.*`)
 - `autoFocus` without clear justification
 ## Output Format
 Group by file. Use `file:line` format (VS Code clickable). Terse findings.
 ```text
 ## src/Button.tsx
 src/Button.tsx:42 - icon button missing aria-label
 src/Button.tsx:18 - input lacks label
 src/Button.tsx:55 - animation missing prefers-reduced-motion
 src/Button.tsx:67 - transition: all → list properties
 ## src/Modal.tsx
 src/Modal.tsx:12 - missing overscroll-behavior: contain
 src/Modal.tsx:34 - "..." → "…"
 ## src/Card.tsx
 ✓ pass
 ```
 State issue + location. Skip explanation unless fix non-obvious. No preamble.
@@ -1,203 +0,0 @@
 #!/usr/bin/env python3
 # Reads a Claude Code SessionEnd hook JSON on stdin and exports that session's
 # claude-mem learnings to a single Obsidian note. Stdlib only. Fails soft:
 # any error exits 0 without blocking the session.
 #
 # Data interface (discovered live, not guessed):
 #   - SQLite DB: ~/.claude-mem/claude-mem.db (read-only)
 #   - sdk_sessions.content_session_id == Claude Code session_id
 #   - sdk_sessions.memory_session_id  -> observations / session_summaries
 #   - observation types seen: discovery, change, feature, decision, bugfix, refactor
 #   - no private/excluded column exists: claude-mem drops <private> content at
 #     capture time so it never reaches the DB. We still scan defensively.
 #   - viewer deep link that resolves: http://localhost:<port>/?observation=<id>
 import sys, os, re, json, sqlite3, datetime
 from pathlib import Path
 HOME       = Path.home()
 DB_PATH    = Path(os.environ.get("CLAUDE_MEM_DB", HOME / ".claude-mem" / "claude-mem.db"))
 VAULT_DIR  = Path(os.environ.get("CMEM_OBSIDIAN_DIR", HOME / "Documents" / "Vault" / "90 - Archive" / "Learnings"))
 WORKER_PORT = os.environ.get("CLAUDE_MEM_WORKER_PORT", "37700")
 LOG_PATH   = HOME / ".claude" / "hooks" / "cmem-to-obsidian.log"
 # observation type -> note section
 SECTIONS = [
    ("Decisions",        {"decision"}),
    ("Fixes & gotchas",  {"bugfix"}),
    ("Insights",         {"discovery", "feature", "change", "refactor"}),
 ]
 def log(msg):
    try:
        with open(LOG_PATH, "a") as f:
            f.write(f"{datetime.datetime.now().isoformat()} {msg}\n")
    except Exception:
        pass
 def slug(s):
    return re.sub(r"[^a-z0-9]+", "-", (s or "").lower()).strip("-") or "unknown"
 def is_private(obs):
    blob = " ".join(str(obs.get(k) or "") for k in ("title", "subtitle", "narrative", "text", "facts"))
    return "<private>" in blob.lower()
 def connect_ro(path):
    # read-only so we never lock or mutate the live DB / WAL
    return sqlite3.connect(f"file:{path}?mode=ro", uri=True, timeout=5)
 def fetch(session_id):
    con = connect_ro(DB_PATH)
    con.row_factory = sqlite3.Row
    cur = con.cursor()
    row = cur.execute(
        "SELECT memory_session_id, project, started_at FROM sdk_sessions "
        "WHERE content_session_id = ? LIMIT 1", (session_id,)
    ).fetchone()
    if not row or not row["memory_session_id"]:
        con.close()
        return None
    mem_id, project, started_at = row["memory_session_id"], row["project"], row["started_at"]
    obs = [dict(r) for r in cur.execute(
        "SELECT id, type, title, subtitle, narrative FROM observations "
        "WHERE memory_session_id = ? ORDER BY created_at_epoch ASC", (mem_id,)
    ).fetchall()]
    summ = cur.execute(
        "SELECT learned, completed, investigated, request FROM session_summaries "
        "WHERE memory_session_id = ? ORDER BY created_at_epoch DESC LIMIT 1", (mem_id,)
    ).fetchone()
    con.close()
    return {
        "mem_id": mem_id,
        "project": project or "unknown",
        "started_at": started_at,
        "observations": [o for o in obs if not is_private(o)],
        "summary": dict(summ) if summ else {},
    }
 def obs_link(oid):
    return f"http://localhost:{WORKER_PORT}/?observation={oid}"
 def one_line(obs):
    title = (obs.get("title") or "").strip()
    sub = (obs.get("subtitle") or "").strip()
    text = f"{title} — {sub}" if title and sub else (title or sub or "(untitled observation)")
    return f"- {text} [cmem #{obs['id']}]({obs_link(obs['id'])})"
 def render_note(data, session_id):
    project = data["project"]
    pslug = slug(project)
    # date from the session's own start time -> stable across re-runs (idempotent)
    date = (data["started_at"] or datetime.datetime.now().isoformat())[:10]
    short = session_id[:8]
    summary = data["summary"]
    abstract = (summary.get("learned") or summary.get("completed")
                or summary.get("investigated") or summary.get("request") or "").strip()
    abstract = re.sub(r"\s+", " ", abstract) or "No session summary recorded."
    fm = [
        "---",
        f"date: {date}",
        f"project: {project}",
        f"session: {short}",
        "source: claude-mem",
        "tags:",
        "  - claude-mem",
        f"  - project/{pslug}",
        "---",
        "",
        f"# {project} — Session Learnings ({date})",
        "",
        "> [!abstract] Session summary",
        f"> {abstract}",
        "",
        f"Project: [[{project}]]",
        "",
    ]
    body = []
    by_id = {o["id"]: o for o in data["observations"]}
    placed = set()
    for heading, types in SECTIONS:
        items = [o for o in data["observations"] if o["type"] in types]
        if not items:
            continue
        body.append(f"## {heading}")
        for o in items:
            placed.add(o["id"])
            if heading == "Decisions":
                t = (o.get("title") or "").strip()
                s = (o.get("subtitle") or "").strip()
                body.append(f"- > [!note] {t}" + (f" — {s}" if s else "")
                            + f" [cmem #{o['id']}]({obs_link(o['id'])})")
            else:
                body.append(one_line(o))
        body.append("")
    # any type we didn't map -> Insights catch-all
    leftover = [o for o in data["observations"] if o["id"] not in placed]
    if leftover:
        body.append("## Insights")
        body.extend(one_line(o) for o in leftover)
        body.append("")
    return "\n".join(fm + body).rstrip() + "\n", project, pslug, date, short
 def ensure_project_moc(project):
    # so [[Project]] wikilink resolves
    moc = VAULT_DIR / f"{project}.md"
    try:
        if not moc.exists():
            moc.write_text(
                f"---\ntags:\n  - moc\n  - project/{slug(project)}\n---\n\n# {project}\n\n"
                "Map of content for claude-mem session learnings.\n"
            )
    except Exception as e:
        log(f"moc write failed: {e}")
 def write_note(data, session_id):
    text, project, pslug, date, short = render_note(data, session_id)
    folder = VAULT_DIR / project
    folder.mkdir(parents=True, exist_ok=True)
    ensure_project_moc(project)
    # deterministic filename keyed to session -> idempotent upsert
    path = folder / f"{date} {project} {short}.md"
    path.write_text(text)
    log(f"wrote {path} ({len(data['observations'])} observations)")
    return path
 def main():
    try:
        payload = json.load(sys.stdin)
    except Exception:
        return
    session_id = payload.get("session_id")
    if not session_id:
        return
    try:
        if not DB_PATH.exists():
            return
        data = fetch(session_id)
        if not data or not data["observations"]:
            return
        write_note(data, session_id)
    except Exception as e:
        log(f"export failed for session {session_id}: {e}")
        return
 if __name__ == "__main__":
    main()
@@ -1,101 +0,0 @@
 #!/bin/sh
 # installed by herdr
 # managed by herdr; reinstalling or updating the integration overwrites this file.
 # add custom hooks beside this file instead of editing it.
 # HERDR_INTEGRATION_ID=claude
 # HERDR_INTEGRATION_VERSION=7
 set -eu
 action="${1:-}"
 hook_input_file="$(mktemp "${TMPDIR:-/tmp}/herdr-claude-hook.XXXXXX")" || exit 0
 trap 'rm -f "$hook_input_file"' EXIT HUP INT TERM
 cat >"$hook_input_file" 2>/dev/null || true
 case "$action" in
  session) ;;
  *) exit 0 ;;
 esac
 [ "${HERDR_ENV:-}" = "1" ] || exit 0
 [ -n "${HERDR_SOCKET_PATH:-}" ] || exit 0
 [ -n "${HERDR_PANE_ID:-}" ] || exit 0
 command -v python3 >/dev/null 2>&1 || exit 0
 HERDR_ACTION="$action" HERDR_HOOK_INPUT_FILE="$hook_input_file" python3 - <<'PY'
 import json
 import os
 import random
 import socket
 import time
 source = "herdr:claude"
 action = os.environ.get("HERDR_ACTION", "")
 pane_id = os.environ.get("HERDR_PANE_ID")
 socket_path = os.environ.get("HERDR_SOCKET_PATH")
 hook_input_file = os.environ.get("HERDR_HOOK_INPUT_FILE")
 if not pane_id or not socket_path:
    raise SystemExit(0)
 hook_input = {}
 if hook_input_file:
    try:
        with open(hook_input_file, encoding="utf-8") as handle:
            content = handle.read()
        if content.strip():
            hook_input = json.loads(content)
    except Exception:
        hook_input = {}
 hook_event_name = str(hook_input.get("hook_event_name") or "")
 is_subagent = bool(hook_input.get("agent_id"))
 if is_subagent:
    raise SystemExit(0)
 if hook_event_name == "SubagentStop":
    # SubagentStop is a completion event. Older Herdr integrations mapped it
    # to durable working, but Claude recap/away-summary can emit it after the
    # main turn has already stopped. Never let it revive an idle pane.
    raise SystemExit(0)
 request_id = f"{source}:{int(time.time() * 1000)}:{random.randrange(1_000_000):06d}"
 report_seq = time.time_ns()
 session_id = hook_input.get("session_id")
 agent_session_id = session_id if isinstance(session_id, str) and session_id else None
 transcript_path = hook_input.get("transcript_path")
 agent_session_path = transcript_path if isinstance(transcript_path, str) and transcript_path else None
 session_start_source = hook_input.get("source") if hook_event_name == "SessionStart" else None
 if not isinstance(session_start_source, str) or not session_start_source:
    session_start_source = None
 if agent_session_id:
    params = {
        "pane_id": pane_id,
        "source": source,
        "agent": "claude",
        "seq": report_seq,
        "agent_session_id": agent_session_id,
    }
    if agent_session_path:
        params["agent_session_path"] = agent_session_path
    if session_start_source:
        params["session_start_source"] = session_start_source
    request = {
        "id": request_id,
        "method": "pane.report_agent_session",
        "params": params,
    }
 else:
    raise SystemExit(0)
 try:
    client = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
    client.settimeout(0.5)
    client.connect(socket_path)
    client.sendall((json.dumps(request) + "\n").encode())
    try:
        client.recv(4096)
    except Exception:
        pass
    client.close()
 except Exception:
    pass
 PY
@@ -1,155 +0,0 @@
 #!/usr/bin/env node
 /**
 * GitNexus Claude Code Hook
 *
 * PreToolUse handler — intercepts Grep/Glob/Bash searches
 * and augments with graph context from the GitNexus index.
 *
 * NOTE: SessionStart hooks are broken on Windows (Claude Code bug).
 * Session context is injected via CLAUDE.md / skills instead.
 */
 const fs = require('fs');
 const path = require('path');
 const { execFileSync } = require('child_process');
 /**
 * Read JSON input from stdin synchronously.
 */
 function readInput() {
  try {
    const data = fs.readFileSync(0, 'utf-8');
    return JSON.parse(data);
  } catch {
    return {};
  }
 }
 /**
 * Check if a directory (or ancestor) has a .gitnexus index.
 */
 function findGitNexusIndex(startDir) {
  let dir = startDir || process.cwd();
  for (let i = 0; i < 5; i++) {
    if (fs.existsSync(path.join(dir, '.gitnexus'))) {
      return true;
    }
    const parent = path.dirname(dir);
    if (parent === dir) break;
    dir = parent;
  }
  return false;
 }
 /**
 * Extract search pattern from tool input.
 */
 function extractPattern(toolName, toolInput) {
  if (toolName === 'Grep') {
    return toolInput.pattern || null;
  }
  if (toolName === 'Glob') {
    const raw = toolInput.pattern || '';
    const match = raw.match(/[*\/]([a-zA-Z][a-zA-Z0-9_-]{2,})/);
    return match ? match[1] : null;
  }
  if (toolName === 'Bash') {
    const cmd = toolInput.command || '';
    if (!/\brg\b|\bgrep\b/.test(cmd)) return null;
    const tokens = cmd.split(/\s+/);
    let foundCmd = false;
    let skipNext = false;
    const flagsWithValues = new Set(['-e', '-f', '-m', '-A', '-B', '-C', '-g', '--glob', '-t', '--type', '--include', '--exclude']);
    for (const token of tokens) {
      if (skipNext) { skipNext = false; continue; }
      if (!foundCmd) {
        if (/\brg$|\bgrep$/.test(token)) foundCmd = true;
        continue;
      }
      if (token.startsWith('-')) {
        if (flagsWithValues.has(token)) skipNext = true;
        continue;
      }
      const cleaned = token.replace(/['"]/g, '');
      return cleaned.length >= 3 ? cleaned : null;
    }
    return null;
  }
  return null;
 }
 function main() {
  try {
    const input = readInput();
    const hookEvent = input.hook_event_name || '';
    if (hookEvent !== 'PreToolUse') return;
    const cwd = input.cwd || process.cwd();
    if (!findGitNexusIndex(cwd)) return;
    const toolName = input.tool_name || '';
    const toolInput = input.tool_input || {};
    if (toolName !== 'Grep' && toolName !== 'Glob' && toolName !== 'Bash') return;
    const pattern = extractPattern(toolName, toolInput);
    if (!pattern || pattern.length < 3) return;
    // Resolve CLI path — try multiple strategies:
    // 1. Relative path (works when script is inside npm package)
    // 2. require.resolve (works when gitnexus is globally installed)
    // 3. Fall back to npx (works when neither is available)
    let cliPath = '/home/prad/.bun/install/global/node_modules/gitnexus/dist/cli/index.js';
    if (!fs.existsSync(cliPath)) {
      try {
        cliPath = require.resolve('gitnexus/dist/cli/index.js');
      } catch {
        cliPath = ''; // will use npx fallback
      }
    }
    // augment CLI writes result to stderr (KuzuDB's native module captures
    // stdout fd at OS level, making it unusable in subprocess contexts).
    const { spawnSync } = require('child_process');
    let result = '';
    try {
      let child;
      if (cliPath) {
        child = spawnSync(
          process.execPath,
          [cliPath, 'augment', pattern],
          { encoding: 'utf-8', timeout: 8000, cwd, stdio: ['pipe', 'pipe', 'pipe'] }
        );
      } else {
        // npx fallback
        const cmd = process.platform === 'win32' ? 'npx.cmd' : 'npx';
        child = spawnSync(
          cmd,
          ['-y', 'gitnexus', 'augment', pattern],
          { encoding: 'utf-8', timeout: 15000, cwd, stdio: ['pipe', 'pipe', 'pipe'] }
        );
      }
      result = child.stderr || '';
    } catch { /* graceful failure */ }
    if (result && result.trim()) {
      console.log(JSON.stringify({
        hookSpecificOutput: {
          hookEventName: 'PreToolUse',
          additionalContext: result.trim()
        }
      }));
    }
  } catch (err) {
    // Graceful failure — log to stderr for debugging
    console.error('GitNexus hook error:', err.message);
  }
 }
 main();
@@ -1,341 +0,0 @@
 {
  "env": {
    "CLAUDE_CODE_DISABLE_AUTO_MEMORY": "1",
    "EDITOR": "/usr/bin/micro"
  },
  "permissions": {
    "allow": [
      "mcp__codegraph__codegraph_search",
      "mcp__codegraph__codegraph_context",
      "mcp__codegraph__codegraph_callers",
      "mcp__codegraph__codegraph_callees",
      "mcp__codegraph__codegraph_impact",
      "mcp__codegraph__codegraph_node",
      "mcp__codegraph__codegraph_status"
    ],
    "defaultMode": "auto"
  },
  "model": "fable",
  "hooks": {
    "Notification": [
      {
        "matcher": ".*",
        "hooks": [
          {
            "type": "command",
            "command": "pixtuoid-hook"
          }
        ]
      }
    ],
    "PermissionRequest": [
      {
        "matcher": "*",
        "hooks": [
          {
            "type": "command",
            "command": "if [ -x '/home/prad/.orca/agent-hooks/claude-hook.sh' ]; then /bin/sh '/home/prad/.orca/agent-hooks/claude-hook.sh'; fi"
          }
        ]
      }
    ],
    "PostToolUse": [
      {
        "matcher": "*",
        "hooks": [
          {
            "type": "command",
            "command": "if [ -x '/home/prad/.orca/agent-hooks/claude-hook.sh' ]; then /bin/sh '/home/prad/.orca/agent-hooks/claude-hook.sh'; fi"
          }
        ]
      },
      {
        "matcher": ".*",
        "hooks": [
          {
            "type": "command",
            "command": "pixtuoid-hook"
          }
        ]
      },
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "atuin hook claude-code"
          }
        ]
      }
    ],
    "PostToolUseFailure": [
      {
        "matcher": "*",
        "hooks": [
          {
            "type": "command",
            "command": "if [ -x '/home/prad/.orca/agent-hooks/claude-hook.sh' ]; then /bin/sh '/home/prad/.orca/agent-hooks/claude-hook.sh'; fi"
          }
        ]
      },
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "atuin hook claude-code"
          }
        ]
      }
    ],
    "PreToolUse": [
      {
        "matcher": "*",
        "hooks": [
          {
            "type": "command",
            "command": "if [ -x '/home/prad/.orca/agent-hooks/claude-hook.sh' ]; then /bin/sh '/home/prad/.orca/agent-hooks/claude-hook.sh'; fi"
          }
        ]
      },
      {
        "matcher": ".*",
        "hooks": [
          {
            "type": "command",
            "command": "pixtuoid-hook"
          }
        ]
      },
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "atuin hook claude-code"
          }
        ]
      }
    ],
    "SessionEnd": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "python3 '/home/prad/.claude/hooks/cmem-to-obsidian.py'",
            "timeout": 15
          }
        ]
      },
      {
        "matcher": ".*",
        "hooks": [
          {
            "type": "command",
            "command": "pixtuoid-hook"
          }
        ]
      }
    ],
    "SessionStart": [
      {
        "matcher": ".*",
        "hooks": [
          {
            "type": "command",
            "command": "pixtuoid-hook"
          }
        ]
      },
      {
        "matcher": "^(startup|resume|clear|compact|fork)$",
        "hooks": [
          {
            "type": "command",
            "command": "bash '/home/prad/.claude/hooks/herdr-agent-state.sh' session",
            "timeout": 10
          }
        ]
      }
    ],
    "Stop": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "if [ -x '/home/prad/.orca/agent-hooks/claude-hook.sh' ]; then /bin/sh '/home/prad/.orca/agent-hooks/claude-hook.sh'; fi"
          }
        ]
      }
    ],
    "StopFailure": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "if [ -x '/home/prad/.orca/agent-hooks/claude-hook.sh' ]; then /bin/sh '/home/prad/.orca/agent-hooks/claude-hook.sh'; fi"
          }
        ]
      }
    ],
    "SubagentStart": [
      {
        "matcher": ".*",
        "hooks": [
          {
            "type": "command",
            "command": "pixtuoid-hook"
          }
        ]
      },
      {
        "matcher": "tldraw-offline",
        "hooks": [
          {
            "type": "command",
            "command": "sh '/home/prad/skills/tldraw-offline/inject-server-context.sh' SubagentStart"
          }
        ]
      }
    ],
    "SubagentStop": [
      {
        "matcher": ".*",
        "hooks": [
          {
            "type": "command",
            "command": "pixtuoid-hook"
          }
        ]
      }
    ],
    "UserPromptSubmit": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "if [ -x '/home/prad/.orca/agent-hooks/claude-hook.sh' ]; then /bin/sh '/home/prad/.orca/agent-hooks/claude-hook.sh'; fi"
          }
        ]
      }
    ]
  },
  "enabledPlugins": {
    "caveman@caveman": true,
    "claude-mem@thedotmack": true,
    "context-mode@context-mode": true,
    "context7@claude-plugins-official": false,
    "council@council-of-high-intelligence": true,
    "exa@claude-plugins-official": true,
    "frontend-design@claude-plugins-official": true,
    "gopls-lsp@claude-plugins-official": true,
    "gopls@claude-code-lsps": true,
    "lua-lsp@claude-plugins-official": true,
    "ponytail@ponytail": true,
    "solidity-language-server@claude-code-lsps": true,
    "understand-anything@understand-anything": true,
    "vtsls@claude-code-lsps": true,
    "yaml-lsp@zircote-lsp": true,
    "diagram-design@diagram-design": true
  },
  "extraKnownMarketplaces": {
    "caveman": {
      "source": {
        "source": "github",
        "repo": "JuliusBrussee/caveman"
      }
    },
    "claude-code-lsps": {
      "source": {
        "source": "github",
        "repo": "Piebald-AI/claude-code-lsps"
      }
    },
    "claude-plugins-official": {
      "source": {
        "source": "github",
        "repo": "anthropics/claude-plugins-official"
      }
    },
    "council-of-high-intelligence": {
      "source": {
        "source": "github",
        "repo": "0xNyk/council-of-high-intelligence"
      }
    },
    "mempalace": {
      "source": {
        "source": "github",
        "repo": "MemPalace/mempalace"
      }
    },
    "omc": {
      "source": {
        "source": "git",
        "url": "https://github.com/Yeachan-Heo/oh-my-claudecode.git"
      }
    },
    "ponytail": {
      "source": {
        "source": "github",
        "repo": "DietrichGebert/ponytail"
      }
    },
    "thedotmack": {
      "source": {
        "source": "github",
        "repo": "thedotmack/claude-mem"
      }
    },
    "understand-anything": {
      "source": {
        "source": "github",
        "repo": "Egonex-AI/Understand-Anything"
      }
    },
    "zircote-lsp": {
      "source": {
        "source": "github",
        "repo": "zircote/lsp-marketplace"
      }
    },
    "diagram-design": {
      "source": {
        "source": "github",
        "repo": "cathrynlavery/diagram-design"
      }
    }
  },
  "tui": "fullscreen",
  "skipDangerousModePermissionPrompt": true,
  "agentPushNotifEnabled": true,
  "skipAutoPermissionPrompt": true,
  "autoMode": {
    "environment": [
      "### Org-wide",
      "**Organization**: None configured",
      "**Cloud provider(s)**: None configured",
      "**Repository visibility**: Private — prdlk/leetcode (github.com)",
      "**Internal sharing / snippet hosting**: None configured — treat public paste/gist services as outside the trust boundary",
      "**Secrets management**: None configured",
      "**Default / protected branches**: Default branch `main`; no protected branches listed (rulesets not queryable here)",
      "**CI/CD deploy targets**: None configured",
      "**Network posture**: None configured",
      "**Source control**: The trusted repo (prdlk/leetcode on github.com) and its remote(s) only — no additional orgs configured",
      "**Trusted internal domains**: None configured",
      "**Trusted cloud buckets**: None configured",
      "**Key internal services**: None configured",
      "**Internal package registry**: None configured",
      "**Sensitive data locations & audiences**: any file or store holding personal data, confidential business data, credentials, regulated data, or similarly sensitive material; preserve exact handles when known and share only with audiences cleared at the [named+specifics] bar. Note: `.env*` patterns are gitignored in this repo (`.env`, `.env.local`, `.env.development.local`, `.env.test.local`, `.env.production.local`) — treat matching files as sensitive.",
      "**Data retention / declassification**: None configured",
      "**Sensitive remote targets**: any namespace, host, or container whose name carries `prod` or `production` as a whole word or name segment (hyphen/underscore/dot-delimited — e.g. matches `prod-db`, not `producer`)",
      "**Protected deployment namespaces / environments**: None configured — fall back to the Sensitive remote targets heuristic",
      "**Protected IaC scopes**: IAM, RBAC, networking, quota, and node-pool resources; anything whose name or tag carries `prod` or `production` as a whole word or name segment",
      "### User-specific",
      "**Primary use of Claude Code**: software development (personal — Leetcode solutions/notes repo)",
      "**Trusted repo**: prdlk/leetcode (github.com), private — the working directory the agent started in and its configured remote `origin`. As a private repo, confidential material may be committed here, but secrets/credentials are never cleared into it by visibility alone.",
      "**Org-specific CLIs**: None configured",
      "routine actions under `prdlk/leetcode` (this repo) treated as low-risk personal-project work"
    ]
  }
 }