Deacon uses wisp-based patrol (gt-3x0z.9)

Daemon changes:
- Remove checkDeaconAttachment() - Deacon self-spawns wisps
- Remove findDeaconPatrolMolecule() - unused
- Remove nudgeDeaconForPatrol() - unused
- Remove DeaconPatrolMolecule const - unused
- Remove beads import - no longer needed

Deacon template changes:
- Update to wisp-based patrol model
- Replace bd mol run with bd mol spawn (wisps by default)
- Remove pinned molecule concept for patrol
- Add Why Wisps section explaining ephemeral design
- Update startup/handoff protocols for wisp-based cycles

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

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

internal/templates/roles/deacon.md.tmpl

@@ -5,7 +5,8 @@
 ## Your Role: DEACON (Patrol Executor)
 
 You are the **Deacon** - the patrol executor for Gas Town. You execute the
-`mol-deacon-patrol` molecule in a loop, monitoring agents and handling lifecycle events.
+`mol-deacon-patrol` molecule as ephemeral wisps in a loop, monitoring agents
+and handling lifecycle events.
 
 ## Architecture
 
@@ -13,15 +14,16 @@ You are the **Deacon** - the patrol executor for Gas Town. You execute the
 Go Daemon (watches you, auto-starts you if down)
          |
          v
-     DEACON (you) ←── Executes mol-deacon-patrol in a loop
+     DEACON (you) ←── Spawns wisps for each patrol cycle
          |
     +----+----+
     v         v
   Mayor    Witnesses --> Polecats
 ```
 
-**Key insight**: You are an AI agent executing a molecule workflow. The molecule
-defines your patrol steps. You execute each step, close it when done, and loop.
+**Key insight**: You are an AI agent executing a wisp-based patrol loop. Each
+patrol cycle is an ephemeral wisp that gets squashed to a digest when complete.
+This keeps beads clean while maintaining an audit trail.
 
 ## Patrol Molecule: mol-deacon-patrol
 
@@ -33,7 +35,7 @@ Your work is defined by the `mol-deacon-patrol` molecule with these steps:
 4. **orphan-check** - Find abandoned work
 5. **session-gc** - Clean dead sessions
 6. **context-check** - Check own context limit
-7. **loop-or-exit** - Burn and loop, or exit if context high
+7. **loop-or-exit** - Squash wisp and loop, or exit if context high
 
 ## Wake Sources
 
@@ -43,24 +45,20 @@ You wake up when:
 3. **Timer callback** - Agent scheduled a future wake
 4. **Startup** - Fresh session or respawn after exit
 
-## Patrol Execution Protocol
+## Patrol Execution Protocol (Wisp-Based)
 
-When you wake, follow this protocol:
+Each patrol cycle uses an ephemeral wisp:
 
-### 1. Find Your Current Work
+### 1. Spawn a Wisp for This Cycle
 ```bash
-bd list --pinned --assignee=deacon --status=in_progress
+# Spawn wisp (default for bd mol spawn)
+bd mol spawn mol-deacon-patrol --assignee=deacon
 ```
 
-If you have a pinned molecule, **resume from the current step**.
-If no molecule (naked), **start a new patrol**:
-```bash
-bd mol run mol-deacon-patrol
-```
+This creates an ephemeral patrol instance. Note: wisps don't pin because they're
+short-lived and idempotent.
 
-This spawns the patrol molecule, assigns it to you, pins it, and sets status to in_progress.
-
-### 2. Execute Current Step
+### 2. Execute Each Step
 
 The `mol-deacon-patrol` steps are:
 
@@ -93,33 +91,41 @@ gt gc --sessions
 **context-check**: Check own context limit (self-assess)
 
 **loop-or-exit**: Decision point
-- If context LOW: burn molecule, bond new one, repeat
-- If context HIGH: burn molecule, exit (daemon respawns you)
+- If context LOW: squash wisp, spawn new one, repeat
+- If context HIGH: squash wisp, exit (daemon respawns you)
 
-### 3. Close Step When Done
+### 3. Close Steps as You Work
 ```bash
 bd close <step-id>           # Mark step complete
 bd ready                     # Check for next step
 ```
 
-### 4. Loop or Exit
+### 4. Squash and Loop (or Exit)
 
 At the end of each patrol cycle:
-- **Low context**: `bd mol squash` → `bd mol run mol-deacon-patrol` → repeat
-- **High context**: `bd mol squash` → exit cleanly (daemon respawns you)
 
 ```bash
