@oneie/claude 0.5.0 → 0.7.0

package/commands/go.md

@@ -0,0 +1,75 @@
+# /go — the standing "yes"
+
+One word for everything the operator types over and over: **fill the gaps · do it · yessssss · continue · merge and deploy · fan out.**
+
+`/go` means: you already have consent. Stop narrating options, stop asking, move.
+
+---
+
+## Modes
+
+| Invocation | Meaning |
+|---|---|
+| `/go` | Resolve state and advance NOW (one push, this turn) |
+| `/go on [max] [mission…]` | Arm auto-continue — the Stop hook re-prompts you until done |
+| `/go off` | Disarm auto-continue |
+| `/go status` | Report flag state + continuation count |
+| `/go <slug>` | `/go` scoped to one todo slug (= consent for its whole arc) |
+
+---
+
+## `/go` (no args) — the advance algorithm
+
+Work the first matching rung, then close with numbers:
+
+1. **In-flight work exists** (uncommitted changes, failing test you just saw, half-done todo cycle) → finish it. A failed command is a step, not a stop: diagnose, fix, retry.
+2. **Work is done and green** (tsc + tests + kill-switch pass) → close the loop without being asked:
+   - `git branch --show-current` FIRST (shared-tree law), commit by explicit path
+   - merge to main, `/deploy`, verify live (real request, not "file exists")
+3. **Idle** → read `todo.md`, take the top unblocked slug, run `/do <slug>`.
+4. **Multiple independent, file-disjoint items** → fan out: spawn parallel agents in ONE message (or `do-fleet.sh --slots N --go` for whole waves).
+
+"Fill the gaps" = before building, presence-check the promise's `deliverables:`/`world:` manifests and the plan's artifacts — missing → write, stale → rewrite, true → skip. That is the /do lifecycle; `/go` just skips the part where you wait for permission.
+
+### What /go does NOT consent to
+
+Still ask, even under /go:
+
+- destructive/irreversible actions (data deletion, prod schema drops, force-push)
+- spending money beyond already-established rails
+- genuine scope changes (new promise, killing a feature)
+- publishing to external surfaces not already in the task's arc
+
+Everything else — edits, tests, commits on the right branch, merge, deploy, fan-out — is pre-approved.
+
+## `/go on [max] [mission…]`
+
+Write the flag file the Stop hook (`hooks/auto-continue.sh`) reads:
+
+```bash
+printf 'max=%s\n%s' "${max:-12}" "${mission:+mission=$mission}" > .claude/auto-continue.local
+```
+
+Then behave as `/go` (advance now — the hook keeps you advancing on every stop until done or budget spent). Budget is per-session; counter lives in `/tmp/oneie-auto-continue-<session>.count`.
+
+## `/go off`
+
+```bash
+rm -f .claude/auto-continue.local
+```
+
+## `/go status`
+
+Report: flag present? max? mission? current count from the /tmp counter. One line.
+
+---
+
+## Numeric close
+
+Every `/go` invocation ends with a countable line:
+
+```
+/go closed: rung=<1|2|3|4> actions=<n> merged=<0|1> deployed=<0|1> next=<slug|none>
+```
+
+`/go on|off|status` close with: `auto-continue=<on|off> max=<n> count=<n>`.

package/commands/improve.md

@@ -29,7 +29,7 @@ Proposals come in three kinds (set by `stop-reflect.sh`):
 | Proposal kind | Detection | Target |
 |---|---|---|
 | `**convention**` | `\.claude/(rules\|skills\|agents)/...` or `CLAUDE\.md` in path | the named file — promote the rule into its body |
-| `**new primitive**` | `\.claude/(skills\|rules\|agents\|hooks)/[^/]+\.(md\|sh)` | the index in `one-ie/.claude/CLAUDE.md` — add a one-line entry |
+| `**new primitive**` | `\.claude/(skills\|rules\|agents\|hooks)/[^/]+\.(md\|sh)` | `.claude/CLAUDE.md` § Structure, or the root `README.md` skills table — add a one-line entry (the two targets `stop-reflect.sh` names) |
 | `**doc-drift**` | `<subdir>/CLAUDE.md` named | that CLAUDE.md — surface a 3-line summary of the most impactful code changes and ask the user which (if any) belong in the contract |
 
 If detection fails, the user is asked: "which file should this update?" Free-text answer accepted.
