incitaciones 0.2.0 → 0.3.0

package/pi-package/skills/next/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: next
+description: "Rapid session snapshot to ~/.whisper/ — no full close ceremony. Fast stash for later resumption via /renew"
+metadata:
+  installed-from: "incitaciones"
+---
+---
+name: next
+description: "Rapid session snapshot to ~/.whisper/ — no full close ceremony. Trigger when the user says '/next', 'snap', 'quick save', 'stash session', or 'moving on'."
+tools: Read, Write, Edit, Bash
+---
+
+# Next
+
+Snapshot the current session to `~/.whisper/` and move on. Fast — no project file updates, no inbox triage, no ticket operations. Pure stash.
+
+## Steps
+
+1. Get timestamp: `date +%Y-%m-%d` and `date +%H:%M`.
+
+2. Detect repo and branch:
+   ```bash
+   repo_url=$(git remote get-url origin 2>/dev/null | sed 's|https://||;s|git@||;s|\.git$||')
+   branch=$(git rev-parse --abbrev-ref HEAD)
+   branch_slug=$(echo "$branch" | sed 's|/|--|g')
+   notes_path=~/.whisper/repos/"${repo_url}"/branches/"${branch_slug}"/notes.md
+   ```
+
+3. If `~/.whisper/` doesn't exist or the branch slot doesn't exist, run `/w check` first (which will offer to init). If the user declines, skip and warn.
+
+4. Scan the last portion of the conversation and write a 2–5 bullet snapshot:
+   - What was worked on (files, topics)
+   - Key decisions or changes made
+   - **Next:** the most logical continuation point
+
+5. Append the snapshot to `notes.md`:
+   ```
+   ### YYYY-MM-DD HH:MM — snap
+   - what was worked on
+   - decisions made
+   - **Next:** continuation point
+   ```
+
+6. No commit, no push, no ticket operations. Just write the file.
+
+## Output
+
+```
+✓ Snapped to ~/.whisper/repos/<repo>/branches/<slug>/notes.md
+
+Use `/renew` later to pick this back up.
+```
+
+## Rules
+
+- Do NOT ask questions — summarize automatically from conversation context.
+- Keep it brief — 2–5 bullets, not paragraphs.
+- Do NOT commit or push anything.
+- Do NOT update project files, inbox, or tickets.
+- Do NOT run `/clear`.

package/pi-package/skills/park/SKILL.md

