ClaudeClaw Field Guide

Run /home end-to-end for me. Specifically:
1. Pull today's calendar events from Google Calendar (next 12 hours)
2. List overdue Notion tasks (status not in [Done, Canceled, Archived - Not resolved], due date past today)
3. Skim the last 24h of conversation_log for unresolved threads
4. Surface the 3 highest-priority focus lines from KAWASIST/STATUS.md
5. Note any grants with deadlines within 14 days from knowledge/ibns/ and notes/grants
6. End with one sentence on the single most important thing to start with today

Done when: Telegram message contains 6 numbered sections, no section is empty, and the final sentence picks ONE thing (not three).
Pause and confirm before any write outside outputs/.

Create a new scheduled job:
- Name: com.kawader.daily.brief
- Cron: 0 7 * * 1-5  (weekdays at 7 AM local time)
- Command: trigger the /home skill on agent "main", chat id = my Telegram DM
- Active: yes

Use the POST /api/scheduled endpoint of ClaudeClaw (see src/dashboard.ts for shape).
Verify by GET /api/scheduled and confirming the new job shows up with next_run in the future.

Done when: GET /api/scheduled returns the new job + nextRun is within 24h.

Audit my Notion tasks across all my KAWASIST databases (use the IDs in knowledge/notion-map.md). Find every task where:
- Status NOT IN [Done, Canceled, Archived - Not resolved]
- Due date is more than 7 days in the past (relative to today)

For each, output: title, database, days overdue, current status, why it might be stuck (1 sentence guess based on title + properties).

Group by database. End with a triage proposal: which ones to bulk-archive vs. which to escalate to "Scheduled" with a new date.

Write the full report to outputs/notion-triage-{TODAY}.md and post a 5-line summary to Telegram.

Done when: outputs/notion-triage-{TODAY}.md exists and Telegram has the summary. Don't actually edit Notion — propose only.

The ClaudeClaw bot is doing something I want stopped right now. From the laptop:

1. cd /Users/Kawader/ClaudeClaw/claudeclaw-os
2. Append MISSION_WORKER_ENABLED=false and SCHEDULER_ENABLED=false to .env (don't replace — these are the kill switches)
3. Wait up to 1.5 s for the worker to re-read .env
4. Verify via: curl -s -H "Authorization: Bearer $DASHBOARD_TOKEN" http://127.0.0.1:3141/api/system/status | jq '.killSwitches'
5. If anything is mid-flight, also run: curl -X POST -H "Authorization: Bearer $DASHBOARD_TOKEN" http://127.0.0.1:3141/api/system/cancel-all

Done when: killSwitches.MISSION_WORKER_ENABLED is false AND missionTasks.running is 0.
Tell me what was running before you stopped it.

I want to activate the Production agent in my ClaudeClaw multi-agent setup. The scaffold sits at /Users/Kawader/KAWASIST/outputs/claudeclaw-guide/team-templates/production/.

Do this:

1. Read team-templates/README.md to confirm the activation sequence.
2. Copy the production/ folder into /Users/Kawader/ClaudeClaw/claudeclaw-os/agents/production/.
3. Verify /Users/Kawader/ClaudeClaw/claudeclaw-os/.env has a PROD_BOT_TOKEN line. If not, STOP and ask me to add it (I'll create the bot via @BotFather and paste the token).
4. Re-read claudeclaw-os/src/agent-config.ts to confirm the schema fields in agent.yaml match (name, telegram_bot_token_env, model, obsidian, mcp_servers, warroom_tools, meet_voice_id, meet_bot_name).
5. Start the bot in a NEW pm2 process: pm2 start npm --name claudeclaw-production -- start -- --agent production
6. Wait 10 s, then check pm2 logs claudeclaw-production --lines 50 — confirm the bot connected and loaded its CLAUDE.md.
7. Send "/start" via Telegram to the new bot. Expect a reply identifying as "Production" with its scope.

Done when:
- pm2 list shows claudeclaw-production "online"
- Dashboard → System → Recent activity has an entry with agent_id = production
- Sending /rental-audit to the new bot gets refused (out of scope) — refusal proves the CLAUDE.md scoping works

Pause and confirm before any write outside outputs/ or claudeclaw-os/agents/.

Activate the Accounting agent for Ihab. Scaffold at /Users/Kawader/KAWASIST/outputs/claudeclaw-guide/team-templates/accounting/.

Steps:
1. Copy team-templates/accounting/ → claudeclaw-os/agents/accounting/.
2. Confirm ACCOUNTING_BOT_TOKEN is in .env (ask me to add via @BotFather if missing).
3. Start: pm2 start npm --name claudeclaw-accounting -- start -- --agent accounting.
4. Verify read-only enforcement: send the new bot a prompt asking it to "create an invoice in Odoo for partner 607". Expected response: refusal with reason "I'm read-only — try @Kawader_Claw_Bot for writes."
5. Test a legitimate read: "Show me the last 5 entries in account.move from this month." Expected: a table from XML-RPC reads.

Done when:
- Bot online, refuses writes, allows reads
- A row appears in Dashboard → Audit with agent_id = accounting and the read action OK
- Ihab can DM the bot at @Kawader_Books_Bot (or whatever handle)

Pause if the agent.yaml schema rejects any field — re-check agent-config.ts.

Compare /Users/Kawader/ClaudeClaw/claudeclaw-os/agents/production/agent.yaml against /Users/Kawader/ClaudeClaw/claudeclaw-os/agents/rentals/agent.yaml.

For each difference, explain in plain English what permission/behavior it changes. Specifically check:
- mcp_servers list — which integrations does each agent reach
- obsidian.folders + obsidian.read_only — what files each can read vs write
- warroom_tools — what they can do in a meeting
- model default
- meet_voice_id

End with a one-line plain-English summary: "Production can do X but not Y. Rentals can do A but not B."

Don't modify either file.

Audit my KAWASIST skill graph for orphans.

For each .md file in /Users/Kawader/KAWASIST/skills/ (excluding _learnings/, INDEX.md):
1. Check if there's a matching /command in /Users/Kawader/KAWASIST/.claude/commands/. If not, flag as "no slash command".
2. Grep skills/ for references to this skill's name (e.g. /home, home.md). If no other skill or command references it, flag as "no inbound reference".
3. Skim the body for tool calls (Bash, mcp__, etc.). If it cites NO tools, flag as "purely declarative — might be doc-only".

Output a markdown table to outputs/skills-audit-{TODAY}.md with columns:
| Skill | Slash command exists? | Inbound refs | Tool calls | Status |

End with a list of "candidates for archiving" (no slash command + no inbound refs + no tool calls).

Don't delete anything. Don't move anything. Read-only audit.

Done when: outputs/skills-audit-{TODAY}.md exists with all 34 skills assessed.

Scan /Users/Kawader/KAWASIST/tools/ and produce a manifest mapping each subfolder to its purpose, language, key entrypoints, and consumers.

For each subfolder:
1. Read its README.md if present, or the first script's header comment
2. Identify the main entrypoint (usually a *.py or *.js file)
3. Grep KAWASIST/skills/ and KAWASIST/.claude/commands/ for references to this folder name — list which skills consume it
4. Detect MCP/external API calls in the entrypoint (Odoo, Notion, Gmail, WhatsApp, Drive, etc.)

Write the result as JSON to /Users/Kawader/KAWASIST/tools/_manifest.json:
{
  "generatedAt": "ISO timestamp",
  "tools": [
    {
      "name": "odoo",
      "purpose": "XML-RPC client + scripts for Odoo SaaS instances",
      "entrypoint": "odoo_client.py",
      "language": "python",
      "consumers": ["/odoo-expert", "/rental-audit", "/import-product-content"],
      "externalDeps": ["odoo XML-RPC", "google sheets"]
    }
  ]
}

Don't modify any tool — just produce the manifest. Surface in the chat any tool with consumers=[] (= orphan candidate).

Done when: tools/_manifest.json exists, all 24 folders assessed, orphans called out.

Scan my auto-memory store at ~/.claude/projects/-Users-Kawader-KAWASIST/memory/ for cleanup opportunities.

For each .md file:
1. Read the frontmatter (name, description, type)
2. Look for:
   - Duplicate or near-duplicate descriptions across different files
   - Stale references (file paths that no longer exist, projects marked "active" but with no mention in last 30 days of notes/daily/)
   - Memories whose frontmatter type doesn't match content style (e.g. labeled "reference" but reads like "feedback")
   - Empty/near-empty files

Output a triage list to outputs/memory-hygiene-{TODAY}.md with three sections:
- MERGE candidates (pairs of files with overlapping content)
- ARCHIVE candidates (stale, type mismatch, empty)
- KEEP (active + correctly typed) — count only, don't list

Do NOT edit or delete anything. Propose only. End with a 3-line summary I can act on.

Done when: outputs/memory-hygiene-{TODAY}.md exists with at minimum the MERGE and ARCHIVE sections populated.

Audit which MCP servers are actually used in KAWASIST.

1. Read .mcp.json (or the MCP config in CLAUDE.md / .claude/) to enumerate ALL configured MCP servers.
2. Grep KAWASIST/skills/ + KAWASIST/.claude/commands/ + KAWASIST/tools/ for each MCP's tool prefix (e.g. mcp__claude_ai_Notion__, mcp__whatsapp__, mcp__gdrive__).
3. Count references per server. Note which are referenced 0 times.
4. For the heavy hitters (top 5), list the skill(s) that drive most usage.

Output to outputs/mcp-usage-{TODAY}.md:
- Table: server | configured? | references | top 3 consumers
- Section "Unused — candidates to disable" (servers configured but never referenced)
- Section "Heavily used — candidates to wrap in a tighter skill" (servers with >20 refs but no dedicated skill)

Read-only. Don't touch .mcp.json.

Done when: outputs/mcp-usage-{TODAY}.md exists with all configured MCPs accounted for.

Rewrite /Users/Kawader/KAWASIST/.claude/commands/home.md in Andrej Karpathy's pedagogical style.

Rules:
1. Every step gets a WHY line in addition to the WHAT. Format:
   ## Step N — <short imperative>
   **What:** <the action>
   **Why:** <why this step exists; what would go wrong if you skipped it>

2. Every branch is visible. If a step has "if A do X else Y", that's two named sub-steps, not buried in prose.
3. Every output is named. ("Returns: 6-section Telegram message with X, Y, Z.")
4. Add a "Built from scratch" appendix at the bottom explaining how a human would execute /home WITHOUT the bot — the manual version, step by step. This is the Karpathy "build it yourself" move: it forces the spec to be honest.

5. Preserve the original behavior exactly. The rewrite is presentation only — no new tool calls, no new behavior.

Write the result to outputs/karpathy-rewrites/home.md (don't overwrite the original yet). Show me a diff summary at the end.

Done when: outputs/karpathy-rewrites/home.md exists, every step has Why, branches are named, output is named, appendix is present.

Apply the same Karpathy-style rewrite (see /home rewrite prompt) to /Users/Kawader/KAWASIST/.claude/commands/brief.md. Specifically:

- Every "look at X and decide Y" must be a named, numbered decision point with explicit branches
- Add an "If this brief is for <audience>" overlay section: who's the reader, what do they need? (Ihab needs different framing than Ameer needs)
- Add a "Worked example" section: a real prior brief from outputs/ (find the most recent), annotated with which step produced which output line

Write to outputs/karpathy-rewrites/brief.md. Don't overwrite the original.

Done when: outputs/karpathy-rewrites/brief.md has named decisions, audience overlay, worked example, and preserves original behavior.

Karpathy-rewrite /Users/Kawader/KAWASIST/.claude/commands/rental-audit.md. Plus:

For each step, add a "What could go wrong" line listing the 1-2 most likely failure modes (e.g. WhatsApp pagination missing the relevant thread; Odoo timezone mismatch when joining sales-order dates with WA timestamps).

Add an "Appendix: Failure modes" at the end consolidating all of them with a one-line "How to detect" + "How to recover" for each. This is the Karpathy "what would go wrong if a student tried this" appendix.

Write to outputs/karpathy-rewrites/rental-audit.md.

Done when: every step has its failure-mode line + the consolidated appendix is at the bottom.

Karpathy-rewrite /Users/Kawader/KAWASIST/.claude/commands/site-iter.md (the website design loop).

This skill already has gate criteria (μ / F / S altitudes from brand/design-manifest.yaml). Pull those gate criteria out into a visible checklist at the top — they're currently buried in prose.

Also: produce a companion outputs/karpathy-rewrites/site-iter-gates.excalidraw drawing showing the 5 gates as a 5-node flow (μ → F → S, with the decision per gate as a labeled diamond). Use simple Excalidraw v2 JSON; the user will polish in Obsidian.

Don't change the skill's behavior. Don't touch brand/design-manifest.yaml.

Done when:
- outputs/karpathy-rewrites/site-iter.md has the gate checklist visible at the top
- outputs/karpathy-rewrites/site-iter-gates.excalidraw exists as valid JSON

Karpathy-rewrite /Users/Kawader/KAWASIST/.claude/commands/odoo-accounting-expert.md.

The unique requirement here: for EVERY factual claim the skill outputs (numbers, balances, dates, vendor names), the rewrite must specify the source-of-truth chain. Format:

> Claim: "Outstanding A/R is ₪47,231"
> Chain: Odoo account.move (move_type='out_invoice', state='posted', payment_state='not_paid') → sum of amount_residual → as of read_date

This is the Karpathy "show every gradient" move applied to finance: no claim without a derivation.

Also: append a "Common errors" section with the top 5 ways an accounting query goes wrong (timezone joins, draft vs posted invoices, multi-company filters, currency conversion, fiscal period vs calendar period).

Write to outputs/karpathy-rewrites/odoo-accounting-expert.md.

Done when: every output category has its source-of-truth chain + common-errors section is at the bottom.

Generate an Excalidraw v2 JSON for the <CLUSTER_NAME> skill cluster.

Replace <CLUSTER_NAME> with one of: rentals, ibns, daily-ops, comms, finance, brand-web.

Steps:
1. Read /Users/Kawader/KAWASIST/skills/INDEX.md to find which skills belong to that cluster
2. For each skill, identify: inputs (data sources), decision branches, outputs (artifacts), tools touched
3. Lay out the diagram with:
   - One labeled rectangle per skill
   - Arrows between skills showing typical sequencing (e.g. /checkin precedes /checkout)
   - A "tools" cluster on one side showing shared dependencies (Odoo, WA, Drive)
   - Color code: skills in green, tools in amber, decision diamonds in gold

Output to /Users/Kawader/KAWASIST/knowledge/diagrams/<CLUSTER_NAME>.excalidraw as valid Excalidraw v2 JSON ({"type": "excalidraw", "version": 2, "elements": [...], "appState": {...}, "files": {}}).

Verify the JSON parses by reading it back and counting elements (expect 10-25).

Done when: file exists, JSON parses, contains at least 10 elements, opens cleanly in https://excalidraw.com (drag-drop test).

Take the skill at /Users/Kawader/KAWASIST/.claude/commands/<SKILL_NAME>.md and produce an Excalidraw v2 JSON showing its decision tree.

Steps:
1. Parse the skill body for branches (if/then/else, "depending on X", numbered options)
2. Lay out as a vertical flow:
   - Entry point at top (rounded rectangle, gold)
   - Each decision = diamond, labeled with the question
   - Each branch = arrow + child rectangle
   - Terminal outputs = rectangles at the bottom
3. Use color: gold for entry/exit, purple for decisions, white for action steps

Save to /Users/Kawader/KAWASIST/knowledge/diagrams/<SKILL_NAME>-tree.excalidraw.

Done when: JSON validates, opens in Excalidraw, branches match the skill markdown structure 1:1.

Build a tool-dependency Excalidraw diagram for /Users/Kawader/KAWASIST/tools/<TOOL_NAME>/.

1. Read the tool's main entrypoint + README
2. Identify what calls this tool (grep skills/ + .claude/commands/) — upstream callers
3. Identify what this tool calls (grep its source for imports, API endpoints, MCP prefixes) — downstream dependencies
4. Lay out the diagram:
   - Center: the tool itself (large rectangle, amber)
   - Top: upstream callers (skills) — green rectangles, arrows pointing DOWN into the tool
   - Bottom: downstream deps (Odoo, Notion, etc.) — purple rectangles, arrows pointing DOWN from the tool

Save to /Users/Kawader/KAWASIST/knowledge/diagrams/tool-<TOOL_NAME>-deps.excalidraw.

Useful for impact analysis before changes ("if I touch this tool, what breaks?").

Done when: file exists, valid JSON, shows full caller-and-dependency graph.

Update an existing Excalidraw diagram. Inputs:
1. Path to the .excalidraw file
2. The intent of the update in plain English (e.g. "add a new node for the Accounting agent connected to the shared memory store")

Steps:
1. Read the existing JSON
2. Make the smallest necessary change — preserve element IDs, only add/modify what's needed
3. Maintain visual consistency: match stroke color + roughness + font of existing elements
4. Bump the version field on modified elements + add a fresh updated timestamp
5. Write back to the SAME path (don't create a new file)
6. Optional: also export an SVG sibling — load the JSON in headless Excalidraw or hand-render via SVG that matches the style

Show me a one-line summary of what changed.

Done when: the file opens cleanly in excalidraw.com, only the intended change is visible, the rest is unchanged.

Implement roadmap item #1: per-mission cost stamp on every card.

Context: Mission cards in /Users/Kawader/ClaudeClaw/claudeclaw-os/web/src/pages/MissionControl.tsx currently show title + assignee + status. They do NOT show cost or tokens.

Steps:
1. Read claudeclaw-os/src/db.ts. If input_tokens / output_tokens / cost_usd are not on mission_tasks, add them via a new migration (follow the existing migration pattern).
2. Update the spawn pipeline in claudeclaw-os/src/scheduler.ts (function runDueMissionTasks) to persist token counts + cost back after the spawn. The Anthropic SDK returns usage in the response — capture it.
3. Update web/src/pages/MissionControl.tsx — add an inline cost badge to each card. Row below title: "$0.42 · 1.2k tokens" in muted color. Skip the row if null.
4. Verify by triggering a mission, waiting for completion, refreshing — the card should show the cost inline.

Don't change anything else. Keep minimal.

Done when:
- Migration runs cleanly
- A completed mission shows cost inline
- A queued mission shows no cost row

Pause and confirm before any write outside claudeclaw-os/ + claudeclaw-os/store/.

Implement roadmap item #2: freeform query bar above Mission Control that parses key:value filters.

Spec:
- Single text input atop /Users/Kawader/ClaudeClaw/claudeclaw-os/web/src/pages/MissionControl.tsx
- Accepts: status:queued, status:running, status:done, status:failed, agent:<name>, since:24h, since:7d, since:2026-05-01, free text
- Combined: "status:queued agent:main since:24h grant"
- Parser: 30-line pure function in web/src/lib/queryParse.ts. No external deps.
- Filter visible cards client-side. Show parsed-filter chips below with "x" to remove.
- Persist last query in sessionStorage.

Steps:
1. Write the parser as a pure function. Unit-test in __tests__.
2. Wire to the existing list filter in MissionControl.tsx.
3. Style: small monospace pill chips for active filters.

Done when:
- "status:queued" filters to queued only
- "agent:main since:7d budget" combines correctly
- Filter chips visible + removable
- 5+ unit tests pass

Don't refactor existing kanban code.

Implement roadmap item #3: /capture Telegram verb that appends to memory with zero LLM routing.

Spec:
- Command handler in /Users/Kawader/ClaudeClaw/claudeclaw-os/src/bot.ts.
- Triggers: "/capture <text>" | forwarded message with /capture caption | voice memo with /capture caption.
- Behavior:
  - Text → append to new raw_captures table. Echo "✓ captured".
  - Voice → transcribe via existing pipeline, save transcript + audio id. Echo "✓ captured (transcribed)".
- NEVER spawn Claude. Zero LLM cost per /capture.
- Nightly job (call from scheduler.ts at cron 0 3 * * *) takes raw_captures from last 24h, runs through the existing memory consolidator (Gemini Flash). Now searchable.

Steps:
1. Migration: CREATE TABLE raw_captures (id, chat_id, kind, text, audio_id, created_at).
2. Add bot.command('capture', ...) handler.
3. Wire nightly consolidator in scheduler.ts.
4. Test: send "/capture remember to call Naeem about meta ads" → row exists → next morning, memory appears.

Done when: /capture works for text + voice, raw_captures gets rows, memory shows up after nightly run.

Pause and confirm before any write outside claudeclaw-os/ + ~/.claude/projects/.../memory/.

Implement roadmap item #4: "Today's learnings" tile on the System page.

Spec:
- Location: System page, after the stat-tile row, before Controls.
- Data: GET /api/system/learnings returns last 24h of memory entries from ~/.claude/projects/-Users-Kawader-KAWASIST/memory/ (mtime >= now-24h). For each: title, type, 1-line summary.
- Display: card "Today's learnings (N)" + max-3-row list. "View all" expands to a dialog.

Steps:
1. Backend: GET /api/system/learnings in /Users/Kawader/ClaudeClaw/claudeclaw-os/src/dashboard.ts. Read memory dir, filter by mtime, parse frontmatter.
2. Frontend: extend web/src/pages/System.tsx with <LearningsTile />. Hit endpoint on mount.
3. Empty state: "No new learnings in the last 24h — the consolidator runs every 30 min."

Done when: endpoint returns valid JSON, tile shows entries OR empty state, "View all" opens a dialog.

Don't change any other tiles.

Implement roadmap item #5: per-skill cost breakdown on the Usage page.

Spec:
- Group today's token spend by skill (slash command) invoked.
- Display: bar chart / sorted list under Today Tokens tile in web/src/pages/Usage.tsx.
- "Unattributed" bucket for free-form chat.

Steps:
1. Tag each spawn with skill_slug. In src/skills.ts (or wherever /api/kawader/skills/:slug/run lives), record skill_slug.
2. Migration: ALTER TABLE conversation_log ADD COLUMN skill_slug TEXT.
3. New endpoint: GET /api/usage/by-skill?since=24h → [{skill: '/home', tokens: 4200, cost: 0.35, turns: 1}, ...].
4. Frontend: horizontal bar chart with inline SVG (no library).

Done when:
- Chart shows at least 2 buckets if skills fired
- Free-form chat in "Unattributed"
- Sums match Today Tokens / Cost

Don't change existing tiles. Add only.

Scan my WhatsApp Business channel for unanswered rental inquiries.

Definition of "unanswered inquiry":
- Inbound message from a non-team contact (not Ameer, not staff)
- Mentions rental keywords (rent, rental, camera, lens, gear, kit, package, weekend, day, project, shoot, film, video)
- Last message in the thread is from THEM, not us
- Older than 2 hours

For each:
1. Contact name + phone (last 4 digits only in chat reply)
2. Inquiry summary (≤30 words)
3. Draft reply in Palestinian dialect, ≤40 words, sign off "Kawader"
4. Notes for me if missing info

Post the list to me in Telegram. Do NOT send any WA message — drafts only.

Done when: Telegram message with all unanswered inquiries listed, drafts shown, no WA sends.

Produce my end-of-day wrap and append it to /Users/Kawader/KAWASIST/notes/daily/{TODAY}.md.

Pull from:
1. Today's git commits in /Users/Kawader/KAWASIST and /Users/Kawader/ClaudeClaw/claudeclaw-os (git log --since=today --oneline)
2. Completed mission tasks today
3. Today's bot turns (Usage / tokens.json)
4. Today's auto-consolidated memories
5. Any unresolved threads from notes/daily/{YESTERDAY}.md "What's next"

Format:
## EOD wrap — {TODAY}

**Shipped:**
- ...

**Learned (from auto-memory):**
- ...

**Open / blocked:**
- ...

**Tomorrow's first thing:**
- ONE line. The single most important start.

Append (don't overwrite) to notes/daily/{TODAY}.md.

Done when: file has the 4-section wrap appended.

Research grant <GRANT_NAME> for the IBNS S2 production. Overnight task.

For the grant:
1. Find the official call page. Capture: opens-date, deadline, eligibility, max amount, currency, what they fund, required deliverables.
2. Find 3 previous grantees in our genre. Project, year, amount, what won them the grant.
3. Compare to IBNS S2's profile (pitch-deck status, budget alignment, timeline).
4. Fit assessment: 1-5 with one-paragraph reason.
5. If fit ≥3, draft the FIRST PARAGRAPH of an application (3-5 sentences, MSA Arabic, hook-first).

Write full briefing to outputs/grant-research/<GRANT_NAME>-{TODAY}.md.
Post 5-line summary to Telegram with fit score, deadline, hook.

Done when: brief exists + Telegram summary sent.

I'm a new operator joining Kawader and need to understand the AI OS setup. Read in order:

1. /Users/Kawader/KAWASIST/outputs/claudeclaw-guide/index.html — this guide
2. /Users/Kawader/KAWASIST/CLAUDE.md
3. /Users/Kawader/KAWASIST/knowledge/business-brain.md
4. /Users/Kawader/KAWASIST/outputs/claudeclaw-guide/team-templates/README.md
5. /Users/Kawader/KAWASIST/skills/INDEX.md

Then write me a 300-word onboarding doc to outputs/onboarding/{TODAY}.md covering:
- What KAWASIST is in 2 sentences
- The 4 ways to invoke the bot (Chat / Mission / Scheduled / Skills)
- The 4 layers (Knowledge / Memory / Skills / Tools) — where do they live
- Which agent role I would inhabit — pick based on what you know; ask me if unclear
- 3 specific commands I should try first
- 1 safety rule I must not violate

End with one question about my role I haven't answered.

Done when: outputs/onboarding/{TODAY}.md exists, <400 words, has all 6 sections.

Verify the per-mission cost stamp from roadmap #1 is wired correctly.

Steps:
1. Read latest 5 completed mission_tasks: sqlite3 store/claudeclaw.db "SELECT id, status, input_tokens, output_tokens, cost_usd FROM mission_tasks WHERE status='done' ORDER BY completed_at DESC LIMIT 5;"
2. Check input_tokens + output_tokens are non-null and cost_usd is positive.
3. Cross-check sum against /api/tokens within 10%.
4. Open Mission Control → confirm those 5 cards show cost inline.

If any check fails, report exactly which one.

Don't fix anything — verify only.

Done when: all 4 conditions checked with evidence.

Verify the new <AGENT_NAME> agent obeys its scope.

Steps:
1. Send a probe for a skill NOT on its allowlist. Expected: refusal citing scope.
2. Send a write-intended out-of-scope request. Expected: refusal.
3. Send a legitimate in-scope request. Expected: it runs.
4. Audit → filter by agent_id = <AGENT_NAME>. Confirm 3 entries with correct status (BLOCKED, BLOCKED, OK).
5. Hive Mind → filter for <AGENT_NAME>. Confirm in-scope action logged.

Report pass/fail. If failure: which check + the exact response that broke scope.

Don't modify config — verify only. If a fix is needed, propose the CLAUDE.md edit and stop.

Done when: 5/5 pass OR you've identified the failing check.