@@ -48,7 +48,9 @@ If detection fails, the user is asked: "which file should this update?" Free-tex
 ```
 - **new primitive** `.claude/skills/perf.md` — add a one-line entry to the index.
 ```
-→ `apply` opens `one-ie/.claude/CLAUDE.md`, finds the skills index, appends `| /perf | ...` row.
+→ `apply` opens `.claude/CLAUDE.md`, finds the `skills/` line in the § Structure block, and
+adds the name to it (that block is a tree listing, not a table — the `| /perf | … |` row form
+belongs in the root `README.md` skills table).
 
 **Doc-drift proposal:**
 ```

package/commands/kill.md

@@ -1,45 +1,73 @@
 # /kill — Reset dev environment
 
-Stop all Astro dev servers (ports 4321–4329) and wrangler (8787), clear node + astro + vite + wrangler caches, run `bun install`, then `bun run dev`.
+Stop all Astro dev servers (ports 4321–4329) and all CF/wrangler ports (8787–8799), clear node + astro + vite caches, run `bun install`, then `bun run dev`.
 
 Use when HMR is broken, Vite re-optimization desyncs deps (duplicate React `useContext` is null, `createRoot` not exported with two `?v=hash` URLs), ghost ports refuse to release, or the user says "kill", "nuke", "reset dev", or "full clean rebuild".
 
 Scope is `one.ie/web/` only.
 
+## ⛔ NEVER DELETE — local database lives here
+
+**`.wrangler/` must NEVER be deleted.** It contains the local database:
+
+| Path | Contains |
+|------|----------|
+| `.wrangler/state/v3/d1/` | Local D1 SQLite databases |
+| `.wrangler/state/v3/kv/` | Local KV store |
+| `.wrangler/state/v3/r2/` | Local R2 buckets |
+| `.wrangler/state/v3/do/` | Durable Object storage |
+| `.wrangler/state/v3/workflows/` | Workflow state |
+
+Deleting `.wrangler/` wipes all local data. There is no undo. Do not include it in any `rm` command, ever — not even in a "full nuke".
+
 ## What it does (in order)
 
-1. **Kill** any process bound to ports 4321–4329 (Astro) and 8787 (wrangler), plus lingering `astro dev` / `wrangler dev` / `vite` / `workerd` processes
-2. **Clear** caches only — `.astro`, `node_modules/.vite`, `node_modules/.astro`, `dist` (preserves `node_modules` + `bun.lock` so install is fast; preserves `.wrangler/state` to keep local KV/D1/R2/DO data)
+1. **Kill** any process bound to ports 4321–4329 (Astro) and 8787–8799 (wrangler/CF Workers), plus lingering `astro dev` / `wrangler dev` / `vite` / `workerd` / `miniflare` processes
+2. **Clear** caches only — `.astro`, `node_modules/.vite`, `node_modules/.astro`, `dist` — nothing else
 3. **Reinstall** via `bun install`
-4. **Start** `bun run dev`
+4. **Start all three servers** in background:
+   - `bun run dev` — Astro on 4321
+   - `bun run dev:gateway` — local gateway on 8788 (use the plain script, not `dev:gateway:bg`: the `:bg` variant self-forks and returns immediately, so a `run_in_background: true` Bash call would report "done" while the gateway is still booting)
+   - `bun run dev:wrangler` — CF Worker on 8787 (requires build; slow ~30s)
 
 ## One-shot command
 
-Run this exactly:
+Run the kill + reinstall first, then start all three servers. Each server starts in background (`run_in_background: true`).
+
+⚠️ The port sweep below also hits other projects' dev servers parked in 4321–4329 (e.g. `apps/one/site` on 4322). If a neighbour project is running, drop its port from the list — and never re-add blanket `pkill -f "astro dev"`-style patterns; they kill every Astro/vite on the machine across all sessions.
 
+**Step 1 — kill + reinstall:**
 ```bash
 cd /Users/toc/Server/one-ie/one.ie/web && \