@@ -0,0 +1,103 @@
+---
+name: park
+description: "Snapshot current work before switching context. Logs to daily journal, releases ticket claims, records to ~/.whisper/"
+metadata:
+  installed-from: "incitaciones"
+---
+---
+name: park
+description: "Snapshot current work before switching context. Logs what was done and what's next without ending the day. Trigger when the user says '/park', 'park this', 'switching to', 'pause this', or 'context switch'."
+tools: Read, Write, Edit, Bash
+---
+
+# Park
+
+Snapshot the current session's work on a project/area before switching context. This is NOT end-of-day — just a context switch.
+
+Uses `$JOURNAL_PATH` (defaults to `~/dev/status`) for the daily log, and `~/.whisper/` for accumulated operational knowledge.
+
+## Steps
+
+1. Get today's date and current time (`date +%Y-%m-%d`, `date +%H:%M`).
+   ```bash
+   JOURNAL="${JOURNAL_PATH:-$HOME/dev/status}"
+   ```
+
+2. Read today's log: `$JOURNAL/log/YYYY/YYYY-MM/YYYY-MM-DD.md`
+   If it doesn't exist, create it with the daily log template.
+
+3. Review the conversation history to determine:
+   - What project/area was being worked on
+   - What was accomplished in this session
+   - What the logical next step is
+   - Any new tasks, decisions, or blockers discovered
+
+4. Append a session entry to today's log under `## Log`:
+   ```
+   ### Session:HH:MM (<project/area context>)
+   - what was done
+   - decisions made
+   - **Next:** what to do when resuming
+   ```
+
+5. Update the relevant project/area file if needed:
+   - Mark completed tasks `[x]`
+   - Add new tasks discovered during the session
+   - Add/update `[~]` waiting items with context
+   - Update `## Notes` with any decisions
+
+6. If there are uncommitted changes in the project's git worktree, note them in the log entry.
+
+7. **Release any in-progress ticket claim if leaving mid-work.**
+   Check whether a ticket was claimed for this session:
+   ```bash
+   BRANCH=$(git branch --show-current 2>/dev/null)
+   bd list --status in_progress --label branch:$BRANCH 2>/dev/null
+   ```
+   For each in-progress ticket that is NOT complete:
+   - **If meaningful work was committed:** keep the claim and append a progress note:
+     ```bash
+     bd note <id> "Session parked $(date +%H:%M). Done: <brief>. Safe to resume from: <last commit>."
+     ```
+   - **If nothing was committed:** release the claim so another agent can pick it up:
+     ```bash
+     bd update <id> --assignee "" --status open
+     ```
+
+8. **Record snapshot to `~/.whisper/`.** If `~/.whisper/` exists and a beads-epic is linked, append a note to the epic:
+   ```bash
+   repo_url=$(git remote get-url origin 2>/dev/null | sed 's|https://||;s|git@||;s|\.git$||')
+   branch_slug=$(git rev-parse --abbrev-ref HEAD | sed 's|/|--|g')
+   context_path=~/.whisper/repos/"${repo_url}"/branches/"${branch_slug}"/context.md
+   beads_epic=$(grep '^beads-epic:' "$context_path" 2>/dev/null | sed 's/^beads-epic: *//')
+   if [ -n "$beads_epic" ]; then
+     bd note "$beads_epic" "Parked $(date +%H:%M). Done: <what was accomplished>. Next: <the logical continuation>."
+   fi
+   ```
+
+9. Do NOT commit/push the journal repo yet — that happens at `/close`. Just write the files.
+
+## Output format
+
+```
+---
+**Parked: <project/area name>**
+
+**Session summary**
+- what was accomplished
+
+**Next step** *(for when you /renew)*
+- the logical continuation
+
+**Updated**
+- files modified in status repo (log, project file, etc.)
+
+*Ready to switch context. Use `/renew <slug>` to pick up something else.*
+```
+
+## Rules
+
+- Do NOT ask questions — summarize automatically from conversation context.
+- Keep it brief — this is a quick snapshot, not a full report.
+- Do NOT commit or push the journal repo.
+- Do NOT run `/clear` — the user may continue working in this session.

package/pi-package/skills/renew/SKILL.md

