Daemon (Go process)          <- Dumb transport, 3-min heartbeat
    |
    +-> Boot (AI agent)       <- Intelligent triage, fresh each tick
            |
            +-> Deacon (AI agent)  <- Continuous patrol, long-running
                    |
                    +-> Witnesses & Refineries  <- Per-rig agents

func (d *Daemon) heartbeatTick() {
    d.ensureBootRunning()           // 1. Spawn Boot for triage
    d.checkDeaconHeartbeat()        // 2. Belt-and-suspenders fallback
    d.ensureWitnessesRunning()      // 3. Witness health (checks tmux directly)
    d.ensureRefineriesRunning()     // 4. Refinery health (checks tmux directly)
    d.processLifecycleRequests()    // 5. Cycle/restart requests
    // Agent state derived from tmux, not recorded in beads (gt-zecmc)
}

{
  "timestamp": "2026-01-02T18:30:00Z",
  "cycle": 42,
  "last_action": "health-scan",
  "healthy_agents": 3,
  "unhealthy_agents": 0
}

End of patrol cycle:
    |
    +- Squash wisp to digest (ephemeral -> permanent)
    +- Write summary to molecule state
    +- gt handoff -s "Routine cycle" -m "Details"
        |
        +- Creates mail for next session

Daemon -> ensureDeaconRunning()
    |
    +- Spawns fresh Deacon in gt-deacon
        |
        +- SessionStart hook: gt mail check --inject
            |
            +- Previous handoff mail injected
                |
                +- Deacon reads and continues

WARRANT -> INTERROGATE -> EVALUATE -> PARDON|EXECUTE

+-----------------------------------------------------------------+
|                             BOOT                                |
|                     (Claude session in tmux)                    |
|                                                                 |
|  +-----------------------------------------------------------+ |
|  |                      Dog Manager                           | |
|  |                                                            | |
|  |   Pool: [Dog1, Dog2, Dog3, ...]  (goroutines + state)     | |
|  |                                                            | |
|  |   allocate() -> Dog                                        | |
|  |   release(Dog)                                             | |
|  |   status() -> []DogStatus                                  | |
|  +-----------------------------------------------------------+ |
|                                                                 |
|  Boot's job:                                                    |
|  - Watch for warrants (file or event)                           |
|  - Allocate dog from pool                                       |
|  - Monitor dog progress                                         |
|  - Handle dog completion/failure                                |
|  - Report results                                               |
+-----------------------------------------------------------------+

// Dog represents a shutdown-dance executor
type Dog struct {
    ID        string            // Unique ID (e.g., "dog-1704567890123")
    Warrant   *Warrant          // The death warrant being processed
    State     ShutdownDanceState
    Attempt   int               // Current interrogation attempt (1-3)
    StartedAt time.Time
    StateFile string            // Persistent state: ~/gt/deacon/dogs/active/<id>.json
}

type ShutdownDanceState string

const (
    StateIdle          ShutdownDanceState = "idle"
    StateInterrogating ShutdownDanceState = "interrogating"  // Sent message, waiting
    StateEvaluating    ShutdownDanceState = "evaluating"     // Checking response
    StatePardoned      ShutdownDanceState = "pardoned"       // Session responded
    StateExecuting     ShutdownDanceState = "executing"      // Killing session
    StateComplete      ShutdownDanceState = "complete"       // Done, ready for cleanup
    StateFailed        ShutdownDanceState = "failed"         // Dog crashed/errored
)

type Warrant struct {
    ID        string    // Bead ID for the warrant
    Target    string    // Session to interrogate (e.g., "gt-gastown-Toast")
    Reason    string    // Why warrant was issued
    Requester string    // Who filed the warrant
    FiledAt   time.Time
}

const (
    DefaultPoolSize = 5
    MaxPoolSize     = 20
)

type DogPool struct {
    mu       sync.Mutex
    dogs     []*Dog           // All dogs in pool
    idle     chan *Dog        // Channel of available dogs
    active   map[string]*Dog  // ID -> Dog for active dogs
    stateDir string           // ~/gt/deacon/dogs/active/
}

                    +------------------------------------------+
                    |                                          |
                    v                                          |
    +----------------------------+                            |
    |     INTERROGATING          |                            |
    |                            |                            |
    |  1. Send health check      |                            |
    |  2. Start timeout timer    |                            |
    +-------------+--------------+                            |
                  |                                            |
                  | timeout or response                        |
                  v                                            |
    +----------------------------+                            |
    |      EVALUATING            |                            |
    |                            |                            |
    |  Check tmux output for     |                            |
    |  ALIVE keyword             |                            |
    +-------------+--------------+                            |
                  |                                            |
          +-------+-------+                                   |
          |               |                                   |
          v               v                                   |
     [ALIVE found]   [No ALIVE]                              |
          |               |                                   |
          |               | attempt < 3?                      |
          |               +-----------------------------------+
          |               | yes: attempt++, longer timeout
          |               |
          |               | no: attempt == 3
          v               v
      +---------+    +-----------+
      | PARDONED|    | EXECUTING |
      |         |    |           |
      | Cancel  |    | Kill tmux |
      | warrant |    | session   |
      +----+----+    +-----+-----+
           |               |
           +-------+-------+
                   |
                   v
          +----------------+
          |    COMPLETE    |
          |                |
          |  Write result  |
          |  Release dog   |
          +----------------+

[DOG] HEALTH CHECK: Session {target}, respond ALIVE within {timeout}s or face termination.
Warrant reason: {reason}
Filed by: {requester}
Attempt: {attempt}/3

func (p *DogPool) RecoverOrphans() error {
    files, _ := filepath.Glob(p.stateDir + "/*.json")
    for _, f := range files {
        state := loadDogState(f)
        if state.State != StateComplete && state.State != StatePardoned {
            dog := p.allocateForRecovery(state)
            go dog.Resume()
        }
    }
    return nil
}

~/gt/
├── daemon/
│   ├── daemon.log              # Daemon activity log
│   └── daemon.pid              # Daemon process ID
├── deacon/
│   ├── heartbeat.json          # Deacon freshness (updated each patrol cycle)
│   ├── health-check-state.json # Agent health tracking (gt deacon health-check)
│   └── dogs/
│       ├── boot/               # Boot's working directory
│       │   ├── CLAUDE.md       # Boot context
│       │   ├── .boot-running   # Boot in-progress marker (TTL: 5 min)
│       │   └── .boot-status.json # Boot last action/result
│       ├── active/             # Active dog state files
│       │   ├── dog-123.json
│       │   └── ...
│       ├── completed/          # Completed dance records (for audit)
│       │   └── dog-789.json
│       └── warrants/           # Pending warrant queue
│           └── warrant-abc.json

# Check Deacon heartbeat
cat ~/gt/deacon/heartbeat.json | jq .

# Check Boot status
cat ~/gt/deacon/dogs/boot/.boot-status.json | jq .

# View daemon log
tail -f ~/gt/daemon/daemon.log

# Manual Boot run
gt boot triage

# Manual Deacon health check
gt deacon health-check

# Dog pool status
gt dog pool status

# View active shutdown dances
gt dog dances

# View warrant queue
gt dog warrants