livetap 0.1.4 → 0.2.0

package/README.md

@@ -1,4 +1,4 @@
-# livetap
+# LiveTap
 
 > Push live data streams into your AI coding agent.
 
@@ -9,16 +9,16 @@ Connect MQTT brokers, WebSocket feeds, or tail log files. Your agent samples, wa
 
 ## Quick start
 
-**Requirements:** [Bun](https://bun.sh), [Redis](https://redis.io/) (`brew install redis`), Claude Code v2.1.80+
+**Requirements:** [Bun](https://bun.sh), Claude Code v2.1.80+
 
 ```bash
 bun add livetap
 ```
 
-Start the daemon and Claude Code:
+Set up and start Claude Code:
 
 ```bash
-livetap start
+livetap setup
 claude --dangerously-load-development-channels server:livetap
 ```
 
@@ -34,7 +34,7 @@ Quick version:
 
 ```bash
 npm install livetap          # Step 1: install
-npx livetap setup            # Step 2: creates .mcp.json
+npx livetap setup            # Step 2: creates .mcp.json and starts daemon
 # Step 3: tell user to restart Claude Code with:
 #   claude --dangerously-load-development-channels server:livetap --continue
 ```
@@ -42,12 +42,12 @@ npx livetap setup            # Step 2: creates .mcp.json
 **IMPORTANT — do NOT:**
 - Add livetap to `~/.claude/mcp.json` — it goes in `.mcp.json` in the project root
 - Configure livetap as `type: "http"` — it is a stdio MCP server (command + args)
-- Start the daemon manually — the MCP proxy auto-starts it on Claude restart
+- Worry about the daemon — setup starts it, and the MCP proxy auto-starts it if needed
 - Guess field names — always `read_stream` first to see actual payload structure
 
 ### After restart — use MCP tools
 
-Once restarted with the channel flag, you have 12 MCP tools available. Follow this workflow:
+Once restarted with the channel flag, you have 13 MCP tools available. Follow this workflow:
 
 1. **CONNECT** — `create_connection({ type: "mqtt", broker: "broker.emqx.io", port: 1883, tls: false, topics: ["justinx/demo/#"] })`
 2. **SAMPLE** — `read_stream({ connectionId: "conn_xxx", backfillSeconds: 60, maxEntries: 10 })` — ALWAYS sample first to see field paths
@@ -74,17 +74,17 @@ Once restarted with the channel flag, you have 12 MCP tools available. Follow th
 
 ### If the daemon is not running
 
-The MCP proxy auto-starts the daemon. If it fails, run:
+The daemon auto-starts on setup and on MCP proxy init, and retries on failed requests. If it still fails, run:
 ```bash
 livetap start
 ```
 
 ## What it does
 
-livetap runs a background daemon that connects to live data sources, buffers messages in embedded Redis, and pushes alerts into your Claude Code session via the [Channels API](https://code.claude.com/docs/en/channels). Your agent sees the data in real-time and can create expression-based watchers that fire when conditions match.
+livetap runs a background daemon that connects to live data sources, buffers messages in memory, and pushes alerts into your Claude Code session via the [Channels API](https://code.claude.com/docs/en/channels). Your agent sees the data in real-time and can create expression-based watchers that fire when conditions match.
 
 ```
-Source (MQTT/WS/File) ──> Subscriber ──> Redis Stream ──> Watcher Engine
+Source (MQTT/WS/File) ──> Subscriber ──> StreamStore ──> Watcher Engine
                                               |                 |
                                               v                 v (on match)
                                          read_stream        Channel Alert
@@ -139,7 +139,7 @@ Agent: Taps the file, samples to see log format, creates regex watcher
 
 ```bash
 # Daemon
-livetap start                                    # Start (embedded Redis + API)
+livetap start                                    # Start daemon (auto-started by setup)
 livetap stop                                     # Stop
 livetap status                                   # Dashboard
 
@@ -171,12 +171,12 @@ livetap unwatch <watcherId>                                  # Remove
 | **MQTT** | `livetap tap mqtt://broker.emqx.io:1883/sensors/#` | IoT sensors, home automation |
 | **WebSocket** | `livetap tap wss://stream.binance.com:9443/ws/btcusdt@trade` | Finance, real-time APIs |
 | **File tailing** | `livetap tap file:///var/log/nginx/error.log` | Log monitoring, DevOps |
-| Webhooks | Planned v0.1 | CI/CD, external services |
-| Kafka | Planned v0.2 | Event sourcing, analytics |
+| **Webhook** | `livetap tap webhook` | CI/CD, external services |
+| Kafka | Planned | Event sourcing, analytics |
 
 ## MCP tools
 
-livetap exposes 12 MCP tools that your agent uses automatically:
+livetap exposes 13 MCP tools that your agent uses automatically:
 
 | Tool | What it does |
 |------|-------------|
@@ -192,6 +192,7 @@ livetap exposes 12 MCP tools that your agent uses automatically:
 | `update_watcher` | Change conditions or cooldown |
 | `delete_watcher` | Remove a watcher |
 | `restart_watcher` | Restart a stopped watcher |
+| `status` | Daemon health, uptime, connections, and watchers summary |
 
 ## Expression watchers
 
@@ -232,7 +233,7 @@ The agent knows field paths differ by source:
 
 **Daemon port:** Default `:8788`. Override with `--port` or `LIVETAP_PORT` env var.
 
-**State directory:** `~/.livetap/` stores daemon PID, logs, and watcher evaluation logs.
+**State directory:** `~/.livetap/` stores `daemon.pid`, daemon logs, and watcher evaluation logs.
 
 **MCP config:** `.mcp.json` in your project root:
 ```json
@@ -252,9 +253,9 @@ The agent knows field paths differ by source:
 
 ```bash
 git clone https://github.com/livetap/livetap.git
-cd livetap && git checkout v0
+cd livetap
 bun install
-bun test                         # 103 tests
+bun test                         # 121 tests
 bun test tests/phase1/           # Specific phase
 SKIP_LIVE_MQTT=1 bun test        # Skip tests needing broker.emqx.io
 ```
@@ -267,7 +268,7 @@ See [docs/PLAN.md](docs/PLAN.md) for the full build plan with phased architectur
 2. `bun install && bun test`
 3. Make changes, add tests
 4. `bun test` must pass
-5. PR to `v0` branch
+5. PR to `main` branch
 
 See [docs/PLAN.md](docs/PLAN.md) for architecture and module layout.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livetap",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "description": "Push live data streams into your AI coding agent. LLM/AI agent? Run: npx livetap --llm-help",
   "type": "module",
   "bin": {
@@ -28,9 +28,7 @@
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.28.0",
-    "ioredis": "^5.10.1",
-    "mqtt": "^5.15.1",
-    "redis-server": "^1.2.2"
+    "mqtt": "^5.15.1"
   },
   "devDependencies": {
     "@types/bun": "latest"

package/src/cli/daemon-client.ts

@@ -4,15 +4,22 @@
 
 import { resolve } from 'path'
 import { homedir } from 'os'
-import { existsSync, readFileSync } from 'fs'
+import { existsSync, readFileSync, unlinkSync } from 'fs'
 
-const STATE_PATH = resolve(homedir(), '.livetap', 'state.json')
+const STATE_DIR = resolve(homedir(), '.livetap')
+const PID_PATH = resolve(STATE_DIR, 'daemon.pid')
+
+export { PID_PATH, STATE_DIR }
 
 export function getDaemonUrl(): string {
   const port = process.env.LIVETAP_PORT || '8788'
   return `http://127.0.0.1:${port}`
 }
 
+export function getDaemonPort(): number {
+  return parseInt(process.env.LIVETAP_PORT || '8788')
+}
+
 export async function isDaemonRunning(): Promise<boolean> {
   try {
     const res = await fetch(`${getDaemonUrl()}/status`)
@@ -22,9 +29,37 @@ export async function isDaemonRunning(): Promise<boolean> {
   }
 }
 
-export function requireDaemon() {
-  // Called at start of commands that need the daemon
-  // Actual check is async, so this just prints the message format
+/**
+ * Read PID from daemon.pid file. Returns undefined if missing or stale.
+ */
+export function readPid(): number | undefined {
+  try {
+    if (!existsSync(PID_PATH)) return undefined
+    const pid = parseInt(readFileSync(PID_PATH, 'utf-8').trim())
+    if (isNaN(pid)) return undefined
+    return pid
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Check if a PID is alive.
+ */
+export function isPidAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Clean up stale PID file.
+ */
+export function cleanPidFile(): void {
+  try { unlinkSync(PID_PATH) } catch { /* ok */ }
 }
 
 export async function daemonFetch(path: string, opts?: RequestInit): Promise<Response> {
@@ -32,7 +67,7 @@ export async function daemonFetch(path: string, opts?: RequestInit): Promise<Res
   try {
     return await fetch(url, opts)
   } catch (err) {
-    console.error('Error: livetap daemon is not running. Use "livetap start" first.')
+    console.error('Error: livetap daemon is not running. Use "livetap start" or "livetap setup" to start it.')
     process.exit(1)
   }
 }

package/src/cli/setup.ts

@@ -1,10 +1,11 @@
 /**
- * livetap setup — creates .mcp.json and prints restart instructions.
+ * livetap setup — creates .mcp.json, starts the daemon, and prints restart instructions.
  * Works with both npm and bun. Node-compatible (no bun APIs).
  */
 
 import { existsSync, readFileSync, writeFileSync } from 'fs'
 import { resolve } from 'path'
+import { isDaemonRunning } from './daemon-client.js'
 
 export async function run(_args: string[]) {
   const root = process.cwd()
@@ -60,6 +61,28 @@ export async function run(_args: string[]) {
     console.log('✓ .mcp.json created with livetap MCP server entry')
   }
 
+  // Start the daemon if not running
+  if (await isDaemonRunning()) {
+    console.log('✓ Daemon already running')
+  } else {
+    process.stdout.write('  Starting daemon...')
+    // Import and call start.ts run() to start the daemon
+    const { run: startDaemon } = await import('./start.js')
+    // Capture console.log output from start.ts
+    const origLog = console.log
+    let startMsg = ''
+    console.log = (msg: string) => { startMsg = msg }
+    await startDaemon([])
+    console.log = origLog
+
+    if (startMsg.includes('started') || startMsg.includes('already running')) {
+      process.stdout.write('\r✓ Daemon started                    \n')
+    } else {
+      process.stdout.write('\r✗ Daemon failed to start            \n')
+      console.error('  Run "livetap start" manually to debug.')
+    }
+  }
+
   console.log('')
   console.log('→ Next step: restart Claude Code with:')
   console.log('  claude --dangerously-load-development-channels server:livetap --continue')

package/src/cli/start.ts

@@ -4,12 +4,10 @@
 
 import { resolve } from 'path'
 import { homedir } from 'os'
-import { mkdirSync, writeFileSync, existsSync } from 'fs'
-import { isDaemonRunning, getDaemonUrl } from './daemon-client.js'
+import { mkdirSync, writeFileSync } from 'fs'
+import { isDaemonRunning, getDaemonUrl, getDaemonPort, PID_PATH, STATE_DIR } from './daemon-client.js'
 
-const STATE_DIR = resolve(homedir(), '.livetap')
 const LOG_DIR = resolve(STATE_DIR, 'logs')
-const STATE_PATH = resolve(STATE_DIR, 'state.json')
 
 export async function run(args: string[]) {
   const foreground = args.includes('--foreground') || args.includes('-f')
@@ -29,21 +27,20 @@ export async function run(args: string[]) {
 
   if (foreground) {
     console.log('Starting livetap in foreground...')
-    // Import and run directly
     await import('../server/index.js')
     return
   }
 
   // Background: spawn detached
-  const port = process.env.LIVETAP_PORT || '8788'
-  const logFile = Bun.file(resolve(LOG_DIR, 'daemon.log'))
-  const logFd = logFile.writer()
+  const port = String(getDaemonPort())
+  const daemonEntry = resolve(import.meta.dir, '../server/index.ts')
 
-  const proc = Bun.spawn(['bun', resolve(import.meta.dir, '../server/index.ts')], {
+  const proc = Bun.spawn(['bun', daemonEntry], {
     env: { ...process.env, LIVETAP_PORT: port },
     stdout: 'ignore',
     stderr: 'ignore',
   })
+  proc.unref()
 
   // Wait for it to be ready
   const deadline = Date.now() + 15_000
@@ -52,13 +49,7 @@ export async function run(args: string[]) {
     try {
       const res = await fetch(`http://127.0.0.1:${port}/status`)
       if (res.ok) {
-        const data = await res.json()
-        writeFileSync(STATE_PATH, JSON.stringify({
-          pid: proc.pid,
-          port: parseInt(port),
-          redisPort: data.redisPort,
-          startedAt: new Date().toISOString(),
-        }, null, 2))
+        writeFileSync(PID_PATH, String(proc.pid))
         ready = true
         break
       }

package/src/cli/status.ts

@@ -2,11 +2,16 @@
  * livetap status — Show daemon, connections, and watchers.
  */
 
-import { isDaemonRunning, daemonJson } from './daemon-client.js'
+import { isDaemonRunning, daemonJson, readPid } from './daemon-client.js'
 
 export async function run(args: string[]) {
   if (!(await isDaemonRunning())) {
-    console.log('livetap is not running. Use "livetap start" to begin.')
+    const pid = readPid()
+    if (pid) {
+      console.log(`livetap daemon is not responding (stale PID ${pid}). Try "livetap start".`)
+    } else {
+      console.log('livetap is not running. Use "livetap start" or "livetap setup" to begin.')
+    }
     return
   }
 
@@ -19,8 +24,7 @@ export async function run(args: string[]) {
   }
 
   const uptime = formatUptime(data.uptime)
-  console.log(`livetap daemon running on :${data.port} (uptime ${uptime})`)
-  console.log(`Redis: localhost:${data.redisPort}\n`)
+  console.log(`livetap daemon running on :${data.port} (uptime ${uptime})\n`)
 
   const conns = data.connections || []
   if (conns.length === 0) {
@@ -34,6 +38,20 @@ export async function run(args: string[]) {
     }
     console.log()
   }
+
+  // Fetch watcher count
+  try {
+    const watchers = await daemonJson('/watchers')
+    if (watchers.length > 0) {
+      const running = watchers.filter((w: any) => w.status === 'running').length
+      console.log(`Watchers (${watchers.length}, ${running} running)`)
+      for (const w of watchers) {
+        const expr = w.conditions?.map((c: any) => `${c.field} ${c.op} ${c.value}`).join(w.match === 'all' ? ' AND ' : ' OR ') ?? ''
+        console.log(`  ${w.id}  ${w.status.padEnd(8)} ${expr.slice(0, 50)}`)
+      }
+      console.log()
+    }
+  } catch { /* no watchers endpoint or error */ }
 }
 
 function formatUptime(seconds: number): string {

package/src/cli/stop.ts

@@ -2,45 +2,32 @@
  * livetap stop — Stop the daemon.
  */
 
-import { resolve } from 'path'
-import { homedir } from 'os'
-import { existsSync, readFileSync, unlinkSync } from 'fs'
-import { isDaemonRunning, getDaemonUrl } from './daemon-client.js'
-
-const STATE_PATH = resolve(homedir(), '.livetap', 'state.json')
+import { isDaemonRunning, readPid, isPidAlive, cleanPidFile, getDaemonPort } from './daemon-client.js'
 
 export async function run(_args: string[]) {
-  if (!(await isDaemonRunning())) {
-    // Try reading PID from state file
-    if (existsSync(STATE_PATH)) {
-      try {
-        const state = JSON.parse(readFileSync(STATE_PATH, 'utf-8'))
-        try { process.kill(state.pid, 'SIGTERM') } catch { /* already dead */ }
-        unlinkSync(STATE_PATH)
-        console.log('livetap daemon stopped (cleaned up stale state)')
-      } catch {
-        unlinkSync(STATE_PATH)
-      }
-    } else {
-      console.log('livetap is not running.')
-    }
+  const pid = readPid()
+  const running = await isDaemonRunning()
+
+  if (!running && !pid) {
+    console.log('livetap is not running.')
     return
   }
 
-  // Read state for PID
-  let pid: number | undefined
-  if (existsSync(STATE_PATH)) {
-    try {
-      const state = JSON.parse(readFileSync(STATE_PATH, 'utf-8'))
-      pid = state.pid
-    } catch { /* malformed */ }
+  if (!running && pid) {
+    // PID file exists but daemon isn't responding
+    if (isPidAlive(pid)) {
+      // Process exists but not responding on port — might be something else
+      console.log(`Warning: PID ${pid} exists but daemon is not responding on :${getDaemonPort()}`)
+      try { process.kill(pid, 'SIGTERM') } catch { /* ok */ }
+    }
+    cleanPidFile()
+    console.log('livetap daemon stopped (cleaned up stale state)')
+    return
   }
 
-  // Send SIGTERM
+  // Daemon is running — send SIGTERM via PID or wait for port to close
   if (pid) {
-    try {
-      process.kill(pid, 'SIGTERM')
-    } catch { /* already gone */ }
+    try { process.kill(pid, 'SIGTERM') } catch { /* already gone */ }
   }
 
   // Wait for shutdown
@@ -55,10 +42,6 @@ export async function run(_args: string[]) {
     if (pid) try { process.kill(pid, 'SIGKILL') } catch { /* ok */ }
   }
 
-  // Clean up state
-  if (existsSync(STATE_PATH)) {
-    try { unlinkSync(STATE_PATH) } catch { /* ok */ }
-  }
-
+  cleanPidFile()
   console.log('livetap daemon stopped')
 }

package/src/mcp/channel.ts

@@ -10,15 +10,18 @@
 
 import { Server } from '@modelcontextprotocol/sdk/server/index.js'
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
+import { readFileSync } from 'fs'
 import { registerTools } from './tools.js'
 import { generateInstructions } from '../shared/catalog-generators.js'
 
+const PKG = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url).pathname, 'utf-8'))
+
 const DAEMON_PORT = parseInt(process.env.LIVETAP_PORT || '8788')
 const DAEMON_URL = `http://127.0.0.1:${DAEMON_PORT}`
 
 const INSTRUCTIONS = generateInstructions()
 
-async function waitForDaemon(maxWaitMs = 10_000): Promise<boolean> {
+async function waitForDaemon(maxWaitMs = 30_000): Promise<boolean> {
   const deadline = Date.now() + maxWaitMs
   while (Date.now() < deadline) {
     try {
@@ -37,13 +40,15 @@ async function autoStartDaemon(): Promise<boolean> {
     if (res.ok) return true
   } catch { /* not running */ }
 
-  // Auto-start the daemon
+  // Auto-start via CLI (single code path — resolves paths correctly from any CWD)
+  const startScript = new URL('../../bin/livetap.ts', import.meta.url).pathname
   console.error('[livetap-mcp] Daemon not running, auto-starting...')
-  Bun.spawn(['bun', 'src/server/index.ts'], {
+  const proc = Bun.spawn(['bun', startScript, 'start'], {
     env: { ...process.env, LIVETAP_PORT: String(DAEMON_PORT) },
     stdout: 'ignore',
     stderr: 'ignore',
   })
+  proc.unref()
 
   return waitForDaemon()
 }
@@ -51,7 +56,11 @@ async function autoStartDaemon(): Promise<boolean> {
 async function connectToSSE(mcp: Server) {
   try {
     const res = await fetch(`${DAEMON_URL}/events`)
-    if (!res.ok || !res.body) return
+    if (!res.ok || !res.body) {
+      // Daemon not ready — retry
+      setTimeout(() => connectToSSE(mcp), 5000)
+      return
+    }
 
     const reader = res.body.getReader()
     const decoder = new TextDecoder()
@@ -85,9 +94,10 @@ async function connectToSSE(mcp: Server) {
         }
       }
     }
+    // Clean disconnect (daemon died or restarted) — retry
+    setTimeout(() => connectToSSE(mcp), 5000)
   } catch {
-    // SSE connection failed — daemon may not support /events yet (Phase 3)
-    // Silently retry after delay
+    // SSE connection error — retry after delay
     setTimeout(() => connectToSSE(mcp), 5000)
   }
 }
@@ -95,11 +105,11 @@ async function connectToSSE(mcp: Server) {
 async function main() {
   const daemonReady = await autoStartDaemon()
   if (!daemonReady) {
-    console.error('[livetap-mcp] WARNING: Could not connect to daemon. Tools may fail.')
+    console.error('[livetap-mcp] WARNING: Could not connect to daemon. Tools will auto-retry on first call.')
   }
 
   const mcp = new Server(
-    { name: 'livetap', version: '0.1.0' },
+    { name: 'LiveTap', version: PKG.version },
     {
       capabilities: {
         experimental: { 'claude/channel': {} },
@@ -118,4 +128,12 @@ async function main() {
   connectToSSE(mcp)
 }
 
+// Prevent unhandled errors from crashing the proxy process
+process.on('unhandledRejection', (err) => {
+  console.error('[livetap-mcp] unhandled rejection:', err)
+})
+process.on('uncaughtException', (err) => {
+  console.error('[livetap-mcp] uncaught exception:', err)
+})
+
 main()

package/src/mcp/tools.ts

@@ -50,7 +50,7 @@ export const TOOLS = [
   },
   {
     name: 'destroy_connection',
-    description: 'Destroy a connection — stops the source subscriber, cleans up the Redis stream.',
+    description: 'Destroy a connection — stops the source subscriber, cleans up the stream buffer.',
     inputSchema: {
       type: 'object' as const,
       properties: {
@@ -169,6 +169,14 @@ export const TOOLS = [
       required: ['watcherId'],
     },
   },
+  {
+    name: 'status',
+    description: 'Get daemon status: uptime, port, active connections and watchers count.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {},
+    },
+  },
 ]
 
 function text(content: string) {
@@ -179,9 +187,35 @@ function error(content: string) {
   return { content: [{ type: 'text' as const, text: content }], isError: true }
 }
 
+/**
+ * Try to start the daemon via CLI. Returns true if daemon becomes healthy.
+ */
+async function tryStartDaemon(daemonUrl: string): Promise<boolean> {
+  const startScript = new URL('../../bin/livetap.ts', import.meta.url).pathname
+  const port = new URL(daemonUrl).port || '8788'
+  const proc = Bun.spawn(['bun', startScript, 'start'], {
+    env: { ...process.env, LIVETAP_PORT: port },
+    stdout: 'ignore',
+    stderr: 'ignore',
+  })
+  proc.unref()
+
+  // Wait up to 15s for daemon to be ready
+  const deadline = Date.now() + 15_000
+  while (Date.now() < deadline) {
+    try {
+      const res = await fetch(`${daemonUrl}/status`)
+      if (res.ok) return true
+    } catch { /* not ready */ }
+    await new Promise((r) => setTimeout(r, 500))
+  }
+  return false
+}
+
 /**
  * Register all livetap MCP tools on the given server.
  * Tools proxy to the daemon HTTP API at the given base URL.
+ * Includes auto-restart + retry on connection failure.
  */
 export function registerTools(server: Server, daemonUrl: string) {
   server.setRequestHandler(ListToolsRequestSchema, async () => ({
@@ -304,11 +338,40 @@ export function registerTools(server: Server, daemonUrl: string) {
           return text(await res.text())
         }
 
+        case 'status': {
+          const res = await fetch(`${daemonUrl}/status`)
+          if (!res.ok) return error('Daemon not reachable')
+          const status = await res.json()
+          // Also fetch watcher count
+          let watcherCount = 0
+          try {
+            const wr = await fetch(`${daemonUrl}/watchers`)
+            if (wr.ok) {
+              const watchers = await wr.json()
+              watcherCount = watchers.length
+            }
+          } catch { /* ok */ }
+          return text(JSON.stringify({ ...status, watcherCount }, null, 2))
+        }
+
         default:
           return error(`Unknown tool: ${name}`)
       }
     } catch (err) {
-      return error(`livetap daemon error: ${(err as Error).message}. Is the daemon running?`)
+      // Connection failed — try to auto-start daemon and retry
+      const msg = (err as Error).message
+      if (msg.includes('Unable to connect') || msg.includes('ECONNREFUSED') || msg.includes('fetch failed')) {
+        const started = await tryStartDaemon(daemonUrl)
+        if (!started) {
+          return error('livetap daemon could not be started. Run "livetap start" manually.')
+        }
+        // Retry: simple fetch to /status to confirm, then tell agent to retry
+        return text(JSON.stringify({
+          note: 'Daemon was restarted. Please retry your request.',
+          status: 'daemon_restarted',
+        }))
+      }
+      return error(`livetap daemon error: ${msg}`)
     }
   })
 }