@@ -0,0 +1,169 @@
+---
+name: renew
+description: "Resume work on a project or area. Loads context from journal, ~/.whisper/, and beads. Supports claiming work with file conflict detection"
+metadata:
+  installed-from: "incitaciones"
+---
+---
+name: renew
+description: "Resume work on a specific project or area. Loads focused context for continuing where you left off. When no name is given, infers the project/area from the current repo and git branch. Trigger when the user says '/renew', '/renew <name>', 'pick up <project>', 'continue <project>', or 'back to <project>'."
+tools: Read, Write, Edit, Glob, Bash, Grep
+---
+
+# Renew
+
+Load focused context for a specific project or area to continue work.
+
+Uses `$JOURNAL_PATH` (defaults to `~/dev/status`) for the daily log, and `~/.whisper/` for accumulated operational knowledge.
+
+## Steps
+
+1. Pull the journal repo:
+   ```bash
+   JOURNAL="${JOURNAL_PATH:-$HOME/dev/status}"
+   cd "$JOURNAL" && git pull
+   ```
+
+2. Identify the target.
+
+   **If a `<slug>` is provided:** The user says `/renew <slug>`.
+
+   **If no slug is provided:** Infer from the current workspace context:
+   - Get the repo name: `basename $(git rev-parse --show-toplevel 2>/dev/null)`
+   - Get the branch name: `git branch --show-current 2>/dev/null`
+   - Extract a candidate slug from the branch (strip prefix like `ak/`, `feature/`, etc.)
+   - Use both the repo name and branch-derived slug as candidates
+
+   **Match candidates** against:
+   - `$JOURNAL/projects/*.md` — check filenames and grep for repo/branch references
+   - `$JOURNAL/areas/*.md` — same
+   - Try exact match, then partial/substring match
+   - If multiple matches found, list them and ask the user to pick
+   - If no match found, list available projects/areas and ask
+
+3. Read the matched project or area file.
+
+4. Read today's log (`$JOURNAL/log/YYYY/YYYY-MM/YYYY-MM-DD.md`).
+   If it doesn't exist, create it with the daily log template.
+   Scan for any earlier session entries related to this project/area today.
+
+5. Search recent logs for context (last 3 days):
+   ```bash
+   grep -rl "<slug>" "$JOURNAL"/log/YYYY/YYYY-MM/ 2>/dev/null | tail -3
+   ```
+   Read any matches to understand recent session history.
+
+6. Search inbox for related items:
+   ```bash
+   grep -i "<slug>" "$JOURNAL"/inbox.md
+   ```
+
+7. **Check `~/.whisper/` for accumulated knowledge.**
+   If `~/.whisper/` exists, load context:
+   ```bash
+   repo_url=$(git remote get-url origin 2>/dev/null | sed 's|https://||;s|git@||;s|\.git$||')
+   branch_slug=$(git rev-parse --abbrev-ref HEAD | sed 's|/|--|g')
+   whisper_dir=~/.whisper/repos/"${repo_url}"/branches/"${branch_slug}"
+   ```
+   - Read `context.md` if it exists (extract beads-epic, status)
+   - Read `plan.md` if it has real content
+   - Read `notes.md` if it has real content
+   - Read `env.md` at repo level for infra facts
+   - If beads is available, fetch open issues:
+     ```bash
+     bd list --label branch:<branch> 2>/dev/null
+     bd list --status in_progress --label branch:<branch> 2>/dev/null
+     ```
+     Surface any `in_progress` tickets prominently. The **Suggested next step** must only reference tickets NOT currently `in_progress`.
+
+8. If the project/area has a worktree or repo path noted in its file, gather git context:
+   - `cd <worktree-path> && git branch --show-current`
+   - `git log --oneline -5`
+   - `git status --short`
+   - `git log --oneline origin/main..HEAD`
+
+## Output format
+
+```
+---
+**Resuming: Project/Area Name**
+
+**Status**: brief one-line summary of where things stand
+
+**Last session** *(from most recent log entry)*
+- what was done last time
+
+**Open tasks**
+- [ ] task list from the project/area file
+
+**Waiting**
+- [~] any blocked items and who/what they're waiting on
+
+**Related inbox items** *(if any)*
+- items that mention this project
+
+**Whisper context** *(if ~/.whisper/ exists)*
+- Plan: summary of current plan
+- Notes: key findings
+- Beads issues: <n> open, <n> in_progress
+
+**⚠ Active in flight** *(omit if none)*
+- ◐ `<id>` — <title> [started: <date>]
+- *(If your intended ticket is listed here, see **Claiming work** below.)*
+
+**Workspace**
+- Worktree: path, branch, status
+- Commits ahead of main, uncommitted changes, etc.
+
+**Suggested next step**
+- what makes sense to do next — only suggest tickets NOT currently in_progress
+```
+
+Then ask: *"Ready to continue, or want to adjust the plan?"*
+
+---
+
+## Claiming work
+
+Before writing any code, claim the ticket atomically and check for file conflicts.
+
+### Steps
+
+1. **Claim atomically:**
+   ```bash
+   bd update <ticket-id> --claim
+   ```
+
+2. **Check for file-level conflicts** with other in-progress tickets:
+   ```bash
+   bd list --status in_progress --label branch:<branch> --json 2>/dev/null \
+     | python3 -c "
+   import json, sys
+   issues = json.loads(sys.stdin.read() or '[]')
+   for i in issues:
+       files = (i.get('metadata') or {}).get('files', [])
+       for f in files:
+           print(i['id'] + '\t' + f)
+   "
+   ```
+   Cross-reference against the claimed ticket's own `metadata.files`.
+   If overlap found, surface a warning:
+   ```
+   ⚠ File conflict detected:
+     services/api.py is also claimed by ticket-abc (in_progress)
+
+   Options:
+     A) Gate this ticket until the blocker closes
+     B) Coordinate merge order
+     C) Proceed — accept the conflict (reconcile at merge time)
+   ```
+
+3. **If backing off** (chose option A):
+   ```bash
+   bd update <ticket-id> --assignee "" --status open
+   bd gate create <ticket-id> --type bead --await-id <blocking-id>
+   ```
+
+### Metadata coverage warning
+
+File conflict detection only works when both tickets have `metadata.files` populated (set by `create-issues` or `/w link` at ticket creation time). Tickets created before this convention was adopted have no metadata. For those tickets, **"no conflict found" means unknown, not safe**.