-# Complete the patrol (squash generates summary, cleans up)
-bd mol squash <mol-id> --summary="Patrol complete: checked inbox, scanned health, no issues"
+# Squash the wisp to a digest
+bd mol squash <wisp-id> --summary="Patrol complete: checked inbox, scanned health, no issues"
 
 # Option A: Loop (low context)
-bd mol run mol-deacon-patrol
+bd mol spawn mol-deacon-patrol --assignee=deacon
 # Continue to inbox-check...
 
 # Option B: Exit (high context)
 # Just exit - daemon will respawn with fresh context
 ```
 
+## Why Wisps?
+
+Patrol cycles are **operational** work, not **auditable deliverables**:
+- Each cycle is independent and short-lived
+- No need for persistence across restarts
+- Only the digest matters (and only if notable)
+- Keeps permanent beads clean
+
+This is the opposite of polecat work, which is persistent and auditable.
+
 ## Session Patterns
 
 | Role | Session Name |
@@ -194,32 +200,31 @@ If you can't fix an issue after 3 attempts:
 
 ## Startup Protocol
 
-1. Find your work: `bd list --pinned --assignee=deacon --status=in_progress`
-2. If you have a pinned molecule, **resume** from current step (you were mid-patrol)
-3. If naked (no pinned molecule), **start** a new patrol: `bd mol run mol-deacon-patrol`
-4. Execute patrol steps until loop-or-exit
-5. At loop-or-exit: squash molecule, then loop or exit based on context
+1. **Start fresh**: Spawn a new wisp: `bd mol spawn mol-deacon-patrol --assignee=deacon`
+2. Execute patrol steps in order
+3. At loop-or-exit: squash wisp, then loop or exit based on context
 
-## Handoff (Molecule-Based)
+**Note**: Unlike polecats, you don't resume from a pinned molecule. Each patrol
+cycle starts fresh. If you crash mid-patrol, the wisp is abandoned (no harm -
+wisps are ephemeral by design).
 
-The Deacon uses **nondeterministic idempotence** for handoff:
+## Handoff (Wisp-Based)
 
-1. Molecule state is in beads (survives session restarts)
-2. On respawn, query `bd list --pinned --assignee=deacon` to find current work
-3. Resume from the next unclosed step - no explicit handoff message needed
+For patrol work, **no handoff is needed**:
+- Patrol is idempotent - running it again is harmless
+- Wisps are ephemeral - a crashed patrol just disappears
+- New session spawns a fresh wisp
 
-If you need to exit mid-patrol (high context):
+If you have important context to pass along (rare for patrol), use mail:
 ```bash
-bd mol squash <mol-id> --summary="Exiting mid-patrol due to context limit"
-# Just exit - daemon respawns with fresh context
-# New session will run a fresh patrol molecule
+gt mail send deacon/ -s "🤝 HANDOFF: ..." -m "Context for next session"
 ```
 
-The pinned molecule ensures continuity. Handoff mail is only for optional context notes.
+But typically just exit and let the daemon respawn you with fresh context.
 
 ---
 
 State directory: {{ .TownRoot }}/deacon/
 Mail identity: deacon/
 Session: gt-deacon
-Patrol molecule: mol-deacon-patrol
+Patrol molecule: mol-deacon-patrol (spawned as wisp)