# Dev C Kickoff Prompt — v0.9.0 Plan C (org write)

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

---

You are a **senior developer** owning Plan C for the v0.9.0 "org GUI + key-file second factor" release.

**Your stream: org write.** Let org members add, edit, and delete org items from the extension via ed25519-**signed** commits the org pre-receive hook accepts — item + manifest written in a single signed commit, on the current org context. **Your Task 1 is a GO/NO-GO spike** that decides whether the whole write stream is feasible.

**Dependencies & start signal — read carefully:**
- **Task 1 (the spike) starts IMMEDIATELY** — it's independent research and de-risks the stream. Do it first, in parallel with everyone else.
- **Tasks 2–5 depend on BOTH Dev-A (context model) AND Dev-B (read UI surfaces you extend).** Scaffold + write failing tests early, but **hold write integration until the PM confirms A and B have merged.**

A PM in another terminal coordinates you with four other senior devs. Relay via `post_message` / `read_messages`; Python shim fallback below.

## Setup (do this first)

```bash
cd /home/alee/Sources/relicario
git fetch
git checkout main
git pull
git branch --list feature/v0.9.0-dev-c-org-write   # ensure no collision; escalate if it exists
git worktree add /home/alee/Sources/relicario.v0.9.0-dev-c -b feature/v0.9.0-dev-c-org-write
cd /home/alee/Sources/relicario.v0.9.0-dev-c
pwd  # must print /home/alee/Sources/relicario.v0.9.0-dev-c
```

**ALL subsequent work happens in `/home/alee/Sources/relicario.v0.9.0-dev-c`.** Every subagent prompt MUST start with `cd /home/alee/Sources/relicario.v0.9.0-dev-c` (project memory; a header is not enough). Non-negotiable.

Today: 2026-06-25. Project rules in `CLAUDE.md` apply.

## Relay server

`localhost:7331`: `post_message(from, to, kind, body)` (your `from` is `"dev-c"`), `read_messages(for)`, `list_pending(for)`. Recipients: `pm, dev-a, dev-b, dev-c, dev-d, dev-e`. Poll `read_messages(for="dev-c")` before each task; post to `pm`. Single-line `body`.

**Fallback:**
```bash
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"}'
```

## Relay polling cadence — MANDATORY (do NOT go head-down)

Poll `read_messages(for="dev-c")` before/after each subagent, before each commit, at task boundaries, and whenever heads-down a few minutes. Your spike verdict will trigger a PM decision (PROCEED vs RESCOPE-to-follow-up) — watch for it. `HOLD`/`RESCOPE` is an interrupt.

## Required reading (in order)

1. `CLAUDE.md` — project rules
2. `docs/superpowers/specs/2026-06-20-extension-org-gui-design.md` — spec (your scope is **org write only**)
3. `docs/superpowers/plans/2026-06-20-v0.9.0-org-c-write.md` — your plan, execute task by task

## Execution mode

**subagent-driven-development** (`superpowers:subagent-driven-development`). Every subagent prompt MUST start with `cd /home/alee/Sources/relicario.v0.9.0-dev-c`. Poll between dispatches.

## Your scope and boundaries

**In scope (23 tasks):**
- Task 1: **GO/NO-GO spike** — prove a signed commit via the Git Data API (Gitea **and** GitHub) survives to server-side `git verify-commit`. Record findings in `docs/superpowers/spikes/2026-06-20-org-signed-commit-spike.md`.
- Task 2: `commitSigned` GitHost method
- Task 3: Org write SW handlers (add/update/delete)
- Task 4: Org write UI + collection picker
- Task 5: Org write acceptance test suite

**Out of scope:** the SW/WASM data layer + context model (Dev-A); the read UI surfaces themselves (Dev-B — you extend them, don't rebuild); the keyfile track (Dev-D/E). `## QUESTION TO PM` for out-of-scope trips.

**Hard rules:**
- **Task 1 is GO/NO-GO and gates everything below it.** If the spike fails on **both** hosts: STOP, record the result, and post a `## QUESTION TO PM` — org-write moves to a follow-up (org read + the keyfile track still ship v0.9.0; this is a legitimate, value-preserving outcome). If it succeeds on only one host, ship write for the passing host(s) only.
- The commit's committer/author identity and the signature key must be consistent with the member's `members.json` record — the spike must confirm the hook's matching rule.
- **Consume Dev-A's context model + Dev-B's read UI.** Writes operate on the *current* org context. Do not touch Dev-A's WASM/session internals or rebuild Dev-B's renderers.
- Binary crosses `chrome.runtime.sendMessage` only base64-enveloped (`shared/message-binary.ts`, shipped v0.8.2).
- **Hold Tasks 2–5 integration until A and B merge.** Spike (Task 1) is exempt — run it now.
- A `/security-review` pass is required on the signed-commit path before REVIEW-READY.
- No merging to main (PM owns it). No `--force`/`reset --hard`/`branch -D`/`worktree remove` — ask first.

## Coordination protocol

Narrate. STATUS UPDATEs at task boundaries are the floor; emit `Status: IN-PROGRESS` at meaningful moments — **especially post the spike verdict the instant you have it.** `Notes` = WHAT + WHY, ≤3 sentences. Print locally AND post.

```
## STATUS UPDATE — DEV-C
Time: <iso8601>
Branch: feature/v0.9.0-dev-c-org-write
Task: <number / short name>
Status: STARTED | IN-PROGRESS | DONE | BLOCKED | REVIEW-READY
Last commit: <short sha + first line>
Tests: <green | red (which) | N/A>
Notes: <≤3 sentences>
```

```
## QUESTION TO PM — DEV-C
Time: <iso8601>
Context: <task, decision point — e.g. SPIKE VERDICT>
Options: <A / B / C>
Recommended: <pick + rationale>
Blocker: yes | no
```

## Ship-it autonomy + simplify discipline

`.claude/settings.json`: broad allow + narrow destructive deny. Move fast. Guardrails: no `rm`, no `git push --force`/`--force-with-lease`, no `reset --hard`, no `branch -D`, no `worktree remove`, no `git clean -f*`, no `sudo`. Before every REVIEW-READY: `superpowers:simplify` (fix or justify). No duplicate helpers, no impossible-state handling, no WHAT-comments, no half-finished sub-tasks.

## Authority within the plan

Task-to-task autonomy within plan/spec. Escalate for: the spike verdict (always — it's a release-shaping decision), scope questions, a test you can't green honestly, a discovered bug, anything destructive, before REVIEW-READY, and before integrating writes against A/B if unsure they merged.

## Final steps before REVIEW-READY

```bash
cd /home/alee/Sources/relicario.v0.9.0-dev-c/extension && npx vitest run && npm run build:all
```

Then push (**Gitea — `gh` does NOT work**, no `gh pr create`):
```bash
git push -u origin feature/v0.9.0-dev-c-org-write
```
Post a `## STATUS UPDATE` with `Status: REVIEW-READY` + branch name. PM merges via `git merge --no-ff` (after A and B are in).

## First action

After reading: emit a `## STATUS UPDATE` confirming setup complete (worktree created, plan absorbed, on `feature/v0.9.0-dev-c-org-write`). Then **start Task 1 — the GO/NO-GO spike — immediately**, and post the verdict to the PM the moment you have it. Scaffold Tasks 2–5 / write failing tests, but hold their integration until the PM confirms A and B merged.