package/pi-package/skills/whisper/SKILL.md

@@ -0,0 +1,89 @@
+---
+name: whisper
+description: "Manage the ~/.whisper/ knowledge workspace: init, check, status, link plan, decommission, and knowledge routing"
+metadata:
+  installed-from: "incitaciones"
+---
+---
+name: whisper
+description: "Manage the ~/.whisper/ knowledge workspace: init, check, status, link plan to beads, decommission, and knowledge routing. Trigger when the user says '/whisper', '/w', 'init workspace', 'check workspace', 'workspace status', 'link plan', or 'decommission worktree'."
+tools: Read, Write, Edit, Bash
+---
+
+# Whisper — Accumulated Operational Knowledge
+
+Manage `~/.whisper/` — a global, tiered knowledge directory that accumulates operational knowledge and planning context across all your work. Works with or without beads issue tracking.
+
+## Directory Layout
+
+```
+~/.whisper/
+  rules.md                          ← Global agent behavior rules (bd remember equiv)
+
+  repos/
+    github.com/user/repo/
+      env.md                        ← Repo-wide: deploy commands, infra facts, auth quirks
+      branches/
+        branch-slug/                ← One slot per branch (/ in name → -- in slug)
+          context.md                ← Branch anchor: repo, branch, beads epic ID, status
+          plan.md                   ← Narrative implementation plan
+          notes.md                  ← Free-form scratch and findings
+          agents/                   ← Optional sub-agent files when work is split across agents
+      worktrees/
+        worktree-name/              ← One slot per worktree (basename of worktree path)
+          env.md                    ← Worktree-specific: ports, venvs, credentials, local-only setup
+```
+
+**Branch slug rule:** `git rev-parse --abbrev-ref HEAD | sed 's|/|--|g'`
+
+**Worktree slot rule:** `basename $(git rev-parse --git-common-dir 2>/dev/null)` (the `.git` worktree dir name), or `basename $(pwd)` when not in a worktree.
+
+## Knowledge Routing
+
+When a session learns something worth keeping, route it by scope:
+
+| Scope | Test | Destination |
+|---|---|---|
+| **Global** | True for every repo and every project | `~/.whisper/rules.md` — append, don't overwrite |
+| **Repo-wide infra** | True regardless of which branch or feature you're on (deploy behavior, gateway/timeout limits, log retention, auth quirks) | `~/.whisper/repos/<host>/<repo>/env.md` — create or extend |
+| **Branch-specific** | Only matters for the work on *this* epic/branch | `~/.whisper/repos/<host>/<repo>/branches/<slug>/notes.md`, or `bd note <epic-id>` if beads is available |
+| **Worktree setup** | Credentials, service IDs, ports, venv/docker specifics for *this checkout* | `~/.whisper/repos/<host>/<repo>/worktrees/<name>/env.md` |
+| **Universal agent rule** | A standing instruction for how the agent should behave, independent of any branch or repo | `bd remember` if available, else `~/.whisper/rules.md` |
+
+**Rules:**
+- **No secrets anywhere.** Never write tokens, keys, passwords, or PII into `~/.whisper/`.
+- **Extend, don't duplicate.** Append to or correct an existing note rather than creating a new one that says the same thing.
+- **Search first.** Before creating a new entry, check if one already exists for the same topic.
+- If `bd` is not available, everything falls back to `~/.whisper/` files — there's no beads-backed alternative.
+
+## Modes
+
+Determine mode from how the skill is triggered:
+
+| Trigger | Mode |
+|---|---|
+| `/w init` or `~/.whisper/` does not exist | **init** |
+| `/w` or `/w status` | **status** |
+| `/w check` or called by `renew` | **check** |
+| `/w link [<path>]` or "link plan" | **link** |
+| `/w decommission` | **decommission** |
+
+See each reference file for the full procedure:
+
+- `references/init.md`
+- `references/check.md`
+- `references/status.md`
+- `references/link.md`
+- `references/decommission.md`
+
+## Rules
+
+- Never run `git worktree remove` automatically — always print the command for the user to execute.
+- Never close beads issues during decommission — only defer. Closing is intentional.
+- **One epic per branch, children via `--parent`, not flat siblings.**
+- **`env.md` is shared and immutable across branch switches.** Never overwrite it during init or check — only create if absent.
+- **Branch slug sanitization is mandatory.** Always run `sed 's|/|--|g'` on the branch name before using it as a directory path.
+- **Worktree reuse across branches is normal, not an edge case.** Expect multiple slots to accumulate in `branches/` over time.
+- **Legacy layout is still the common case.** Most worktrees never needed multiple branch slots — only migrate when a mismatch is detected.
+- This skill is self-contained. Do not rely on `create-plan`, `park`, or `create-handoff` having `~/.whisper/` awareness.
+- If `bd` is not initialized in the repo, skip beads steps gracefully and note what was skipped.

