relicario/docs/superpowers/coordination/2026-05-09-cli-tail-dev-c-prompt.md

Dev C Kickoff Prompt — CLI Tail (Cycle 2) Stream C

Paste everything below the --- line into a fresh Claude Code terminal as the first user message.

---

You are a senior developer owning Stream C of the CLI-tail cycle-2 release.

Stream C is Plan B Phases 7 and 8 — the parser migration to relicario-core plus the WASM seam. Two phases, M effort:

• Phase 7 — Migrate parse_month_year, base32_decode_lenient, guess_mime from crates/relicario-cli/src/parse.rs into relicario-core (MonthYear::parse on time.rs, new pub(crate) mod base32 with encode_rfc4648 / decode_rfc4648_lenient, new mime::guess_for_extension). Pair with DEV-A's P2 base32 dedup: extract the inline base32_encode from crates/relicario-core/src/item.rs:255-275 and decode_base32_totp from crates/relicario-core/src/import_lastpass.rs:202-220 into the new shared module. Steam's STEAM_ALPHABET at item_types/totp.rs:13 stays untouched (with a neighbour comment). The CLI's parse.rs becomes a thin re-export shim — no callsite changes in cycle 2.
• Phase 8 — #[wasm_bindgen] exports for the three migrated parsers (parse_month_year, base32_decode_lenient, guess_mime) plus the matching declarations in extension/src/wasm.d.ts. snake_case JS naming consistent with every existing export. Plan C (extension restructure) does NOT consume these this round — the seam ships in cycle 2; consumption is a future plan.

Phase definitions are canonical in docs/superpowers/specs/2026-05-04-cli-restructure-design.md Phases 7 and 8. Internal sequencing: Phase 7 before Phase 8.

A PM in another terminal coordinates you with Dev-A (Plan B Phase 3) and Dev-B (Plan B Phases 4, 5, 6). With the relay server running, you communicate via post_message / read_messages directly.

Setup (do this first)

cd /home/alee/Sources/relicario
git fetch
git checkout main
git pull
git worktree add ../relicario.cli-tail-stream-c -b feature/cli-tail-stream-c-core-wasm-seam
cd ../relicario.cli-tail-stream-c
pwd  # should print /home/alee/Sources/relicario.cli-tail-stream-c

ALL subsequent work happens in /home/alee/Sources/relicario.cli-tail-stream-c. Force-cd subagents into this directory — CLAUDE.md has a memory rule that subagent prompts MUST start with cd /home/alee/Sources/relicario.cli-tail-stream-c so subagents don't accidentally commit to main. Non-negotiable.

Today: 2026-05-09. Project rules in CLAUDE.md apply.

Relay server

A message-bus MCP server is running on localhost:7331. You have three native tools:

• post_message(from, to, kind, body) — push a message; your from is always "dev-c"
• read_messages(for) — drain your inbox; call with for="dev-c" before each task
• list_pending(for) — check inbox count without consuming

Recipients: pm, dev-a, dev-b, dev-c. Use these instead of asking the user to copy-paste. Before starting each task: read_messages(for="dev-c"). After emitting any status/question block: post_message(from="dev-c", to="pm", kind="status"|"question", body="...").

Fallback: If the relay MCP tools are not registered in your session, use the Python shim:

cd /home/alee/Sources/relicario/tools/relay
python3 call.py post_message '{"from":"dev-c","to":"pm","kind":"status","body":"..."}'
python3 call.py read_messages '{"for":"dev-c"}'

Cycle-1 lessons baked in (read once):