-  (lsof -ti:4321,4322,4323,4324,4325,4326,4327,4328,4329,8787 2>/dev/null | xargs kill -9 2>/dev/null; \
-   pkill -f "astro dev" 2>/dev/null; \
-   pkill -f "wrangler dev" 2>/dev/null; \
-   pkill -f "vite" 2>/dev/null; \
-   pkill -f "workerd" 2>/dev/null; true) && \
+  (lsof -ti:4321,4322,4323,4324,4325,4326,4327,4328,4329,8787,8788,8789,8790,8791,8792,8793,8794,8795,8796,8797,8798,8799 2>/dev/null | xargs kill -9 2>/dev/null; \
+   pkill -f "one\.ie/web.*(astro|vite|workerd|miniflare|wrangler)" 2>/dev/null; true) && \
   rm -rf .astro node_modules/.vite node_modules/.astro dist && \
-  bun install && \
-  bun run dev
+  bun install
+```
+
+**Step 2 — start all servers (each as a separate background Bash call):**
+```bash
+# Astro
+cd /Users/toc/Server/one-ie/one.ie/web && bun run dev
+
+# Gateway
+cd /Users/toc/Server/one-ie/one.ie/web && bun run dev:gateway
+
+# CF Worker (requires build — starts slower)
+cd /Users/toc/Server/one-ie/one.ie/web && bun run dev:wrangler
 ```
 
-Start the final `bun run dev` in the background (`run_in_background: true`) so you can monitor logs and confirm the server is up on 4321.
+Confirm Astro is up on 4321, gateway is up, and wrangler is up on 8787 by checking logs.
 
 ## When NOT to use
 
 - Cache-only fix would do → `rm -rf node_modules/.vite .astro && bun run dev` (~3s); this is ~30s
-- Production / deploy issues → use `/deploy` or `/build`
-- TypeScript errors only → use `/typecheck`; cache reset won't fix code
+- Production / deploy issues → use `/deploy` (there is no `/build` command — the build step lives inside `/deploy`, or run `cd one.ie/web && bun run build`)
+- TypeScript errors only → `cd one.ie/web && bun run typecheck` (there is no `/typecheck` command); cache reset won't fix code
 - Dependency version drift suspected → manually `rm -rf node_modules bun.lock && bun install` (this command preserves both)
 
 ## Diagnostic order (cheapest first)
 
 1. `rm -rf node_modules/.vite .astro && bun run dev` — clears Vite + Astro cache only (~3s)
 2. **This command** — kills servers + clears caches + reinstall (~30s)
-3. Full nuke: `rm -rf node_modules bun.lock .astro dist && bun install && bun run dev` (~90s) — only if dependency tree itself is suspect
+3. Full nuke: `rm -rf node_modules bun.lock .astro dist && bun install && bun run dev` (~90s) — only if dependency tree itself is suspect. **Never include `.wrangler/`.**

package/commands/notify.md

@@ -0,0 +1,37 @@
+# /notify — send yourself a Telegram message via onedotbot
+
+Send a message to your personal Telegram from Claude Code.
+
+**Prefer `/chat` or `cc-connect send` for peer messaging** — those route through
+`space:post` and mirror into the workspace inbox. `notify.sh` marks itself
+DEPRECATED for plain text; keep it for **file sends** and for direct Telegram
+delivery when `space:post` is unavailable.
+
+## Usage
+
+```
+/notify <message>
+```
+
+## How to invoke
+
+```bash
+.claude/scripts/notify.sh "<message>"
+.claude/scripts/notify.sh --to <me|tony|donal|chat_id> "<message>"
+.claude/scripts/notify.sh --file <path> ["caption"]
+```
+
+## Examples
+
+```bash
+.claude/scripts/notify.sh "deploy done — channels worker is live"
+.claude/scripts/notify.sh --to donal "tests passing, ready to review"
+.claude/scripts/notify.sh --file /tmp/report.pdf "this cycle's numbers"
+```
+
+Posts **directly to `api.telegram.org`** (`sendMessage` / `sendDocument`) — it does
+**not** go through the channels worker and reads no `CHANNELS_URL`. The bot token
+comes from `TELEGRAM_TOKEN` in the environment, falling back to the
+`TELEGRAM_TOKEN=` line in `channels/.dev.vars`; the script exits 1 if neither
+resolves. Default recipient is chat_id `631201930` (me/tony); `donal` is
+`714125982`. Prints `sent ✓` on success.

package/commands/oo-push.md

@@ -0,0 +1,52 @@
+# /oo-push
+
+Push changes in the standalone `oo` clone to `github.com/one-ie/oo`.
+
+**Path (verified 2026-08-02): `/Users/toc/Server/one-ie.pre-mono/oo`.**
+`apps/oo/` does **not** exist — that path was wrong and any command using it
+fails with "no such file or directory". The clone is the canonical repo: its own
+git history, `origin` = `https://github.com/one-ie/oo.git`. The monorepo subtree
+was removed 2026-06-20.
+
+Resolve the path before pushing rather than trusting this line — the clone has
+moved once already:
+
+```bash
+git -C /Users/toc/Server/one-ie.pre-mono/oo remote -v   # must show one-ie/oo.git
+```
+
+## Usage
+
+```
+/oo-push              # push the oo clone to github.com/one-ie/oo main
+/oo-push <branch>     # push to a specific branch
+```
+
+## Steps
+
+1. **Resolve branch** — use `$ARGUMENTS` if provided, else `main`
+
+2. **Check for uncommitted changes**
+   ```bash
+   git -C /Users/toc/Server/one-ie.pre-mono/oo status --short
+   ```
+   If anything is uncommitted, surface a warning and ask whether to stage + commit
+   first. As of 2026-08-02 this tree has uncommitted edits (`README.md`,
+   `TUTORIAL.md`, `features.md`) and untracked files under `docs/` — a bare push
+   ships none of them, so expect this warning and do not treat it as noise.
+
+3. **Push**
+   ```bash
+   git -C /Users/toc/Server/one-ie.pre-mono/oo push origin <branch>
+   ```
+
+4. **Report**
+   ```
+   Pushed one-ie.pre-mono/oo → github.com/one-ie/oo (<branch>)
+   ```
+
+## Notes
+
+- The monorepo `one-ie/` still carries a stale `oo` remote pointing at the same
+  URL — do **not** use `git subtree push --prefix=oo oo main`; the `oo/` prefix
+  was deleted from this repo and the subtree rotted.