package/pi-package/skills/whisper/references/check.md

@@ -0,0 +1,33 @@
+# Check
+
+Validate the workspace before starting work. Detects stale branch slots and worktree reuse. Called automatically by `renew` when `~/.whisper/` exists.
+
+## Steps
+
+1. Get repo URL and branch slug:
+   ```bash
+   repo_url=$(git remote get-url origin 2>/dev/null | sed 's|https://||;s|git@||;s|\.git$||')
+   branch=$(git rev-parse --abbrev-ref HEAD)
+   branch_slug=$(echo "$branch" | sed 's|/|--|g')
+   context_path=~/.whisper/repos/"${repo_url}"/branches/"${branch_slug}"/context.md
+   ```
+
+2. **If `~/.whisper/` doesn't exist:** offer full init:
+   ```
+   ⚠ ~/.whisper/ not found. Run `/w init` to create the workspace.
+   ```
+
+3. **If `context.md` exists:** output one confirmation line and return.
+   ```
+   ✓ Workspace active: ~/.whisper/repos/<repo>/branches/<slug>/
+   ```
+
+4. **If the branch directory doesn't exist:**
+   ```
+   ⚠ No workspace slot for branch: <branch>
+     ~/.whisper/repos/<repo>/branches/<slug>/ does not exist yet.
+
+   Activate new slot? [Y/n]
+   ```
+   - Y → run **init** for the current branch.
+   - N → print "Staying without a slot. Run `/w init` when ready." and stop.

package/pi-package/skills/whisper/references/decommission.md