• Prefer single-line body content when posting to the relay. Some inbox-monitor scripts use strict JSON parsers that reject embedded \n literals. Use periods between sentences and -- for stronger breaks; reserve actual newlines for STATUS UPDATEs you're printing locally only.
• If you build your own inbox-monitor in Python: f-strings cannot contain backslash-escaped quotes inside brace expressions. Use single quotes inside: {m.get('from')} not {m.get(\"from\")}. Cycle-1 DEV-A and DEV-B both hit this; documenting once here so cycle-2 DEV-C does not.

Required reading (in order)

1. CLAUDE.md — project rules
2. docs/superpowers/coordination/2026-05-09-cli-tail-coordinator.md — partition spec; confirms your scope is Phases 7 + 8 only
3. docs/superpowers/specs/2026-05-04-cli-restructure-design.md — Plan B (read the whole plan; execute Phases 7 and 8)
4. docs/superpowers/reviews/2026-05-04-architecture-review.md — synthesis (skim only — your work is fully captured in Plan B)
5. docs/superpowers/reviews/2026-05-04-dev-a-notes.md — DEV-A's notes; the relevant section is the P2 "three base32 implementations" finding (the dedup that pairs with your Phase 7)
6. docs/superpowers/reviews/2026-05-04-dev-b-notes.md — DEV-B's notes; the relevant section is the parser-migration P2 (line-level context for parse_month_year, base32_decode_lenient, guess_mime)
7. docs/superpowers/reviews/2026-05-04-dev-c-notes.md — read only the "Boundary notes for DEV-B" section (cross-boundary contracts — wasm.d.ts is hand-maintained; every change must mirror; BigInt typing care for attachment_encrypt-style paths, but your three new exports take only &str and return primitives so they avoid that class)

Execution mode

Use subagent-driven-development. Invoke superpowers:subagent-driven-development and follow it: fresh subagent per phase, two-stage review.

Every subagent prompt MUST start with:

cd /home/alee/Sources/relicario.cli-tail-stream-c

…before any other instruction.

Your scope and boundaries

In scope: Plan B Phases 7 and 8 — parser migration to relicario-core (paired with DEV-A P2 base32 dedup), then WASM exports + extension/src/wasm.d.ts mirror.

Out of scope:

• Phase 3 (Dev-A owns) — prompt_or_flag<T> + builder compression
• Phases 4, 5, 6 (Dev-B owns) — session/manifest discipline
• Plan C (extension restructure) — consumption of your new WASM exports is explicitly deferred to a future plan; you ship the seam, you do NOT wire SW message handlers in the extension.
• Anything outside Plan B Phases 7-8. If you trip over an out-of-scope issue (e.g. a fourth base32 implementation surfaces; a parser the CLI uses that wasn't in Plan B's three), file a ## QUESTION TO PM block and keep moving.

Hard rules:

• Steam's STEAM_ALPHABET at crates/relicario-core/src/item_types/totp.rs:13 is intentionally non-RFC-4648; do NOT consolidate it into the new shared base32 module. Add a neighbour comment: // not RFC 4648 — Steam Guard's de-ambiguated alphabet; see crate::base32 for the standard impl.
• The CLI's parse.rs becomes a thin re-export shim — keep callsite imports unchanged in cycle 2 (no caller-side import churn).
• WASM JS naming stays snake_case for the three new exports — consistent with every existing #[wasm_bindgen] export. Do NOT introduce camelCase here; that decision is explicitly deferred per Plan B.
• extension/src/wasm.d.ts mirror lands in the same commit as the Rust #[wasm_bindgen] additions. Both sides updated together; no half-state.
• Do not change CLI external behaviour — all existing crates/relicario-cli/tests/* integration tests must pass without modification.
• Do not merge your branch to main. The PM owns merges.
• Do not push --force or run git reset --hard. Per CLAUDE.md: ask first.

Internal phase sequencing (within Stream C):

• Phase 7 (parser migration to core + base32 dedup) before Phase 8 (WASM exports). Phase 8 imports from the new core paths; Phase 7 must compile clean first.

Coordination protocol

You are one of four terminals. The PM coordinates you with Dev-A and Dev-B.

Narration discipline. STATUS UPDATEs at task boundaries are the floor, not the ceiling. Also emit Status: IN-PROGRESS updates at meaningful in-flight moments:

• When you dispatch a subagent
• When a subagent returns with a decision worth flagging (an unexpected coupling, an alternative API shape considered, a found-but-flagged out-of-scope issue)
• When a sub-task completes (e.g. base32 module landed; MonthYear::parse integrated; first WASM export wired)
• When you change direction or hit something unexpected
• When you start a new phase

The Notes field should narrate WHAT and WHY. Three sentences max. Examples of useful: "subagent surfaced a fourth base32 callsite in crates/relicario-core/src/manifest.rs:??; not in DEV-A P2's flagged list — escalating as a question"; "kept MonthYear::parse returning Result<Self, RelicarioError> rather than touching MonthYear::new's &'static str per Plan B's recommendation; new-to-RelicarioError is DEV-A's separate P3"; "WASM exports compile clean; wasm.d.ts mirror passes tsc --noEmit in extension/." Print every STATUS UPDATE locally too.

At every task boundary AND every meaningful in-flight moment: call read_messages(for="dev-c") first, then post via post_message and print here. Format:

## STATUS UPDATE — DEV-C
Time: <iso8601>
Branch: feature/cli-tail-stream-c-core-wasm-seam
Task: <phase number / sub-step>
Status: STARTED | IN-PROGRESS | DONE | BLOCKED | REVIEW-READY
Last commit: <short sha + first line>
Tests: <green | red (which failed) | N/A>
Notes: <WHAT and WHY — 3 sentences max>

For PM input mid-task:

## QUESTION TO PM — DEV-C
Time: <iso8601>
Context: <what task, what decision point>
Options: <A: ... / B: ... / C: ...>
Recommended: <your pick + one-sentence rationale>
Blocker: yes | no

Authority within Phases 7-8

You don't need PM permission to:

• Execute sub-steps per Plan B's Phases 7 and 8
• Make implementation decisions consistent with Plan B
• Write tests, refactor your own code, fix bugs you introduce
• Push commits to your feature branch

You do escalate when:

• A scope question outside Plan B Phases 7-8
• A test you can't make green after honest debugging
• A discovered bug not in Plan B
• A fourth base32 implementation or a parser surfaces beyond DEV-A P2 + Plan B's three
• Anything destructive (per CLAUDE.md)
• Before opening the PR for review

Final steps before REVIEW-READY

Run the project's full validation:

cd /home/alee/Sources/relicario.cli-tail-stream-c
cargo test --workspace
cargo clippy --workspace
cargo build -p relicario-wasm --target wasm32-unknown-unknown
cd extension && npm run test  # verify wasm.d.ts mirror compiles against TS callers

All four must be green / clean. Then push and open the PR:

cd /home/alee/Sources/relicario.cli-tail-stream-c
git push -u origin feature/cli-tail-stream-c-core-wasm-seam
gh pr create --base main --head feature/cli-tail-stream-c-core-wasm-seam --title "refactor(core,wasm): migrate parsers + base32 dedup + WASM exports (Plan B Phases 7, 8)" --body "$(cat <<'EOF'
## Summary
- Phase 7 — `parse_month_year`, `base32_decode_lenient`, `guess_mime` migrated from CLI to `relicario-core` (`MonthYear::parse`, new `pub(crate) mod base32`, new `mime::guess_for_extension`); base32 dedup folds `crates/relicario-core/src/item.rs:255-275` and `import_lastpass.rs:202-220` into the new shared module (Steam alphabet untouched per neighbour comment)
- Phase 8 — `#[wasm_bindgen]` exports for the three migrated parsers; `extension/src/wasm.d.ts` mirror updated in the same commit; snake_case JS naming consistent with existing exports
- The CLI's `parse.rs` is a thin re-export shim; existing CLI callsites unchanged

## Plan B Phases 7-8
Implements `docs/superpowers/specs/2026-05-04-cli-restructure-design.md` Phases 7 and 8.
See `docs/superpowers/coordination/2026-05-09-cli-tail-coordinator.md` for cycle-2 partition.

## Test plan
- [x] cargo test --workspace
- [x] cargo clippy --workspace
- [x] cargo build -p relicario-wasm --target wasm32-unknown-unknown
- [x] cd extension && npm run test (verifies wasm.d.ts compiles)
- [x] Existing crates/relicario-cli/tests/* pass without modification
- [x] Existing crates/relicario-core/tests/* pass without modification

## Out of scope (deferred)
- Extension consumption of the new WASM exports — Plan C territory; no SW message handlers wired in this PR
- camelCase JS naming for the three new exports — explicitly snake_case per Plan B; the camelCase decision is its own future plan

🤖 Generated with [Claude Code](https://claude.com/claude-code)
EOF
)"

Emit a ## STATUS UPDATE with Status: REVIEW-READY and the PR URL.

First action

After reading: emit a ## STATUS UPDATE confirming setup complete (worktree created, plan absorbed, on feature/cli-tail-stream-c-core-wasm-seam), then start Phase 7 sub-step 1 (create crates/relicario-core/src/base32.rs with the unified encode_rfc4648 / decode_rfc4648_lenient shape).