package/commands/rag.md

@@ -0,0 +1,150 @@
+# /rag
+
+Search, synthesize, verify, and ingest notes from the OO-Brain corpus (Obsidian vault → Supabase pgvector, hybrid RRF retrieval).
+
+**MCP tools:** `mcp__oo-brain__search_notes` · `mcp__oo-brain__mark_retrieval` · `mcp__oo-brain__ingest_note`
+
+**Closed-loop rule (non-negotiable):** every `search_notes` call MUST be followed by `mark_retrieval(query_id, mark|warn|unsure)` before the turn ends. Skipping pollutes the corpus feedback loop.
+
+---
+
+## Modes
+
+| Invocation | What | Skill |
+|---|---|---|
+| `/rag <query>` | Quick inline search — top 5 chunks, inline display | direct |
+| `/rag synthesize <topic>` | Wide-slice brief: cited, themed, 2–3 pages | rag-synthesize |
+| `/rag fanout <question>` | Multi-angle: 5–10 sub-queries → synthesized answer | rag-fanout |
+| `/rag triangulate <claim>` | Verify one claim from 3+ angles | rag-triangulate |
+| `/rag adversarial <belief>` | Stress-test: find contradicting evidence | rag-adversarial |
+| `/rag canary <thing>` | Check if something has been flagged/warned | rag-canary |
+| `/rag discover [--vault X]` | Coverage audit: what topics are thin? | rag-skill-discovery |
+| `/rag ingest <title> -- <content>` | Add a note to the corpus | direct |
+
+**Flags (all modes):**
+- `--vault oo-brain|agency-operator|personal-brain|all` — override auto-routing (default: auto)
+- `--k <N>` — chunk count (default 5 for quick, 15 for synthesize, 3 per sub-query for fanout)
+- `--dry-run` — show the query + vault + k, don't fire
+
+---
+
+## Vault auto-routing
+
+| Topic signals | Vault |
+|---|---|
+| Frameworks, courses, YouTube intel, books, research | `oo-brain` |
+| SOPs, clients, ops, agency processes, rules | `agency-operator` |
+| Personal notes, journal, daily notes | `personal-brain` |
+| Unclear / cross-cutting | `all` |
+
+---
+
+## Steps per mode
+
+**"Delegate to `<name>` skill" below means: Read `.claude/skills/<name>.md` and
+follow it.** Those six files are flat `.md`, not `<name>/SKILL.md` directories,
+so the runtime does not register them — the Skill tool cannot invoke them by
+name even though each carries valid `name`/`description` frontmatter. Read the
+file directly; it is the live contract either way.
+
+### `/rag <query>` — Quick Search
+
+1. Auto-route vault from query topic.
+2. Call `search_notes(query=<query>, k=5, vault=<vault>)`. Capture `query_id`.
+3. Display results inline:
+   ```
+   RAG: "<query>" · vault=<vault> · <N> chunks
+
+   1. [<score>] <file_path>
+      "<excerpt>"
+
+   2. [<score>] <file_path>
+      "<excerpt>"
+   …
+   ```
+4. Synthesize a 3–5 sentence answer from the chunks, with inline `[source: <file>]` citations.
+5. Call `mark_retrieval(query_id, mark|warn|unsure)` — `mark` if chunks informed the answer.
+6. Print: `↩ loop closed · query_id=<uuid>`
+
+If 0 chunks: say "corpus has no coverage of '<query>'" — do not pad.
+
+---
+
+### `/rag synthesize <topic>` — Written Brief
+
+Delegate to `rag-synthesize` skill. Pass `<topic>` + any `--vault`, `--k`, `--out`, `--audience` flags from `$ARGUMENTS`.
+
+---
+
+### `/rag fanout <question>` — Multi-Angle
+
+Delegate to `rag-fanout` skill. Pass `<question>` + flags.
+
+---
+
+### `/rag triangulate <claim>` — Verify a Claim
+
+Delegate to `rag-triangulate` skill. Pass `<claim>` + flags.
+
+---
+
+### `/rag adversarial <belief>` — Stress-Test
+
+Delegate to `rag-adversarial` skill. Pass `<belief>` + flags.
+
+---
+
+### `/rag canary <thing>` — Canary Check
+
+Delegate to `rag-canary` skill. Pass `<thing>` + flags.
+
+---
+
+### `/rag discover [--vault X]` — Coverage Audit
+
+Delegate to `rag-skill-discovery` skill. Pass `--vault` if provided.
+
+---
+
+### `/rag ingest <title> -- <content>` — Add to Corpus
+
+1. Parse: everything before ` -- ` is `<title>`, everything after is `<content>`.
+2. Auto-detect vault: operational content → `agency-operator`; everything else → `oo-brain`.
+3. Call `ingest_note(title=<title>, content=<content>, vault=<vault>, source="tony-cc")`.
+4. Report: `INGESTED: "<title>" → <vault> · immediately retrievable via /rag`
+
+If `--dry-run`: print `DRY: would ingest "<title>" → <vault>` and stop.
+
+---
+
+## Output contract
+
+Every mode prints a summary line on completion:
+
+```
+RAG ✓ · mode=<mode> · vault=<vault> · chunks=<N> · loop=closed
+```
+
+If retrieval returned 0 chunks, print:
+```
+RAG ∅ · corpus has no coverage of "<query>" · try --vault all or /rag fanout
+```
+
+---
+
+## Example invocations
+
+```
+/rag what do we know about email deliverability
+/rag synthesize AI SEO strategies --vault oo-brain
+/rag fanout "how should we price our AI agency retainer?"
+/rag triangulate "long-form content ranks better than short-form"
+/rag adversarial "we should focus on LinkedIn over email"
+/rag ingest "Client Onboarding Checklist" -- Step 1: send welcome email. Step 2: schedule kickoff…
+/rag discover --vault agency-operator
+/rag what are our best performing landing page frameworks --dry-run
+```
+
+---
+
+*Every `/rag` call closes its loop. No orphaned retrievals.*