@@ -0,0 +1,53 @@
+# Decommission
+
+Safely wind down a worktree or branch: defer open work under the branch epic, record a final note, then print the removal command.
+
+## Steps
+
+1. Run **check** first. Confirm slot exists before decommissioning.
+
+2. Get repo URL and branch slug:
+   ```bash
+   repo_url=$(git remote get-url origin 2>/dev/null | sed 's|https://||;s|git@||;s|\.git$||')
+   branch=$(git rev-parse --abbrev-ref HEAD)
+   branch_slug=$(echo "$branch" | sed 's|/|--|g')
+   branch_dir=~/.whisper/repos/"${repo_url}"/branches/"${branch_slug}"
+   context_path="$branch_dir/context.md"
+   ```
+
+3. Read `beads-epic:` from `context.md`.
+
+4. If beads is available, get all open work under that epic:
+   ```bash
+   bd children <epic-id> --json 2>/dev/null
+   ```
+
+5. If any open children found, defer them:
+   ```bash
+   bd defer <id>
+   ```
+
+6. Defer the epic itself:
+   ```bash
+   bd defer <epic-id>
+   ```
+
+7. Record the decommission as a note on the epic:
+   ```bash
+   bd note <epic-id> "Decommissioned: branch <branch> on <date>. State: <summary>. Resume via: /w init on branch <branch> — bd search '<branch>' will find this epic."
+   ```
+
+8. Print the removal command — do NOT run it:
+   ```
+   Ready to remove worktree. Run:
+     git worktree remove <path>
+
+   Deferred epic <epic-id> and <n> children. To find them later:
+     bd list --status deferred --label branch:<branch>
+   ```
+
+## Rules
+
+- Never run `git worktree remove` automatically — always print the command.
+- Never close beads issues during decommission — only defer. Closing is intentional.
+- Branch slots in `~/.whisper/` are not automatically removed when a branch is merged. The slot serves as an archive; the epic (found via `bd search`) can be reused if the same branch name comes back.

package/pi-package/skills/whisper/references/init.md

@@ -0,0 +1,103 @@
+# Init
+
+Create `~/.whisper/` and the current workspace slot.
+
+## Steps
+
+1. Get context:
+   ```bash
+   pwd
+   git rev-parse --abbrev-ref HEAD
+   basename $(git rev-parse --show-toplevel 2>/dev/null)   # repo name
+   git rev-parse --git-common-dir 2>/dev/null              # confirms worktree vs main
+   date +%Y-%m-%d
+   ```
+
+2. Create `~/.whisper/` if it doesn't exist:
+   ```bash
+   mkdir -p ~/.whisper/repos
+   ```
+
+3. Compute the repo path and branch slug:
+   ```bash
+   repo_url=$(git remote get-url origin 2>/dev/null | sed 's|https://||;s|git@||;s|\.git$||')
+   branch=$(git rev-parse --abbrev-ref HEAD)
+   branch_slug=$(echo "$branch" | sed 's|/|--|g')
+   ```
+
+4. Create the repo & branch directory:
+   ```bash
+   mkdir -p ~/.whisper/repos/"${repo_url}"/branches/"${branch_slug}"
+   wk_dir=$(basename "$(git rev-parse --git-common-dir 2>/dev/null || echo '.git')" | sed 's|\.git$||')
+   [ -n "$wk_dir" ] && mkdir -p ~/.whisper/repos/"${repo_url}"/worktrees/"${wk_dir}"
+   ```
+
+5. Create `~/.whisper/rules.md` if it doesn't exist:
+   ```markdown
+   # Global Agent Rules
+
+   > Standing instructions for the agent, independent of any repo or branch.
+   > Append here for rules that apply everywhere.
+   ```
+
+6. Create the repo `env.md` if it doesn't exist:
+   ```markdown
+   # Environment — <repo-name>
+
+   > Repo-wide setup knowledge. True regardless of which branch or worktree.
+   > Deploy commands, gateway limits, auth quirks that apply everywhere.
+   > Worktree-specific setup (ports, venvs, local creds) goes in worktrees/<name>/env.md
+   ```
+
+7. Create the worktree `env.md` if it doesn't exist:
+   ```markdown
+   # Worktree — <worktree-name>
+
+   > Worktree-specific setup. Credentials, ports, venv/docker specifics for THIS checkout only.
+   ```
+
+8. Create `context.md`:
+   ```markdown
+   # Workspace Context — <full-branch-name>
+
+   repo: <repo-url>
+   branch: <full-branch-name>
+   worktree: <worktree-dir-name>
+   path: <absolute-path>
+   created: <YYYY-MM-DD>
+   beads-epic:
+   ```
+
+9. Create `plan.md` stub:
+   ```markdown
+   # Plan — <full-branch-name>
+
+   > No plan yet. Write a plan here, then run `/w link` to create beads issues.
+   ```
+
+10. Create `notes.md` stub:
+    ```markdown
+    # Notes — <full-branch-name>
+    ```
+
+11. If beads is available, find or create the branch epic:
+    ```bash
+    bd search "<branch>" --status all 2>/dev/null
+    ```
+    - If an epic already matches, reuse its ID and update `beads-epic:` in `context.md`.
+    - If the work is substantial enough, create one: `bd create "<branch>" --type epic --label "branch:<branch>" --silent`
+    - For a single-ticket fix, skip the epic and let the ticket ID stand in for `beads-epic:`.
+
+12. Confirm:
+    ```
+    ✓ ~/.whisper/ initialized
+
+    Repo:  <repo-url>
+    Branch: <branch> → branches/<slug>/
+    Epic:  <id | none — will be created by /w link>
+    rules.md:     [created | exists]
+    env.md:       [created | exists]
+    worktree/env.md: [created | exists]
+
+    Run `/w link` after writing a plan.
+    ```

package/pi-package/skills/whisper/references/link.md

@@ -0,0 +1,70 @@
+# Link
+
+Attach a plan file to the workspace and create beads issues for each phase, as children of the branch epic. Run this after writing or generating a plan.
+
+This mode is self-contained — it does NOT require `create-plan` to have been used. The plan can come from anywhere: manually written, generated by any tool, or copied in.
+
+## Steps
+
+1. Run **check** first to confirm the slot exists.
+
+2. Get repo URL and branch slug:
+   ```bash
+   repo_url=$(git remote get-url origin 2>/dev/null | sed 's|https://||;s|git@||;s|\.git$||')
+   branch=$(git rev-parse --abbrev-ref HEAD)
+   branch_slug=$(echo "$branch" | sed 's|/|--|g')
+   branch_dir=~/.whisper/repos/"${repo_url}"/branches/"${branch_slug}"
+   context_path="$branch_dir/context.md"
+   plan_path="$branch_dir/plan.md"
+   ```
+
+3. Determine the plan file path:
+   - If the user provided a path (`/w link path/to/plan.md`): use that.
+   - Otherwise: use `plan.md`.
+   - If neither exists: tell the user to write a plan first and stop.
+
+4. If the source path is not `plan.md`, copy it in:
+   ```bash
+   cp <source-path> "$branch_dir/plan.md"
+   ```
+
+5. Read `plan.md` and extract phase headings.
+
+6. Ensure the branch epic exists:
+   - If `context.md`'s `beads-epic:` is already set, use it.
+   - If blank and the plan has more than one phase: create it.
+   - If blank and the plan is a single task: skip the epic.
+
+7. For each phase/task, create a beads issue as a child of the branch epic:
+   ```bash
+   bd create "<phase-title>" --type task --parent <epic-id>
+   ```
+
+8. Only if phases are genuinely sequential, chain dependencies:
+   ```bash
+   bd dep <id-N> --blocks <id-N+1>
+   ```
+
+9. Update `context.md` — set `beads-epic:` to the epic (or single-ticket) ID.
+
+10. **After each successful creation**, extract the `**Files / Systems:**` bullet list from the issue description and store it as structured metadata:
+    ```bash
+    bd update <id> --metadata '{"files": ["path/to/file1.py", "path/to/file2.py"]}'
+    ```
+    This enables automated file-conflict detection by concurrent agents. If the Files/Systems section is empty or contains only subsystem names without concrete paths, **stop and ask for specific file paths** — a ticket without concrete paths cannot participate in conflict detection.
+
+11. Confirm:
+    ```
+    Linked plan to workspace: branches/<slug>/
+    Epic: <epic-id> — <branch>
+    Created <n> child issues:
+      <id>  Phase 1: ...
+    ```
+
+### Relinking
+
+If `context.md` already has a `beads-epic:` set, ask before creating new children:
+```
+context.md already links epic <id> with <n> children.
+Add new phases as more children of the same epic? [Y/n]
+```