offhands 0.1.5 → 0.1.9

package/dist/daemon.mjs

@@ -79,9 +79,9 @@ var require_buffer_util = __commonJS({
       }
       return target;
     }
-    function _mask(source, mask, output, offset, length) {
+    function _mask(source, mask, output2, offset, length) {
       for (let i2 = 0; i2 < length; i2++) {
-        output[offset + i2] = source[i2] ^ mask[i2 & 3];
+        output2[offset + i2] = source[i2] ^ mask[i2 & 3];
       }
     }
     function _unmask(buffer, mask) {
@@ -119,9 +119,9 @@ var require_buffer_util = __commonJS({
     if (!process.env.WS_NO_BUFFER_UTIL) {
       try {
         const bufferUtil = __require("bufferutil");
-        module2.exports.mask = function(source, mask, output, offset, length) {
-          if (length < 48) _mask(source, mask, output, offset, length);
-          else bufferUtil.mask(source, mask, output, offset, length);
+        module2.exports.mask = function(source, mask, output2, offset, length) {
+          if (length < 48) _mask(source, mask, output2, offset, length);
+          else bufferUtil.mask(source, mask, output2, offset, length);
         };
         module2.exports.unmask = function(buffer, mask) {
           if (buffer.length < 32) _unmask(buffer, mask);
@@ -4719,7 +4719,7 @@ var require_main = __commonJS({
         var qrcode = new QRCode(-1, this.error);
         qrcode.addData(input);
         qrcode.make();
-        var output = "";
+        var output2 = "";
         if (opts && opts.small) {
           var BLACK = true, WHITE = false;
           var moduleCount = qrcode.getModuleCount();
@@ -4736,37 +4736,37 @@ var require_main = __commonJS({
           };
           var borderTop = repeat(platte.BLACK_WHITE).times(moduleCount + 3);
           var borderBottom = repeat(platte.WHITE_BLACK).times(moduleCount + 3);
-          output += borderTop + "\n";
+          output2 += borderTop + "\n";
           for (var row = 0; row < moduleCount; row += 2) {
-            output += platte.WHITE_ALL;
+            output2 += platte.WHITE_ALL;
             for (var col = 0; col < moduleCount; col++) {
               if (moduleData[row][col] === WHITE && moduleData[row + 1][col] === WHITE) {
-                output += platte.WHITE_ALL;
+                output2 += platte.WHITE_ALL;
               } else if (moduleData[row][col] === WHITE && moduleData[row + 1][col] === BLACK) {
-                output += platte.WHITE_BLACK;
+                output2 += platte.WHITE_BLACK;
               } else if (moduleData[row][col] === BLACK && moduleData[row + 1][col] === WHITE) {
-                output += platte.BLACK_WHITE;
+                output2 += platte.BLACK_WHITE;
               } else {
-                output += platte.BLACK_ALL;
+                output2 += platte.BLACK_ALL;
               }
             }
-            output += platte.WHITE_ALL + "\n";
+            output2 += platte.WHITE_ALL + "\n";
           }
           if (!oddRow) {
-            output += borderBottom;
+            output2 += borderBottom;
           }
         } else {
           var border = repeat(white).times(qrcode.getModuleCount() + 3);
-          output += border + "\n";
+          output2 += border + "\n";
           qrcode.modules.forEach(function(row2) {
-            output += white;
-            output += row2.map(toCell).join("");
-            output += white + "\n";
+            output2 += white;
+            output2 += row2.map(toCell).join("");
+            output2 += white + "\n";
           });
-          output += border;
+          output2 += border;
         }
-        if (cb) cb(output);
-        else console.log(output);
+        if (cb) cb(output2);
+        else console.log(output2);
       },
       setErrorLevel: function(error) {
         this.error = QRErrorCorrectLevel[error] || this.error;
@@ -4777,7 +4777,7 @@ var require_main = __commonJS({
 
 // ../daemon/src/index.ts
 import { resolve as resolve5 } from "node:path";
-import { existsSync as existsSync9 } from "node:fs";
+import { existsSync as existsSync10 } from "node:fs";
 
 // ../daemon/src/runners/claude-code.ts
 import { spawn } from "node:child_process";
@@ -4862,10 +4862,12 @@ function mapClaudeEvent(value) {
       for (const block of content) {
         if (block?.type === "tool_use" && typeof block.name === "string") {
           if (block.name.startsWith("mcp__offhand__")) continue;
+          const todos = block.name === "TodoWrite" ? extractTodos(block.input) : void 0;
           events.push({
             type: "tool",
             name: block.name,
-            summary: summariseToolInput(block.name, block.input)
+            summary: todos ? summariseTodos(todos) : summariseToolInput(block.name, block.input),
+            ...todos ? { todos } : {}
           });
         }
       }
@@ -4894,6 +4896,29 @@ function contextUsage(usage, costUsd) {
   if (contextTokens <= 0) return null;
   return { type: "usage", contextTokens, contextWindow: 2e5, ...costUsd !== void 0 ? { costUsd } : {} };
 }
+function extractTodos(input) {
+  if (typeof input !== "object" || input === null) return void 0;
+  const list = input.todos;
+  if (!Array.isArray(list)) return void 0;
+  const todos = [];
+  for (const item of list) {
+    if (typeof item !== "object" || item === null) return void 0;
+    const t2 = item;
+    if (typeof t2.content !== "string") return void 0;
+    if (t2.status !== "pending" && t2.status !== "in_progress" && t2.status !== "completed") return void 0;
+    todos.push({
+      content: t2.content,
+      status: t2.status,
+      ...typeof t2.activeForm === "string" ? { activeForm: t2.activeForm } : {}
+    });
+  }
+  return todos;
+}
+function summariseTodos(todos) {
+  const active = todos.find((t2) => t2.status === "in_progress");
+  const done = todos.filter((t2) => t2.status === "completed").length;
+  return active ? `TodoWrite: ${active.activeForm ?? active.content} (${done}/${todos.length} done)` : `TodoWrite: ${done}/${todos.length} done`;
+}
 function summariseToolInput(name, input) {
   if (typeof input !== "object" || input === null) return name;
   const i2 = input;
@@ -4941,8 +4966,21 @@ var ClaudeCodeRunner = class {
   }
   id = "claude-code";
   name = "Claude Code";
-  models = ["sonnet", "opus", "haiku"];
+  // No enumeration command exists (checked `claude --help` in full against
+  // CLI v2.1.263 — no `models` subcommand, no --list-models flag). These are
+  // the aliases `--model`'s own help text names as examples ('fable', 'opus',
+  // 'sonnet'), plus 'haiku' (long-standing, not superseded by anything found
+  // here) — hardcoded because there is genuinely nothing to query, not out
+  // of laziness. Re-verify against `claude --help` when bumping this list.
+  models = ["sonnet", "opus", "haiku", "fable"];
   supportsApprovals = true;
+  // Real: every tier maps to a MAX_THINKING_TOKENS value below (see start()).
+  effortTiers = ["low", "medium", "high", "max"];
+  // The vendor's own supported install path (code.claude.com/docs/en/setup
+  // lists this as the "advanced installation option" alongside their native
+  // curl/PowerShell installer — npm works fine and is what the daemon can
+  // run unattended). Verified Sept 2026; re-check if this ever 404s.
+  installCommand = { command: "npm", args: ["install", "-g", "@anthropic-ai/claude-code"] };
   loggedIn() {
     return existsSync(join(homedir(), ".claude", ".credentials.json"));
   }
@@ -4988,7 +5026,15 @@ var ClaudeCodeRunner = class {
           offhand: {
             command: process.execPath,
             args: [APPROVAL_MCP_PATH],
-            env: { OFFHAND_APPROVAL_URL: this.approvalUrl }
+            // OFFHAND_STATUS_URL is derived from approvalUrl rather than a
+            // second constructor param — same daemon, same port, one fewer
+            // thing to keep in sync as this.approvalUrl already carries the
+            // host:port everything else here needs.
+            env: {
+              OFFHAND_APPROVAL_URL: this.approvalUrl,
+              OFFHAND_STATUS_URL: this.approvalUrl.replace(/\/approval$/, "/status"),
+              OFFHAND_SESSION_ID: run.sessionId
+            }
           }
         }
       };
@@ -5102,6 +5148,7 @@ var CodexCliRunner = class {
   name = "OpenAI Codex CLI";
   models = [];
   supportsApprovals = false;
+  installCommand = { command: "npm", args: ["install", "-g", "@openai/codex"] };
   detect = () => commandExists("codex");
   start = (_run) => notImplemented(this.id);
 };
@@ -5110,7 +5157,18 @@ var CursorAgentRunner = class {
   name = "Cursor";
   models = [];
   supportsApprovals = false;
-  detect = () => commandExists("cursor-agent");
+  // No npm package exists — the vendor's real installer is a piped shell
+  // script (`curl https://cursor.com/install | bash` / an iwr|iex on
+  // Windows). Never auto-execute a remote script on the user's behalf;
+  // link out instead of offering a one-tap install here.
+  installUrl = "https://cursor.com/docs/cli/installation";
+  // The installed binary is actually named `agent`, not `cursor-agent`
+  // (confirmed against the vendor's current docs, Sept 2026) — detect()
+  // was checking the wrong command name and would never find a real
+  // install. Fixed alongside the install-hint work since the two are
+  // directly related: there's no point offering install guidance for a
+  // runner whose own detection can never succeed.
+  detect = () => commandExists("agent");
   start = (_run) => notImplemented(this.id);
 };
 var GeminiCliRunner = class {
@@ -5118,6 +5176,7 @@ var GeminiCliRunner = class {
   name = "Gemini CLI";
   models = [];
   supportsApprovals = false;
+  installCommand = { command: "npm", args: ["install", "-g", "@google/gemini-cli"] };
   detect = () => commandExists("gemini");
   start = (_run) => notImplemented(this.id);
 };
@@ -5174,6 +5233,12 @@ var CopilotCliRunner = class {
   models = [];
   // no headless enumeration in 1.0.31; CLI default
   supportsApprovals = false;
+  // No effortTiers: start() never reads run.effort — there's no thinking-
+  // budget flag in Copilot CLI 1.0.31's non-interactive mode. Leaving this
+  // undefined (not an empty array) is what tells the phone to hide the
+  // effort control here rather than show one that silently does nothing.
+  // Vendor's own docs (docs.github.com/copilot/how-tos/copilot-cli/install-copilot-cli).
+  installCommand = { command: "npm", args: ["install", "-g", "@github/copilot"] };
   /** [command, ...prefixArgs] resolved once. */
   resolved = null;
   resolveCommand() {
@@ -5302,7 +5367,8 @@ import { spawn as spawn4 } from "node:child_process";
 import { createServer } from "node:net";
 import { existsSync as existsSync3 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { delimiter as delimiter2, join as join3 } from "node:path";
+import { delimiter as delimiter2, join as join3, dirname as dirname2 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // ../daemon/src/runners/opencode-map.ts
 function mapOpenCodeEvent(value) {
@@ -5385,22 +5451,59 @@ function truncate3(s2, max) {
 
 // ../daemon/src/runners/opencode-cli.ts
 var POLL_INTERVAL_MS = 500;
+var APPROVAL_MCP_PATH2 = join3(dirname2(fileURLToPath2(import.meta.url)), "..", "approval-mcp.mjs");
+function statusOnlyMcpConfigContent(statusUrl2, sessionId) {
+  return JSON.stringify({
+    mcp: {
+      "offhand-status": {
+        type: "local",
+        command: [process.execPath, APPROVAL_MCP_PATH2],
+        environment: {
+          OFFHAND_STATUS_URL: statusUrl2 ?? "",
+          OFFHAND_SESSION_ID: sessionId
+        }
+      }
+    }
+  });
+}
 var OpenCodeRunner = class {
-  constructor(broker2) {
+  constructor(broker2, statusUrl2) {
     this.broker = broker2;
+    this.statusUrl = statusUrl2;
   }
   id = "opencode";
   name = "OpenCode";
   supportsApprovals = true;
   models = [];
   // populated dynamically via `opencode models`
+  // Real: every tier maps to a --variant value below (see startViaCli()) —
+  // low/medium collide onto minimal/high internally, but all four inputs
+  // are genuinely honored, just not 1:1 named.
+  effortTiers = ["low", "medium", "high", "max"];
+  // Package name is `opencode-ai` (opencode.ai/docs), not `opencode` or
+  // `@opencode/cli` — verified against the vendor's own install docs.
+  installCommand = { command: "npm", args: ["install", "-g", "opencode-ai"] };
   /** [command, ...prefixArgs] resolved once. */
   resolved = null;
   modelsCache = [];
-  // Lazily-started, shared `opencode serve` instance backing startViaHttpApi.
-  serverPort = null;
-  serverProcess = null;
-  serverStarting = null;
+  // Lazily-started `opencode serve` instances backing startViaHttpApi — ONE
+  // PER OFFHAND SESSION, not a single shared process. A shared server was
+  // the original design (simpler, one cold-start instead of many), but its
+  // MCP config is fixed at spawn time via an env var, and the server itself
+  // is genuinely multi-tenant (concurrent offhand sessions each get their
+  // own opencode-internal session id on the SAME shared HTTP server — see
+  // the `POST /session` call in startViaHttpApi). A single shared server
+  // therefore cannot carry a correct OFFHAND_SESSION_ID for
+  // offhand_status_update: two sessions running at once would have the
+  // second one's status updates silently attributed to the first. Keying
+  // by session id costs an extra `opencode serve` cold-start per session
+  // (kept alive for that session's lifetime, matching how
+  // `resumeConversationId` already expects the SAME server instance across
+  // that session's later turns) in exchange for actually-correct
+  // attribution — worth it; a silently wrong session id is a Rule #2
+  // violation, a slower first prompt is not.
+  servers = /* @__PURE__ */ new Map();
+  serverStarting = /* @__PURE__ */ new Map();
   resolveCommand() {
     if (this.resolved) return this.resolved;
     if (process.platform === "win32") {
@@ -5462,15 +5565,15 @@ var OpenCodeRunner = class {
         stdio: ["ignore", "pipe", "ignore"],
         shell: process.platform === "win32"
       });
-      let output = "";
+      let output2 = "";
       p2.stdout.setEncoding("utf8");
       p2.stdout.on("data", (chunk) => {
-        output += chunk;
+        output2 += chunk;
       });
       p2.on("close", (code) => {
         if (code === 0) {
           try {
-            const lines = output.trim().split("\n");
+            const lines = output2.trim().split("\n");
             const models = lines.map((l2) => l2.trim()).filter((l2) => l2.length > 0);
             this.modelsCache = models;
             Object.defineProperty(this, "models", {
@@ -5557,7 +5660,10 @@ var OpenCodeRunner = class {
       child = spawn4(cmd[0], args2, {
         cwd: run.workspace,
         stdio: ["ignore", "pipe", "pipe"],
-        shell: process.platform === "win32"
+        shell: process.platform === "win32",
+        // One-shot process per prompt — no shared-server cross-session risk
+        // here, so the session id can go straight on the env unconditionally.
+        env: { ...process.env, OPENCODE_CONFIG_CONTENT: statusOnlyMcpConfigContent(this.statusUrl, run.sessionId) }
       });
     } catch (e) {
       queue.push({ type: "error", message: `failed to spawn opencode: ${String(e)}` });
@@ -5631,7 +5737,7 @@ stderr: ${stderrTail}` : ""}`
     };
     void (async () => {
       try {
-        port2 = await this.ensureServer();
+        port2 = await this.ensureServer(run.sessionId);
       } catch (e) {
         emit([{ type: "error", message: `failed to start opencode server: ${String(e)}` }]);
         cleanup();
@@ -5652,6 +5758,14 @@ stderr: ${stderrTail}` : ""}`
           sessionId = session.id;
         }
         callbacks?.onConversationId?.(sessionId);
+        const baselineMessageIds = /* @__PURE__ */ new Set();
+        if (run.resumeConversationId) {
+          try {
+            const existing = await httpJson(`${base}/session/${sessionId}/message?directory=${encDir}`, "GET");
+            for (const row of existing) baselineMessageIds.add(row.info.id);
+          } catch {
+          }
+        }
         const parts = [{ type: "text", text: run.prompt }];
         for (const file of run.attachments ?? []) {
           parts.push({ type: "file", mime: "application/octet-stream", url: fileUrl(file) });
@@ -5660,7 +5774,7 @@ stderr: ${stderrTail}` : ""}`
         const modelRef = parseModelRef(run.model);
         if (modelRef) promptBody.model = { providerID: modelRef.providerId, modelID: modelRef.modelId };
         await httpJson(`${base}/session/${sessionId}/prompt_async?directory=${encDir}`, "POST", promptBody, true);
-        await this.pollUntilDone(base, sessionId, encDir, broker2, emit, pendingQuestions, () => cancelled);
+        await this.pollUntilDone(base, sessionId, encDir, broker2, emit, pendingQuestions, baselineMessageIds, () => cancelled);
       } catch (e) {
         if (!cancelled) emit([{ type: "error", message: `opencode HTTP API error: ${String(e)}` }]);
       } finally {
@@ -5689,7 +5803,7 @@ stderr: ${stderrTail}` : ""}`
     };
   }
   /** Poll session messages + pending permissions/questions until the turn finishes. */
-  async pollUntilDone(base, sessionId, encDir, broker2, emit, pendingQuestions, isCancelled) {
+  async pollUntilDone(base, sessionId, encDir, broker2, emit, pendingQuestions, baselineMessageIds, isCancelled) {
     const seenPermissions = /* @__PURE__ */ new Set();
     const seenQuestions = /* @__PURE__ */ new Set();
     const emittedParts = /* @__PURE__ */ new Set();
@@ -5721,21 +5835,9 @@ stderr: ${stderrTail}` : ""}`
       } catch {
         continue;
       }
-      for (const row of messages) {
-        if (row.info.role !== "assistant") continue;
-        for (const part of row.parts) {
-          if (!part.id || emittedParts.has(part.id)) continue;
-          if ((part.type === "text" || part.type === "reasoning") && !part.time?.end) continue;
-          emittedParts.add(part.id);
-          const events = mapOpenCodeEvent({ part });
-          emit(events);
-          if (events.some((e) => e.type === "done" || e.type === "error")) sawTerminal = true;
-        }
-        if (!sawTerminal && row.info.error) {
-          sawTerminal = true;
-          emit([{ type: "error", message: row.info.error.data?.message ?? "run failed" }]);
-        }
-      }
+      const result = processMessages(messages, baselineMessageIds, emittedParts);
+      emit(result.events);
+      if (result.sawTerminal) sawTerminal = true;
     }
   }
   /** Route one pending permission through the shared broker, then reply. */
@@ -5785,37 +5887,61 @@ stderr: ${stderrTail}` : ""}`
     } catch {
     }
   }
-  /** Lazily start (once) the shared `opencode serve` instance used for
-   * broker-driven runs, and wait for it to accept connections. */
-  async ensureServer() {
-    if (this.serverPort) return this.serverPort;
-    if (this.serverStarting) return this.serverStarting;
-    this.serverStarting = (async () => {
+  /** Lazily start (once per offhand session) the `opencode serve` instance
+   * backing that session's broker-driven runs, and wait for it to accept
+   * connections. Reused across that session's later turns (so
+   * `resumeConversationId` keeps working); a different session never
+   * shares this instance — see the field comment above for why. */
+  async ensureServer(sessionId) {
+    const existing = this.servers.get(sessionId);
+    if (existing) return existing.port;
+    const inFlight = this.serverStarting.get(sessionId);
+    if (inFlight) return inFlight;
+    const starting = (async () => {
       const cmd = this.resolveCommand();
       if (!cmd) throw new Error("opencode CLI not found");
       const port2 = await findFreePort();
       const proc = spawn4(cmd[0], [...cmd.slice(1), "serve", "--port", String(port2), "--hostname", "127.0.0.1"], {
         stdio: ["ignore", "pipe", "pipe"],
-        shell: process.platform === "win32"
+        shell: process.platform === "win32",
+        env: { ...process.env, OPENCODE_CONFIG_CONTENT: statusOnlyMcpConfigContent(this.statusUrl, sessionId) }
       });
       proc.on("exit", () => {
-        if (this.serverProcess === proc) {
-          this.serverProcess = null;
-          this.serverPort = null;
-        }
+        const cur = this.servers.get(sessionId);
+        if (cur?.process === proc) this.servers.delete(sessionId);
       });
       await waitForServerReady(port2);
-      this.serverProcess = proc;
-      this.serverPort = port2;
+      this.servers.set(sessionId, { port: port2, process: proc });
       return port2;
     })();
+    this.serverStarting.set(sessionId, starting);
     try {
-      return await this.serverStarting;
+      return await starting;
     } finally {
-      this.serverStarting = null;
+      this.serverStarting.delete(sessionId);
     }
   }
 };
+function processMessages(messages, baselineMessageIds, emittedParts) {
+  const events = [];
+  let sawTerminal = false;
+  for (const row of messages) {
+    if (row.info.role !== "assistant" || baselineMessageIds.has(row.info.id)) continue;
+    for (const part of row.parts) {
+      if (!part.id || emittedParts.has(part.id)) continue;
+      if ((part.type === "text" || part.type === "reasoning") && !part.time?.end) continue;
+      emittedParts.add(part.id);
+      const partEvents = mapOpenCodeEvent({ part });
+      events.push(...partEvents);
+      if (partEvents.some((e) => e.type === "done" || e.type === "error")) sawTerminal = true;
+    }
+    if (!sawTerminal && row.info.error) {
+      sawTerminal = true;
+      events.push({ type: "error", message: row.info.error.data?.message ?? "run failed" });
+    }
+  }
+  return { events, sawTerminal };
+}
 function buildPermissionRuleset(mode) {
   const base = [{ permission: "*", pattern: "*", action: "allow" }];
   if (mode === "acceptEdits") {
@@ -5886,10 +6012,12 @@ function sleep(ms) {
 
 // ../daemon/src/session-manager.ts
 import { randomUUID } from "node:crypto";
-import { hostname, platform, tmpdir } from "node:os";
-import { existsSync as existsSync6, mkdirSync as mkdirSync2, readdirSync as readdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname2, join as join6, basename as basename3, parse as parse2, resolve as resolve3 } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { hostname, platform as platform2, tmpdir } from "node:os";
+import { existsSync as existsSync7, mkdirSync as mkdirSync2, readdirSync as readdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname3, join as join6, basename as basename3, parse as parse2, resolve as resolve3 } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { execFile as execFile4 } from "node:child_process";
+import { promisify as promisify4 } from "node:util";
 
 // ../daemon/src/receipts.ts
 import { execFile } from "node:child_process";
@@ -5911,6 +6039,7 @@ async function workspaceInfo(row) {
     path: row.path,
     label: row.label,
     policy: row.policy,
+    intelligenceMode: row.intelligenceMode,
     ...branch ? { gitBranch: branch } : {},
     ...status !== null ? { dirty: status.trim() !== "" } : {},
     ...row.devUrl ? { devUrl: row.devUrl } : {}
@@ -6234,10 +6363,508 @@ function mimeFromName(path) {
   }[ext] ?? "application/octet-stream";
 }
 
+// ../daemon/src/handover.ts
+var MAX_DIFF_BYTES2 = 48 * 1024;
+var MAX_TOOL_SUMMARIES = 30;
+var MAX_RECENT_MESSAGES = 10;
+async function liveDiff(workspace) {
+  const diff = await git(workspace, "diff", "HEAD");
+  if (!diff) return "";
+  return diff.length > MAX_DIFF_BYTES2 ? diff.slice(0, MAX_DIFF_BYTES2) + "\n\u2026 diff truncated \u2026" : diff;
+}
+function assembleHandoverPacket(items, diff) {
+  const toolSummaries = [];
+  let todos;
+  const recentMessages = [];
+  const resolvedApprovalIds = /* @__PURE__ */ new Set();
+  const approvalsById = /* @__PURE__ */ new Map();
+  for (const msg of items) {
+    if (msg.type === "run-started") {
+      recentMessages.push({ role: "user", text: msg.prompt });
+      continue;
+    }
+    if (msg.type !== "run-event") continue;
+    const ev = msg.event;
+    if (ev.type === "tool") {
+      toolSummaries.push(ev.summary);
+      if (ev.todos) todos = ev.todos;
+    } else if (ev.type === "text") {
+      const last = recentMessages[recentMessages.length - 1];
+      if (last?.role === "assistant") last.text += ev.chunk;
+      else recentMessages.push({ role: "assistant", text: ev.chunk });
+    } else if (ev.type === "approval") {
+      approvalsById.set(ev.id, { action: ev.action, detail: ev.detail, risk: ev.risk });
+    } else if (ev.type === "approval-result") {
+      resolvedApprovalIds.add(ev.id);
+    }
+  }
+  const pendingApprovals = [...approvalsById.entries()].filter(([id]) => !resolvedApprovalIds.has(id)).map(([, a2]) => a2);
+  return {
+    diff,
+    toolSummaries: toolSummaries.slice(-MAX_TOOL_SUMMARIES),
+    ...todos ? { todos } : {},
+    pendingApprovals,
+    recentMessages: recentMessages.slice(-MAX_RECENT_MESSAGES)
+  };
+}
+function translatePacketToPrompt(packet, fromRunnerName) {
+  const sections = [
+    `You're continuing a task handed off from ${fromRunnerName}, which hit its usage limit mid-task. Here is the context so far.`
+  ];
+  if (packet.recentMessages.length > 0) {
+    sections.push(
+      "## Recent conversation\n" + packet.recentMessages.map((m3) => `**${m3.role}:** ${m3.text}`).join("\n\n")
+    );
+  }
+  if (packet.toolSummaries.length > 0) {
+    sections.push("## Actions already taken\n" + packet.toolSummaries.map((t2) => `- ${t2}`).join("\n"));
+  }
+  if (packet.todos && packet.todos.length > 0) {
+    sections.push(
+      "## Remaining plan\n" + packet.todos.map((t2) => `- [${t2.status === "completed" ? "x" : " "}] ${t2.content}`).join("\n")
+    );
+  }
+  if (packet.pendingApprovals.length > 0) {
+    sections.push(
+      "## Not yet approved (ask again if still needed)\n" + packet.pendingApprovals.map((a2) => `- ${a2.action}: ${a2.detail} (${a2.risk} risk)`).join("\n")
+    );
+  }
+  if (packet.diff.trim()) {
+    sections.push("## Uncommitted changes so far (git diff)\n```diff\n" + packet.diff + "\n```");
+  }
+  if (packet.agentSummary) {
+    sections.push("## Outgoing agent's own summary\n" + packet.agentSummary);
+  }
+  sections.push("Please continue the task from here.");
+  return sections.join("\n\n");
+}
+
+// ../daemon/src/wol.ts
+import { execFile as execFile2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+import { networkInterfaces, platform } from "node:os";
+import { existsSync as existsSync6 } from "node:fs";
+var exec2 = promisify2(execFile2);
+function pickPrimaryInterface(ifaces) {
+  for (const [name, infos] of Object.entries(ifaces)) {
+    if (!infos) continue;
+    const ipv4 = infos.find((i2) => i2.family === "IPv4" && !i2.internal);
+    if (ipv4?.mac && ipv4.mac !== "00:00:00:00:00:00") {
+      return { name, mac: ipv4.mac, address: ipv4.address, netmask: ipv4.netmask };
+    }
+  }
+  return null;
+}
+function pickInterfaceByName(ifaces, name) {
+  const infos = ifaces[name];
+  if (!infos) return null;
+  const ipv4 = infos.find((i2) => i2.family === "IPv4" && !i2.internal);
+  if (!ipv4?.mac || ipv4.mac === "00:00:00:00:00:00") return null;
+  return { name, mac: ipv4.mac, address: ipv4.address, netmask: ipv4.netmask };
+}
+function computeBroadcastAddress(address, netmask) {
+  const a2 = address.split(".").map(Number);
+  const m3 = netmask.split(".").map(Number);
+  if (a2.length !== 4 || m3.length !== 4 || a2.some(Number.isNaN) || m3.some(Number.isNaN)) return null;
+  return a2.map((octet, i2) => (octet | ~m3[i2] & 255) & 255).join(".");
+}
+function normalizeMac(mac) {
+  return (mac ?? "").toLowerCase().replace(/[:-]/g, "");
+}
+function classifyWindowsMediaType(mediaType) {
+  const t2 = (mediaType ?? "").toLowerCase();
+  if (t2.includes("802.11") || t2.includes("wireless") || t2.includes("native 802.11")) return "wifi";
+  if (t2.includes("802.3") || t2.includes("ethernet")) return "ethernet";
+  return "unknown";
+}
+function parseWindowsAdapterJson(json) {
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch {
+    return [];
+  }
+  const arr = Array.isArray(parsed) ? parsed : parsed ? [parsed] : [];
+  return arr.filter((x2) => !!x2 && typeof x2 === "object").map((x2) => ({
+    name: String(x2.Name ?? ""),
+    macAddress: x2.MacAddress ? String(x2.MacAddress) : null,
+    networkType: classifyWindowsMediaType(x2.MediaType),
+    wakeOnMagicPacket: x2.WakeOnMagicPacket === "Enabled" || x2.WakeOnMagicPacket === "Disabled" || x2.WakeOnMagicPacket === "NotSupported" ? x2.WakeOnMagicPacket : null
+  }));
+}
+function parseMacPmset(output2) {
+  const m3 = output2.match(/^\s*womp\s+(\d)/m);
+  return m3 ? m3[1] === "1" : false;
+}
+function classifyMacHardwarePort(listing, deviceName) {
+  const blocks = listing.split(/\n\n+/);
+  for (const block of blocks) {
+    if (!new RegExp(`Device:\\s*${deviceName}\\b`).test(block)) continue;
+    if (/Hardware Port:\s*Wi-Fi/i.test(block)) return "wifi";
+    if (/Hardware Port:\s*(Ethernet|Thunderbolt Ethernet)/i.test(block)) return "ethernet";
+  }
+  return "unknown";
+}
+function parseLinuxEthtool(output2) {
+  let supports = "";
+  let current = "";
+  for (const line of output2.split(/\r?\n/)) {
+    const supportsMatch = line.match(/^\s*Supports Wake-on:\s*([a-zA-Z]*)/);
+    if (supportsMatch) {
+      supports = supportsMatch[1];
+      continue;
+    }
+    const currentMatch = line.match(/^\s*Wake-on:\s*([a-zA-Z]*)/);
+    if (currentMatch) current = currentMatch[1];
+  }
+  return { supportsWakeOnG: supports.toLowerCase().includes("g"), wakeOnGEnabled: current.toLowerCase().includes("g") };
+}
+function computeWolCapability(networkType, wolWorks) {
+  if (!wolWorks) {
+    return {
+      capability: "unsupported",
+      reason: networkType === "wifi" ? "Wake-on-Wireless-LAN isn't enabled on this network adapter." : "Wake-on-LAN isn't enabled (or isn't supported) on this network adapter."
+    };
+  }
+  if (networkType === "wifi") {
+    return {
+      capability: "wifi-limited",
+      reason: "Wake-on-Wireless-LAN is enabled, but WiFi wake support depends on the router too \u2014 less reliable than a wired connection."
+    };
+  }
+  if (networkType === "ethernet") {
+    return { capability: "supported", reason: "Wake-on-LAN is enabled on this wired connection." };
+  }
+  return { capability: "unsupported", reason: "Couldn't determine this machine's network connection type." };
+}
+var WINDOWS_ADAPTER_SCRIPT = "Get-NetAdapter -Physical | Where-Object Status -eq 'Up' | ForEach-Object { $pm = Get-NetAdapterPowerManagement -Name $_.Name -ErrorAction SilentlyContinue; [PSCustomObject]@{ Name = $_.Name; MediaType = [string]$_.PhysicalMediaType; MacAddress = $_.MacAddress; WakeOnMagicPacket = [string]$pm.WakeOnMagicPacket } } | ConvertTo-Json";
+async function detectWindows(primary) {
+  const { stdout } = await exec2("powershell", ["-NoProfile", "-NonInteractive", "-Command", WINDOWS_ADAPTER_SCRIPT], {
+    timeout: 8e3
+  });
+  const adapters = parseWindowsAdapterJson(stdout);
+  const match = adapters.find((a2) => normalizeMac(a2.macAddress) === normalizeMac(primary.mac)) ?? adapters[0];
+  if (!match) throw new Error("no active physical adapter reported by Get-NetAdapter");
+  return { networkType: match.networkType, wolWorks: match.wakeOnMagicPacket === "Enabled" };
+}
+async function detectMac(primary) {
+  const { stdout: hardwarePorts } = await exec2("networksetup", ["-listallhardwareports"], { timeout: 8e3 });
+  const networkType = classifyMacHardwarePort(hardwarePorts, primary.name);
+  const { stdout: pmsetOut } = await exec2("pmset", ["-g"], { timeout: 8e3 });
+  return { networkType, wolWorks: parseMacPmset(pmsetOut) };
+}
+async function detectLinux(primary) {
+  const networkType = existsSync6(`/sys/class/net/${primary.name}/wireless`) ? "wifi" : "ethernet";
+  const { stdout } = await exec2("ethtool", [primary.name], { timeout: 8e3 });
+  const { supportsWakeOnG, wakeOnGEnabled } = parseLinuxEthtool(stdout);
+  return { networkType, wolWorks: supportsWakeOnG && wakeOnGEnabled };
+}
+async function getDefaultRouteInterfaceName(plat) {
+  try {
+    if (plat === "win32") {
+      const { stdout } = await exec2(
+        "powershell",
+        [
+          "-NoProfile",
+          "-NonInteractive",
+          "-Command",
+          "Get-NetRoute -DestinationPrefix '0.0.0.0/0' -ErrorAction SilentlyContinue | Sort-Object RouteMetric | Select-Object -First 1 -ExpandProperty InterfaceAlias"
+        ],
+        { timeout: 8e3 }
+      );
+      return stdout.trim() || null;
+    }
+    if (plat === "darwin") {
+      const { stdout } = await exec2("route", ["-n", "get", "default"], { timeout: 8e3 });
+      const m3 = stdout.match(/interface:\s*(\S+)/);
+      return m3 ? m3[1] : null;
+    }
+    if (plat === "linux") {
+      const { stdout } = await exec2("ip", ["route", "show", "default"], { timeout: 8e3 });
+      const m3 = stdout.match(/\bdev\s+(\S+)/);
+      return m3 ? m3[1] : null;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function probeWolCapability() {
+  const checkedAtMs = Date.now();
+  const plat = platform();
+  const ifaces = networkInterfaces();
+  const routeIfaceName = await getDefaultRouteInterfaceName(plat);
+  const primary = routeIfaceName && pickInterfaceByName(ifaces, routeIfaceName) || pickPrimaryInterface(ifaces);
+  if (!primary) {
+    return {
+      capability: "unsupported",
+      reason: "Couldn't find an active network interface to check.",
+      networkType: "unknown",
+      mac: null,
+      broadcast: null,
+      checkedAtMs
+    };
+  }
+  const broadcast = computeBroadcastAddress(primary.address, primary.netmask);
+  try {
+    const detected = plat === "win32" ? await detectWindows(primary) : plat === "darwin" ? await detectMac(primary) : plat === "linux" ? await detectLinux(primary) : (() => {
+      throw new Error(`unsupported OS: ${plat}`);
+    })();
+    const { capability, reason } = computeWolCapability(detected.networkType, detected.wolWorks);
+    return { capability, reason, networkType: detected.networkType, mac: primary.mac, broadcast, checkedAtMs };
+  } catch (e) {
+    return {
+      capability: "unsupported",
+      reason: `Couldn't check Wake-on-LAN support: ${e instanceof Error ? e.message : String(e)}`,
+      networkType: "unknown",
+      mac: primary.mac,
+      broadcast,
+      checkedAtMs
+    };
+  }
+}
+
+// ../daemon/src/intelligence/ripgrep.ts
+import { execFile as execFile3 } from "node:child_process";
+import { promisify as promisify3 } from "node:util";
+var exec3 = promisify3(execFile3);
+var cachedAvailable = null;
+async function detectRipgrep() {
+  if (cachedAvailable !== null) return cachedAvailable;
+  try {
+    await exec3("rg", ["--version"], { timeout: 5e3 });
+    cachedAvailable = true;
+  } catch {
+    cachedAvailable = false;
+  }
+  return cachedAvailable;
+}
+async function searchTerms(workspace, terms, opts = {}) {
+  if (terms.length === 0) return [];
+  const timeoutMs = opts.timeoutMs ?? 3e3;
+  const maxMatches = opts.maxMatches ?? 40;
+  const args2 = [
+    "--fixed-strings",
+    "--ignore-case",
+    "--line-number",
+    "--no-heading",
+    "--max-count",
+    "3",
+    "--max-filesize",
+    "1M",
+    "--glob",
+    "!.git",
+    "--glob",
+    "!node_modules",
+    ...terms.flatMap((t2) => ["-e", t2]),
+    "."
+  ];
+  try {
+    const { stdout } = await exec3("rg", args2, { cwd: workspace, timeout: timeoutMs, maxBuffer: 4 * 1024 * 1024 });
+    return parseRipgrepOutput(stdout).slice(0, maxMatches);
+  } catch (e) {
+    const err = e;
+    return err.stdout ? parseRipgrepOutput(err.stdout).slice(0, maxMatches) : [];
+  }
+}
+function parseRipgrepOutput(stdout) {
+  const hits = [];
+  for (const line of stdout.split("\n")) {
+    if (!line) continue;
+    const m3 = /^(.+?):(\d+):(.*)$/.exec(line);
+    if (!m3) continue;
+    hits.push({ file: m3[1], line: Number(m3[2]), text: m3[3].trim().slice(0, 200) });
+  }
+  return hits;
+}
+
+// ../daemon/src/intelligence/context-inject.ts
+var DEFAULT_MAX_CHARS = 8e3;
+var OVERALL_TIMEOUT_MS = 4e3;
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "to",
+  "for",
+  "in",
+  "on",
+  "of",
+  "and",
+  "or",
+  "is",
+  "are",
+  "be",
+  "been",
+  "add",
+  "please",
+  "can",
+  "you",
+  "we",
+  "this",
+  "that",
+  "it",
+  "with",
+  "from",
+  "when",
+  "where",
+  "how",
+  "what",
+  "i",
+  "my",
+  "our",
+  "some",
+  "make",
+  "sure",
+  "need",
+  "needs",
+  "want",
+  "wants",
+  "like",
+  "using",
+  "use",
+  "so",
+  "up",
+  "as",
+  "at",
+  "by",
+  "not",
+  "do",
+  "does",
+  "did",
+  "have",
+  "has",
+  "had",
+  "will",
+  "would",
+  "should",
+  "could",
+  "also",
+  "into",
+  "if",
+  "then",
+  "than"
+]);
+function extractTerms(prompt, maxTerms = 8) {
+  const raw = prompt.toLowerCase().split(/[^a-z0-9._-]+/).map((t2) => t2.replace(/^[._-]+|[._-]+$/g, "")).filter((t2) => t2.length >= 3 && !STOPWORDS.has(t2) && !/^\d+$/.test(t2));
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const t2 of raw) {
+    if (seen.has(t2)) continue;
+    seen.add(t2);
+    deduped.push(t2);
+  }
+  return deduped.slice().sort((a2, b2) => b2.length - a2.length).slice(0, maxTerms);
+}
+async function buildContext(workspace, prompt, opts = {}) {
+  const startedAt = Date.now();
+  const maxChars = opts.maxChars ?? (Number(process.env.OFFHAND_INTEL_MAX_CHARS) || DEFAULT_MAX_CHARS);
+  const work = gatherFindings(workspace, prompt);
+  const timeout = new Promise((resolve6) => setTimeout(() => resolve6("timeout"), OVERALL_TIMEOUT_MS));
+  const result = await Promise.race([work, timeout]);
+  const durationMs = Date.now() - startedAt;
+  if (result === "timeout") {
+    return {
+      block: "",
+      meta: {
+        promptChars: prompt.length,
+        contextChars: 0,
+        filesConsidered: 0,
+        filesSelected: 0,
+        retrievalOpsRun: 0,
+        durationMs,
+        ripgrepAvailable: false,
+        timedOut: true
+      }
+    };
+  }
+  const { findings, retrievalOpsRun, ripgrepAvailable, gitState } = result;
+  if (findings.length === 0) return null;
+  findings.sort((a2, b2) => b2.priority - a2.priority);
+  const { text: block, selectedCount } = formatBlock(prompt, findings, gitState, maxChars);
+  if (selectedCount === 0) return null;
+  return {
+    block,
+    meta: {
+      promptChars: prompt.length,
+      contextChars: block.length,
+      filesConsidered: findings.length,
+      filesSelected: selectedCount,
+      retrievalOpsRun,
+      durationMs: Date.now() - startedAt,
+      ripgrepAvailable,
+      timedOut: false
+    }
+  };
+}
+async function gatherFindings(workspace, prompt) {
+  let retrievalOpsRun = 0;
+  const byPath = /* @__PURE__ */ new Map();
+  const add = (path, reason, priority) => {
+    const existing = byPath.get(path);
+    if (existing) {
+      if (!existing.reasons.includes(reason)) existing.reasons.push(reason);
+      existing.priority = Math.max(existing.priority, priority);
+    } else {
+      byPath.set(path, { path, reasons: [reason], priority });
+    }
+  };
+  const statusOut = await git(workspace, "status", "--porcelain");
+  retrievalOpsRun++;
+  let gitState = null;
+  if (statusOut !== null) {
+    const dirtyFiles = statusOut.split("\n").filter((l2) => l2.length > 3).map((l2) => l2.slice(3).trim()).filter(Boolean);
+    for (const f2 of dirtyFiles.slice(0, 15)) add(f2, "currently dirty", 3);
+    gitState = dirtyFiles.length > 0 ? `${dirtyFiles.length} file(s) with uncommitted changes` : "clean working tree";
+  }
+  const ripgrepAvailable = await detectRipgrep();
+  retrievalOpsRun++;
+  const terms = extractTerms(prompt);
+  if (ripgrepAvailable && terms.length > 0) {
+    const hits = await searchTerms(workspace, terms);
+    retrievalOpsRun++;
+    for (const hit of hits) {
+      const term = terms.find((t2) => hit.text.toLowerCase().includes(t2));
+      add(hit.file, term ? `matched "${term}"` : "matched search terms", 2);
+    }
+  }
+  const logOut = await git(workspace, "log", "-n", "15", "--name-only", "--pretty=format:");
+  retrievalOpsRun++;
+  if (logOut !== null) {
+    const recentFiles = [...new Set(logOut.split("\n").map((l2) => l2.trim()).filter(Boolean))];
+    for (const f2 of recentFiles.slice(0, 10)) add(f2, "recently changed", 1);
+  }
+  return { findings: [...byPath.values()], retrievalOpsRun, ripgrepAvailable, gitState };
+}
+function formatBlock(prompt, rankedFindings, gitState, maxChars) {
+  const header = `TASK
+${prompt}
+
+OFFHAND REPOSITORY CONTEXT
+`;
+  const gitLine = gitState ? `- Current git state: ${gitState}
+` : "";
+  const footer = "\nIMPORTANT: This context was generated from local repository analysis and may be incomplete or wrong. Verify against the workspace and search further wherever it looks warranted \u2014 do not treat this as the complete picture.";
+  const budget = maxChars - header.length - gitLine.length - footer.length;
+  const lines = [];
+  let used = 0;
+  let selectedCount = 0;
+  for (const f2 of rankedFindings) {
+    const line = `- ${f2.path} \u2014 ${f2.reasons.join(", ")}
+`;
+    if (used + line.length > budget) break;
+    lines.push(line);
+    used += line.length;
+    selectedCount++;
+  }
+  const text = header + gitLine + lines.join("") + footer;
+  return { text, selectedCount };
+}
+
 // ../daemon/src/session-manager.ts
 function resolveDaemonVersion() {
   try {
-    const pkgPath = join6(dirname2(fileURLToPath2(import.meta.url)), "..", "package.json");
+    const pkgPath = join6(dirname3(fileURLToPath3(import.meta.url)), "..", "package.json");
     const pkg = JSON.parse(readFileSync3(pkgPath, "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
@@ -6245,6 +6872,10 @@ function resolveDaemonVersion() {
   }
 }
 var DAEMON_VERSION = resolveDaemonVersion();
+var execFileAsync = promisify4(execFile4);
+var SYSTEM_LOG_SESSION_ID = "system";
+var MOBILE_SESSION_PREAMBLE_BASE = "You're being driven remotely from a phone via offhand \u2014 the person who sent this prompt isn't at this keyboard and can't see this terminal. Lean on visual proof (screenshots, diffs, clear file paths) over long text explanations where you can, since they're reading this on a phone screen, not a terminal.";
+var MOBILE_SESSION_PREAMBLE_STATUS_TOOL = " You have an offhand_status_update tool available \u2014 call it with a short plain-English note at meaningful checkpoints (starting a long step, hitting a snag, finishing a phase) so they see progress without waiting for the whole run to end.";
 var SessionManager = class {
   constructor(store2, runners2) {
     this.store = store2;
@@ -6257,8 +6888,19 @@ var SessionManager = class {
   // sessionId → workspace
   queues = /* @__PURE__ */ new Map();
   // sessionId → queued prompts
+  /** reviewId → an Offhand Intelligence proposal (Execution Plan 8) awaiting
+   * `intelligence-response` — not tied to any run, since none exists yet. */
+  pendingIntelligence = /* @__PURE__ */ new Map();
   runners = /* @__PURE__ */ new Map();
   runnerAvailability = /* @__PURE__ */ new Map();
+  /** handoverId → what was proposed, so `handover-response` (which only
+   * carries the id back) knows what to act on. */
+  pendingHandovers = /* @__PURE__ */ new Map();
+  /** sessionId → the most recent offhand_status_update note (Execution Plan
+   * 5) — becomes a Handover Packet's optional agentSummary when a handover
+   * is proposed afterward. Still zero hosted AI: the agent chose to send
+   * this, on its own tokens, no different from any other tool call. */
+  latestStatusUpdate = /* @__PURE__ */ new Map();
   /** Optional artifact plumbing (set by index when capture is possible). */
   uploader = null;
   capture = null;
@@ -6276,6 +6918,21 @@ var SessionManager = class {
     for (const [id, r2] of this.runners) {
       this.runnerAvailability.set(id, await r2.detect());
     }
+    void this.recheckWolCapability();
+  }
+  /** Runs the real Wake-on-LAN/WiFi probe and persists the result — called
+   * once at startup and again on-demand via the phone's "check again"
+   * action (Execution Plan 7), since drivers/BIOS/network type can change. */
+  async recheckWolCapability() {
+    const result = await probeWolCapability();
+    this.store.setWolCapability({
+      capability: result.capability,
+      reason: result.reason,
+      networkType: result.networkType,
+      mac: result.mac,
+      broadcast: result.broadcast,
+      checkedAtMs: result.checkedAtMs
+    });
   }
   // ---- transport attachment --------------------------------------------------
   attach(sink) {
@@ -6283,10 +6940,16 @@ var SessionManager = class {
     return () => this.sinks.delete(sink);
   }
   hello() {
+    const wol = this.store.getWolCapability();
     return {
       type: "hello",
       protocol: 2,
-      host: { hostname: hostname(), os: platform(), daemonVersion: DAEMON_VERSION },
+      host: {
+        hostname: hostname(),
+        os: platform2(),
+        daemonVersion: DAEMON_VERSION,
+        ...wol ? { wolCapability: wol.capability, wolReason: wol.reason, wolCheckedAtMs: wol.checkedAtMs } : {}
+      },
       lastSeq: this.store.lastSeq()
     };
   }
@@ -6297,7 +6960,10 @@ var SessionManager = class {
       available: this.runnerAvailability.get(r2.id) ?? false,
       ...r2.loggedIn ? { loggedIn: r2.loggedIn() } : {},
       models: r2.models,
-      supportsApprovals: r2.supportsApprovals
+      supportsApprovals: r2.supportsApprovals,
+      ...r2.effortTiers ? { effortTiers: [...r2.effortTiers] } : {},
+      ...r2.installCommand ? { installCommand: `${r2.installCommand.command} ${r2.installCommand.args.join(" ")}` } : {},
+      ...r2.installUrl ? { installUrl: r2.installUrl } : {}
     }));
     const workspaces = await Promise.all(
       this.store.listWorkspaces().map((w2) => workspaceInfo(w2))
@@ -6329,28 +6995,86 @@ var SessionManager = class {
           reply({ type: "error", message: `unknown session ${msg.sessionId}` });
           return;
         }
-        let prompt = msg.prompt;
-        if (msg.attachments?.length && this.attachmentFetcher) {
-          try {
-            prompt += "\n\nAttached files (read them from disk):";
-            for (const a2 of msg.attachments) {
-              const bytes = await this.attachmentFetcher(a2.blobId);
-              const dir = join6(tmpdir(), "offhand-attachments");
-              mkdirSync2(dir, { recursive: true });
-              const path = join6(dir, `${a2.blobId.slice(0, 8)}-${basename3(a2.name)}`);
-              writeFileSync2(path, bytes);
-              prompt += `
-- ${path} (${a2.mime})`;
-            }
-          } catch (e) {
-            reply({ type: "error", message: `attachment staging failed: ${String(e)}` });
-            return;
+        let prompt;
+        try {
+          prompt = await this.stageAttachments(msg.prompt, msg.attachments);
+        } catch (e) {
+          reply({ type: "error", message: `attachment staging failed: ${String(e)}` });
+          return;
+        }
+        this.enqueuePrompt(session, prompt);
+        await this.broadcastManifest();
+        return;
+      }
+      case "intelligence-set": {
+        this.store.setWorkspaceIntelligenceMode(msg.workspace, msg.mode);
+        await this.broadcastManifest();
+        return;
+      }
+      case "intelligence-prepare": {
+        const session = this.store.getSession(msg.sessionId);
+        if (!session) {
+          reply({ type: "error", message: `unknown session ${msg.sessionId}` });
+          return;
+        }
+        let prompt;
+        try {
+          prompt = await this.stageAttachments(msg.prompt, msg.attachments);
+        } catch (e) {
+          reply({ type: "error", message: `attachment staging failed: ${String(e)}` });
+          return;
+        }
+        const built = await buildContext(session.workspace, prompt);
+        this.record(session.id, (seq) => ({
+          type: "run-event",
+          sessionId: session.id,
+          runId: "",
+          seq,
+          event: {
+            type: "intelligence-built",
+            promptChars: prompt.length,
+            contextChars: built?.meta.contextChars ?? 0,
+            filesConsidered: built?.meta.filesConsidered ?? 0,
+            filesSelected: built?.meta.filesSelected ?? 0,
+            retrievalOpsRun: built?.meta.retrievalOpsRun ?? 0,
+            durationMs: built?.meta.durationMs ?? 0,
+            ripgrepAvailable: built?.meta.ripgrepAvailable ?? false,
+            timedOut: built?.meta.timedOut ?? false,
+            attached: built !== null && built.block !== ""
           }
+        }));
+        if (!built || built.block === "") {
+          this.enqueuePrompt(session, prompt);
+          await this.broadcastManifest();
+          return;
         }
-        const q2 = this.queues.get(session.id) ?? [];
-        q2.push(prompt);
-        this.queues.set(session.id, q2);
-        this.pump(session.id);
+        const reviewId = randomUUID();
+        this.pendingIntelligence.set(reviewId, { sessionId: session.id, prompt, block: built.block });
+        this.record(session.id, (seq) => ({
+          type: "intelligence-review",
+          sessionId: session.id,
+          seq,
+          reviewId,
+          originalPrompt: prompt,
+          block: built.block,
+          filesSelected: built.meta.filesSelected
+        }));
+        return;
+      }
+      case "intelligence-response": {
+        const pending = this.pendingIntelligence.get(msg.reviewId);
+        if (!pending || pending.sessionId !== msg.sessionId) return;
+        this.pendingIntelligence.delete(msg.reviewId);
+        const session = this.store.getSession(msg.sessionId);
+        if (!session) return;
+        this.record(session.id, (seq) => ({
+          type: "intelligence-resolved",
+          sessionId: session.id,
+          seq,
+          reviewId: msg.reviewId,
+          useContext: msg.useContext
+        }));
+        this.enqueuePrompt(session, pending.prompt, msg.useContext ? pending.block : void 0);
         await this.broadcastManifest();
         return;
       }
@@ -6392,6 +7116,38 @@ var SessionManager = class {
       case "resume":
         for (const m3 of this.store.replayAfter(msg.afterSeq)) reply(m3);
         return;
+      case "handover-response": {
+        const pending = this.pendingHandovers.get(msg.handoverId);
+        if (!pending || pending.sessionId !== msg.sessionId) return;
+        this.pendingHandovers.delete(msg.handoverId);
+        if (!msg.accept) {
+          this.record(msg.sessionId, (seq) => ({
+            type: "run-event",
+            sessionId: msg.sessionId,
+            runId: "",
+            seq,
+            event: { type: "handover-declined", id: msg.handoverId }
+          }));
+          return;
+        }
+        const session = this.store.getSession(msg.sessionId);
+        const toRunner = this.runners.get(pending.toRunnerId);
+        if (!session || !toRunner) return;
+        const fromRunnerId = session.runnerId;
+        const fromRunner = this.runners.get(fromRunnerId);
+        const prompt = translatePacketToPrompt(pending.packet, fromRunner?.name ?? fromRunnerId);
+        this.store.updateSession(session.id, { runnerId: pending.toRunnerId, conversationId: null });
+        this.record(session.id, (seq) => ({
+          type: "run-event",
+          sessionId: session.id,
+          runId: "",
+          seq,
+          event: { type: "handover-accepted", id: msg.handoverId, fromRunnerId, toRunnerId: pending.toRunnerId }
+        }));
+        this.enqueuePrompt(session, prompt);
+        await this.broadcastManifest();
+        return;
+      }
       case "session-create": {
         const row = this.store.createSession(msg.workspace, msg.runnerId, msg.model, msg.label);
         this.store.upsertWorkspace(msg.workspace);
@@ -6415,7 +7171,9 @@ var SessionManager = class {
           ...msg.model !== void 0 ? { model: msg.model || null } : {},
           ...msg.archived !== void 0 ? { archived: msg.archived } : {},
           ...msg.permissionMode !== void 0 ? { permissionMode: msg.permissionMode } : {},
-          ...msg.effort !== void 0 ? { effort: msg.effort } : {}
+          ...msg.effort !== void 0 ? { effort: msg.effort } : {},
+          ...msg.budgetCostUsdCap !== void 0 ? { budgetCostUsdCap: msg.budgetCostUsdCap } : {},
+          ...msg.budgetMinutesCap !== void 0 ? { budgetMinutesCap: msg.budgetMinutesCap } : {}
         });
         await this.broadcastManifest();
         return;
@@ -6448,8 +7206,117 @@ var SessionManager = class {
       case "fs-list":
         reply({ type: "fs-response", rpcId: msg.rpcId, ...listFolders(msg.path) });
         return;
+      case "fs-create-folder": {
+        try {
+          const safeName = safeDropName(msg.name);
+          mkdirSync2(join6(resolve3(msg.path), safeName), { recursive: false });
+        } catch (e) {
+          reply({
+            type: "fs-response",
+            rpcId: msg.rpcId,
+            ...listFolders(msg.path),
+            error: `couldn't create folder: ${e instanceof Error ? e.message : String(e)}`
+          });
+          return;
+        }
+        reply({ type: "fs-response", rpcId: msg.rpcId, ...listFolders(msg.path) });
+        return;
+      }
+      case "wol-recheck":
+        await this.recheckWolCapability();
+        reply(this.hello());
+        return;
+      case "runner-install": {
+        const runner = this.runners.get(msg.runnerId);
+        if (!runner?.installCommand) {
+          reply({
+            type: "runner-install-response",
+            rpcId: msg.rpcId,
+            ok: false,
+            message: `No one-tap install available for "${msg.runnerId}".`
+          });
+          return;
+        }
+        try {
+          const { stderr } = await execFileAsync(runner.installCommand.command, runner.installCommand.args, {
+            timeout: 18e4
+          });
+          this.runnerAvailability.set(runner.id, await runner.detect());
+          reply({
+            type: "runner-install-response",
+            rpcId: msg.rpcId,
+            ok: true,
+            message: stderr.trim() || "Installed."
+          });
+          await this.broadcastManifest();
+        } catch (e) {
+          const err = e;
+          const detail = (err.stderr?.trim() || err.message || String(e)).slice(0, 500);
+          reply({ type: "runner-install-response", rpcId: msg.rpcId, ok: false, message: detail });
+        }
+        return;
+      }
     }
   }
+  /** The daemon's own relay connection dropped — logged durably so a phone
+   * that wasn't listening live can still see it in the "left off" digest
+   * (Execution Plan 6), unlike the relay's ephemeral `presence` frame. */
+  recordDeviceOffline() {
+    this.record(SYSTEM_LOG_SESSION_ID, (seq) => ({ type: "device-offline", seq, atMs: Date.now() }));
+  }
+  /** A running agent proactively pushed a status note (Execution Plan 5's
+   * offhand_status_update MCP tool). Recorded into the normal session log
+   * (so it shows in the transcript and the run timeline) and cached as the
+   * latest note for this session, ready to enrich a Handover Packet later. */
+  recordStatusUpdate(sessionId, text) {
+    this.latestStatusUpdate.set(sessionId, text);
+    this.record(sessionId, (seq) => ({
+      type: "run-event",
+      sessionId,
+      runId: "",
+      seq,
+      event: { type: "status-update", text }
+    }));
+  }
+  /** Offhand Intelligence Phase 5 (Execution Plan 8) — the agent itself
+   * calls this via the offhand_context MCP tool, mid-run, instead of a
+   * human reviewing on the phone first. Same buildContext() mechanism and
+   * telemetry as the mobile review path (Phase 2); the tool's own response
+   * carries the same "may be incomplete, keep searching" framing so the
+   * agent's discovery is supplemented, never restricted. */
+  async buildContextFor(sessionId, query) {
+    const session = this.store.getSession(sessionId);
+    if (!session) return null;
+    const built = await buildContext(session.workspace, query);
+    this.record(sessionId, (seq) => ({
+      type: "run-event",
+      sessionId,
+      runId: "",
+      seq,
+      event: {
+        type: "intelligence-built",
+        promptChars: query.length,
+        contextChars: built?.meta.contextChars ?? 0,
+        filesConsidered: built?.meta.filesConsidered ?? 0,
+        filesSelected: built?.meta.filesSelected ?? 0,
+        retrievalOpsRun: built?.meta.retrievalOpsRun ?? 0,
+        durationMs: built?.meta.durationMs ?? 0,
+        ripgrepAvailable: built?.meta.ripgrepAvailable ?? false,
+        timedOut: built?.meta.timedOut ?? false,
+        attached: built !== null && built.block !== ""
+      }
+    }));
+    if (!built || built.block === "") return null;
+    return { block: built.block, filesSelected: built.meta.filesSelected };
+  }
+  recordDeviceReconnected(offlineForMs) {
+    this.record(SYSTEM_LOG_SESSION_ID, (seq) => ({
+      type: "device-reconnected",
+      seq,
+      atMs: Date.now(),
+      offlineForMs
+    }));
+  }
   async sendDropToPhone(path) {
     if (!this.uploader) throw new Error("drop upload unavailable: start daemon with --relay");
     const file = readOutgoingDrop(path);
@@ -6469,13 +7336,40 @@ var SessionManager = class {
   pump(sessionId) {
     if (this.active.has(sessionId)) return;
     const q2 = this.queues.get(sessionId);
-    const prompt = q2?.shift();
-    if (!prompt) return;
+    const item = q2?.shift();
+    if (!item) return;
     const session = this.store.getSession(sessionId);
     if (!session) return;
-    void this.runOne(session, prompt);
+    void this.runOne(session, item.prompt, item.block);
+  }
+  /** Appends staged-attachment file paths to a prompt — shared by `prompt`
+   * and `intelligence-prepare` so the two paths can't drift. Throws on
+   * fetch/write failure; callers turn that into an `error` reply. */
+  async stageAttachments(prompt, attachments) {
+    if (!attachments?.length || !this.attachmentFetcher) return prompt;
+    let out = prompt + "\n\nAttached files (read them from disk):";
+    for (const a2 of attachments) {
+      const bytes = await this.attachmentFetcher(a2.blobId);
+      const dir = join6(tmpdir(), "offhand-attachments");
+      mkdirSync2(dir, { recursive: true });
+      const path = join6(dir, `${a2.blobId.slice(0, 8)}-${basename3(a2.name)}`);
+      writeFileSync2(path, bytes);
+      out += `
+- ${path} (${a2.mime})`;
+    }
+    return out;
+  }
+  /** Pushes a prompt onto a session's queue and pumps it — the one place
+   * every prompt (plain, post-review, or a translated handover packet)
+   * enters execution, so none of those callers duplicate queue/pump/
+   * broadcast bookkeeping. */
+  enqueuePrompt(session, prompt, block) {
+    const q2 = this.queues.get(session.id) ?? [];
+    q2.push(block !== void 0 ? { prompt, block } : { prompt });
+    this.queues.set(session.id, q2);
+    this.pump(session.id);
   }
-  async runOne(session, prompt) {
+  async runOne(session, prompt, precomputedBlock) {
     const runner = this.runners.get(session.runnerId);
     if (!runner || !(this.runnerAvailability.get(session.runnerId) ?? false)) {
       this.record(session.id, (seq) => ({
@@ -6492,10 +7386,44 @@ var SessionManager = class {
     const touchedFiles = [];
     let toolCount = 0;
     let succeeded = false;
+    let limitHitEmitted = false;
+    let budgetWarned = false;
+    const hasStatusTool = runner.id === "claude-code" && session.permissionMode !== "bypass";
+    const preambled = session.conversationId ? prompt : `${MOBILE_SESSION_PREAMBLE_BASE}${hasStatusTool ? MOBILE_SESSION_PREAMBLE_STATUS_TOOL : ""}
+
+${prompt}`;
+    let sentPrompt = preambled;
+    if (precomputedBlock !== void 0) {
+      sentPrompt = preambled.replace(prompt, precomputedBlock);
+    } else if (process.env.OFFHAND_INTEL_DEBUG === "1") {
+      const built = await buildContext(session.workspace, prompt);
+      this.record(session.id, (seq) => ({
+        type: "run-event",
+        sessionId: session.id,
+        runId,
+        seq,
+        event: {
+          type: "intelligence-built",
+          promptChars: prompt.length,
+          contextChars: built?.meta.contextChars ?? 0,
+          filesConsidered: built?.meta.filesConsidered ?? 0,
+          filesSelected: built?.meta.filesSelected ?? 0,
+          retrievalOpsRun: built?.meta.retrievalOpsRun ?? 0,
+          durationMs: built?.meta.durationMs ?? 0,
+          ripgrepAvailable: built?.meta.ripgrepAvailable ?? false,
+          timedOut: built?.meta.timedOut ?? false,
+          attached: built !== null && built.block !== ""
+        }
+      }));
+      if (built && built.block !== "") {
+        sentPrompt = preambled.replace(prompt, built.block);
+      }
+    }
     const handle = runner.start(
       {
         runId,
-        prompt,
+        sessionId: session.id,
+        prompt: sentPrompt,
         workspace: session.workspace,
         ...session.model ? { model: session.model } : {},
         ...session.conversationId ? { resumeConversationId: session.conversationId } : {},
@@ -6528,6 +7456,17 @@ var SessionManager = class {
           seq,
           event
         }));
+        const limitHit = checkLimitHit(event, limitHitEmitted);
+        if (limitHit) {
+          limitHitEmitted = true;
+          this.record(session.id, (seq) => ({ type: "run-event", sessionId: session.id, runId, seq, event: limitHit }));
+          void this.proposeHandover(session, runId, limitHit.reason);
+        }
+        const budgetHit = checkBudgetWarning(event, session, budgetWarned) ?? checkTimeBudget(session, Date.now() - startedAt, budgetWarned);
+        if (budgetHit) {
+          budgetWarned = true;
+          this.record(session.id, (seq) => ({ type: "run-event", sessionId: session.id, runId, seq, event: budgetHit }));
+        }
       }
     } finally {
       this.active.delete(session.id);
@@ -6559,7 +7498,65 @@ var SessionManager = class {
       }));
     }
   }
+  /** Builds and offers a Handover Packet once a limit-hit fires. Entirely
+   * deterministic (live git diff + this session's own log) — no cooperation
+   * needed from the agent that just hit its limit, which is the point:
+   * this must still work when that agent is already dead or blocked, not
+   * only the graceful case. Silent (no card at all) when there's no other
+   * detected, available runner to hand off to — never a dead-end proposal. */
+  async proposeHandover(session, runId, reason) {
+    const target = this.pickHandoverTarget(session.runnerId);
+    if (!target) return;
+    const diff = await liveDiff(session.workspace);
+    const { items } = this.store.historyPage(session.id, 0, 500);
+    const packet = assembleHandoverPacket(items, diff);
+    const agentSummary = this.latestStatusUpdate.get(session.id);
+    if (agentSummary) packet.agentSummary = agentSummary;
+    const id = randomUUID();
+    this.pendingHandovers.set(id, { sessionId: session.id, toRunnerId: target.id, packet });
+    this.record(session.id, (seq) => ({
+      type: "run-event",
+      sessionId: session.id,
+      runId,
+      seq,
+      event: { type: "handover-proposed", id, fromRunnerId: session.runnerId, toRunnerId: target.id, reason, packet }
+    }));
+  }
+  /** First other detected+available runner — good enough for v1 (single
+   * candidate, not a picker); a real choice among several becomes relevant
+   * once more than one alternative is commonly available at once. */
+  pickHandoverTarget(currentRunnerId) {
+    for (const [id, runner] of this.runners) {
+      if (id === currentRunnerId) continue;
+      if (!(this.runnerAvailability.get(id) ?? false)) continue;
+      return runner;
+    }
+    return null;
+  }
 };
+var LIMIT_HIT_THRESHOLD = 0.9;
+function checkLimitHit(event, alreadyEmitted) {
+  if (alreadyEmitted || event.type !== "rate-limit") return null;
+  const utilization = Math.max(event.fiveHourUtilization, event.sevenDayUtilization);
+  if (utilization < LIMIT_HIT_THRESHOLD) return null;
+  return { type: "limit-hit", reason: "rate_limit", utilization };
+}
+function checkBudgetWarning(event, session, alreadyWarned) {
+  if (alreadyWarned || event.type !== "usage" || !session.budgetCostUsdCap) return null;
+  if (event.costUsd === void 0 || event.costUsd < session.budgetCostUsdCap) return null;
+  return { type: "budget-warning", kind: "cost", capUsd: session.budgetCostUsdCap, actualUsd: event.costUsd };
+}
+function checkTimeBudget(session, elapsedMs, alreadyWarned) {
+  if (alreadyWarned || !session.budgetMinutesCap) return null;
+  const minutes = elapsedMs / 6e4;
+  if (minutes < session.budgetMinutesCap) return null;
+  return {
+    type: "budget-warning",
+    kind: "time",
+    capMinutes: session.budgetMinutesCap,
+    actualMinutes: Math.round(minutes)
+  };
+}
 function trackTouches(event, touched) {
   if (event.type !== "tool") return;
   if (!/^(Edit|Write|MultiEdit|NotebookEdit)/.test(event.name)) return;
@@ -6576,16 +7573,16 @@ function listFolders(path) {
   const current = resolve3(path);
   const dirs = safeReadDir2(current).filter((entry) => entry.isDirectory() && !skipDir(entry.name)).map((entry) => {
     const full = join6(current, entry.name);
-    return { name: entry.name, path: full, isGit: existsSync6(join6(full, ".git")) };
+    return { name: entry.name, path: full, isGit: existsSync7(join6(full, ".git")) };
   }).sort((a2, b2) => Number(b2.isGit) - Number(a2.isGit) || a2.name.localeCompare(b2.name)).slice(0, 200);
-  return { path: current, parent: isRoot(current) ? null : dirname2(current), dirs };
+  return { path: current, parent: isRoot(current) ? null : dirname3(current), dirs };
 }
 function driveRoots() {
-  if (process.platform !== "win32") return [{ name: "/", path: "/", isGit: existsSync6("/.git") }];
+  if (process.platform !== "win32") return [{ name: "/", path: "/", isGit: existsSync7("/.git") }];
   const roots = [];
   for (let code = 67; code <= 90; code++) {
     const name = `${String.fromCharCode(code)}:\\`;
-    if (existsSync6(name)) roots.push({ name, path: name, isGit: existsSync6(join6(name, ".git")) });
+    if (existsSync7(name)) roots.push({ name, path: name, isGit: existsSync7(join6(name, ".git")) });
   }
   return roots.sort((a2, b2) => a2.name.localeCompare(b2.name)).slice(0, 200);
 }
@@ -6650,6 +7647,15 @@ var Store = class {
         dev_url TEXT
       );
       CREATE VIRTUAL TABLE IF NOT EXISTS log_fts USING fts5(text, session_id UNINDEXED, seq UNINDEXED);
+      CREATE TABLE IF NOT EXISTS device (
+        id INTEGER PRIMARY KEY CHECK (id = 1),
+        wol_capability TEXT,
+        wol_reason TEXT,
+        wol_network_type TEXT,
+        wol_mac TEXT,
+        wol_broadcast TEXT,
+        wol_checked_at_ms INTEGER
+      );
     `);
     try {
       this.db.exec(`ALTER TABLE workspaces ADD COLUMN policy TEXT NOT NULL DEFAULT 'balanced'`);
@@ -6663,6 +7669,18 @@ var Store = class {
       this.db.exec(`ALTER TABLE sessions ADD COLUMN effort TEXT`);
     } catch {
     }
+    try {
+      this.db.exec(`ALTER TABLE sessions ADD COLUMN budget_cost_usd_cap REAL`);
+    } catch {
+    }
+    try {
+      this.db.exec(`ALTER TABLE sessions ADD COLUMN budget_minutes_cap INTEGER`);
+    } catch {
+    }
+    try {
+      this.db.exec(`ALTER TABLE workspaces ADD COLUMN intelligence_mode TEXT NOT NULL DEFAULT 'off'`);
+    } catch {
+    }
   }
   // ---- sessions -------------------------------------------------------------
   createSession(workspace, runnerId, model, label) {
@@ -6676,7 +7694,9 @@ var Store = class {
       archived: false,
       conversationId: null,
       permissionMode: "guarded",
-      effort: null
+      effort: null,
+      budgetCostUsdCap: null,
+      budgetMinutesCap: null
     };
     this.db.prepare(
       `INSERT INTO sessions (id, workspace, runner_id, model, label, created_at_ms, archived, conversation_id)
@@ -6696,7 +7716,9 @@ var Store = class {
       archived: Boolean(r2.archived),
       conversationId: r2.conversation_id ?? null,
       permissionMode: r2.permission_mode ?? "guarded",
-      effort: r2.effort ?? null
+      effort: r2.effort ?? null,
+      budgetCostUsdCap: r2.budget_cost_usd_cap ?? null,
+      budgetMinutesCap: r2.budget_minutes_cap ?? null
     }));
   }
   getSession(id) {
@@ -6707,8 +7729,20 @@ var Store = class {
     if (!current) return;
     const next = { ...current, ...patch };
     this.db.prepare(
-      `UPDATE sessions SET label = ?, model = ?, archived = ?, conversation_id = ?, permission_mode = ?, effort = ? WHERE id = ?`
-    ).run(next.label, next.model, next.archived ? 1 : 0, next.conversationId, next.permissionMode, next.effort, id);
+      `UPDATE sessions SET label = ?, model = ?, archived = ?, conversation_id = ?, permission_mode = ?, effort = ?,
+         budget_cost_usd_cap = ?, budget_minutes_cap = ?, runner_id = ? WHERE id = ?`
+    ).run(
+      next.label,
+      next.model,
+      next.archived ? 1 : 0,
+      next.conversationId,
+      next.permissionMode,
+      next.effort,
+      next.budgetCostUsdCap,
+      next.budgetMinutesCap,
+      next.runnerId,
+      id
+    );
   }
   toSessionInfo(row, busy, queued) {
     return {
@@ -6722,7 +7756,9 @@ var Store = class {
       permissionMode: row.permissionMode,
       effort: row.effort ?? void 0,
       busy,
-      queuedPrompts: queued
+      queuedPrompts: queued,
+      budgetCostUsdCap: row.budgetCostUsdCap ?? void 0,
+      budgetMinutesCap: row.budgetMinutesCap ?? void 0
     };
   }
   // ---- transcript log ---------------------------------------------------------
@@ -6787,12 +7823,42 @@ var Store = class {
       path: r2.path,
       label: r2.label,
       devUrl: r2.dev_url ?? null,
-      policy: r2.policy ?? "balanced"
+      policy: r2.policy ?? "balanced",
+      intelligenceMode: r2.intelligence_mode ?? "off"
     }));
   }
   setWorkspacePolicy(path, policy) {
     this.db.prepare(`UPDATE workspaces SET policy = ? WHERE path = ?`).run(policy, path);
   }
+  setWorkspaceIntelligenceMode(path, mode) {
+    this.db.prepare(`UPDATE workspaces SET intelligence_mode = ? WHERE path = ?`).run(mode, path);
+  }
+  // ---- device capability (Execution Plan 7) ----------------------------------
+  getWolCapability() {
+    const row = this.db.prepare(`SELECT * FROM device WHERE id = 1`).get();
+    if (!row || row.wol_capability == null) return null;
+    return {
+      capability: row.wol_capability,
+      reason: row.wol_reason,
+      networkType: row.wol_network_type,
+      mac: row.wol_mac ?? null,
+      broadcast: row.wol_broadcast ?? null,
+      checkedAtMs: row.wol_checked_at_ms
+    };
+  }
+  setWolCapability(v2) {
+    this.db.prepare(
+      `INSERT INTO device (id, wol_capability, wol_reason, wol_network_type, wol_mac, wol_broadcast, wol_checked_at_ms)
+         VALUES (1, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           wol_capability = excluded.wol_capability,
+           wol_reason = excluded.wol_reason,
+           wol_network_type = excluded.wol_network_type,
+           wol_mac = excluded.wol_mac,
+           wol_broadcast = excluded.wol_broadcast,
+           wol_checked_at_ms = excluded.wol_checked_at_ms`
+    ).run(v2.capability, v2.reason, v2.networkType, v2.mac, v2.broadcast, v2.checkedAtMs);
+  }
 };
 function searchableText(msg) {
   switch (msg.type) {
@@ -6803,6 +7869,7 @@ function searchableText(msg) {
       if (msg.event.type === "tool") return msg.event.summary;
       if (msg.event.type === "done") return msg.event.summary;
       if (msg.event.type === "error") return msg.event.message;
+      if (msg.event.type === "status-update") return msg.event.text;
       return "";
     case "drop":
       return msg.name;
@@ -10872,11 +11939,42 @@ var ApprovalQuestionSchema = external_exports.object({
   options: external_exports.array(external_exports.object({ label: external_exports.string(), description: external_exports.string().optional() })),
   multiSelect: external_exports.boolean().optional()
 });
+var TodoItemSchema = external_exports.object({
+  content: external_exports.string(),
+  status: external_exports.enum(["pending", "in_progress", "completed"]),
+  activeForm: external_exports.string().optional()
+});
+var HandoverPacketSchema = external_exports.object({
+  /** Live `git diff HEAD` against the workspace, captured at handover time. */
+  diff: external_exports.string(),
+  /** Tool-call summaries this session made, oldest first, capped to the most recent. */
+  toolSummaries: external_exports.array(external_exports.string()),
+  /** The last TodoWrite call's task list, verbatim — never summarized. */
+  todos: external_exports.array(TodoItemSchema).optional(),
+  /** Approvals raised but never resolved (still pending or timed out) at handover time. */
+  pendingApprovals: external_exports.array(
+    external_exports.object({ action: external_exports.string(), detail: external_exports.string(), risk: external_exports.enum(["low", "high"]) })
+  ),
+  /** Recent prompt/response turns, oldest first, capped — for tone/context continuity. */
+  recentMessages: external_exports.array(external_exports.object({ role: external_exports.enum(["user", "assistant"]), text: external_exports.string() })),
+  /** Optional free-text self-summary from the outgoing agent — enrichment
+   * only, attempted when there was runway before a hard cutoff. Its absence
+   * changes nothing; the packet above is already sufficient on its own. */
+  agentSummary: external_exports.string().optional()
+});
 var RunEventSchema = external_exports.discriminatedUnion("type", [
   external_exports.object({ type: external_exports.literal("text"), chunk: external_exports.string() }),
   /** Extended-thinking content, streamed the same way as text (medium+ effort tiers). */
   external_exports.object({ type: external_exports.literal("thinking"), chunk: external_exports.string() }),
-  external_exports.object({ type: external_exports.literal("tool"), name: external_exports.string(), summary: external_exports.string() }),
+  external_exports.object({
+    type: external_exports.literal("tool"),
+    name: external_exports.string(),
+    summary: external_exports.string(),
+    /** Structured payload for calls that matter to continuity (TodoWrite's
+     * actual task list). Optional: most tool calls have none, and omitting
+     * it is always safe — `summary` alone still renders the transcript. */
+    todos: external_exports.array(TodoItemSchema).optional()
+  }),
   external_exports.object({
     type: external_exports.literal("approval"),
     id: external_exports.string(),
@@ -10921,12 +12019,87 @@ var RunEventSchema = external_exports.discriminatedUnion("type", [
     fiveHourResetsAtMs: external_exports.number(),
     sevenDayUtilization: external_exports.number(),
     sevenDayResetsAtMs: external_exports.number()
+  }),
+  /** Emitted once, when the daemon's own threshold check crosses before the
+   * CLI itself refuses — the phone's cue to propose a handover (Execution
+   * Plan 5) while there's still runway to do it gracefully. */
+  external_exports.object({
+    type: external_exports.literal("limit-hit"),
+    reason: external_exports.enum(["rate_limit", "context_window", "cost_cap"]),
+    /** 0-1 utilization that crossed the threshold, when known. */
+    utilization: external_exports.number().optional()
+  }),
+  /** Session cost or wall-clock time crossed the cap set on it (Execution
+   * Plan 1's budget feature) — informational, the run is not cancelled. */
+  external_exports.object({
+    type: external_exports.literal("budget-warning"),
+    kind: external_exports.enum(["cost", "time"]),
+    capUsd: external_exports.number().optional(),
+    capMinutes: external_exports.number().optional(),
+    actualUsd: external_exports.number().optional(),
+    actualMinutes: external_exports.number().optional()
+  }),
+  /** The daemon is offering to move this session to another runner
+   * (Execution Plan 4) — built from the log/diff alone, never from asking
+   * this agent to cooperate (it may already be unable to). */
+  external_exports.object({
+    type: external_exports.literal("handover-proposed"),
+    id: external_exports.string(),
+    fromRunnerId: external_exports.string(),
+    toRunnerId: external_exports.string(),
+    reason: external_exports.enum(["rate_limit", "context_window", "cost_cap", "crash", "manual"]),
+    packet: HandoverPacketSchema
+  }),
+  external_exports.object({
+    type: external_exports.literal("handover-declined"),
+    id: external_exports.string()
+  }),
+  external_exports.object({
+    type: external_exports.literal("handover-accepted"),
+    id: external_exports.string(),
+    fromRunnerId: external_exports.string(),
+    toRunnerId: external_exports.string()
+  }),
+  /** A proactive note the agent chose to push mid-run (Execution Plan 5's
+   * offhand_status_update MCP tool) — outside the normal streamed
+   * text/thinking, and never fabricated: only exists when the agent itself
+   * called the tool. The most recent one on a session also becomes the
+   * Handover Packet's optional `agentSummary` (Execution Plan 4) when a
+   * handover is proposed afterward — still zero hosted AI, since it's the
+   * same agent, on its own tokens, choosing to leave a note. */
+  external_exports.object({
+    type: external_exports.literal("status-update"),
+    text: external_exports.string()
+  }),
+  /** Telemetry for Offhand Intelligence's Phase 1 (Execution Plan 8) — one
+   * record per run where the deterministic context-injection step actually
+   * ran, so Intelligence-ON vs Intelligence-OFF is eventually a real
+   * measurement, not a guess. Never carries the context block's own text —
+   * just the shape of what happened — reusing the existing event-log spine
+   * rather than a parallel telemetry system. */
+  external_exports.object({
+    type: external_exports.literal("intelligence-built"),
+    promptChars: external_exports.number().int(),
+    contextChars: external_exports.number().int(),
+    filesConsidered: external_exports.number().int(),
+    filesSelected: external_exports.number().int(),
+    retrievalOpsRun: external_exports.number().int(),
+    durationMs: external_exports.number().int(),
+    ripgrepAvailable: external_exports.boolean(),
+    timedOut: external_exports.boolean(),
+    /** Whether the block was actually attached to the run (false when
+     * buildContext found nothing worth attaching, or timed out). */
+    attached: external_exports.boolean()
   })
 ]);
 var PermissionModeSchema = external_exports.enum(["guarded", "plan", "acceptEdits", "bypass"]);
 var EffortSchema = external_exports.enum(["low", "medium", "high", "max"]);
 var RunSpecSchema = external_exports.object({
   runId: external_exports.string(),
+  /** The offhand session this run belongs to — lets an MCP bridge tool
+   * (Execution Plan 5) tag a proactive call (status update, dropped file)
+   * with the right session without a global single-listener broker. */
+  sessionId: external_exports.string(),
   prompt: external_exports.string().min(1),
   /** Absolute path of the workspace the agent runs in. */
   workspace: external_exports.string(),
@@ -10951,9 +12124,22 @@ var RunnerInfoSchema = external_exports.object({
   version: external_exports.string().optional(),
   /** Model ids the phone may offer; empty = CLI default only. */
   models: external_exports.array(external_exports.string()),
-  supportsApprovals: external_exports.boolean()
+  supportsApprovals: external_exports.boolean(),
+  /** Thinking-budget tiers this runner actually honors (Execution Plan 3) —
+   * undefined means the phone should hide the effort control entirely for
+   * this runner, not show one that silently does nothing. */
+  effortTiers: external_exports.array(external_exports.enum(["low", "medium", "high", "max"])).optional(),
+  /** Display string for the vendor's own install command (e.g. "npm install
+   * -g @anthropic-ai/claude-code") — present only when the daemon can run
+   * it unattended via `runner-install`. */
+  installCommand: external_exports.string().optional(),
+  /** Where to send the user instead, when there's no safe one-tap install
+   * (a piped shell-script installer, a GUI app, etc.) — never set alongside
+   * installCommand. */
+  installUrl: external_exports.string().optional()
 });
 var ApprovalPolicySchema = external_exports.enum(["paranoid", "balanced", "trusting"]);
+var IntelligenceModeSchema = external_exports.enum(["off", "automatic", "manual"]);
 var WorkspaceInfoSchema = external_exports.object({
   path: external_exports.string(),
   label: external_exports.string(),
@@ -10962,7 +12148,8 @@ var WorkspaceInfoSchema = external_exports.object({
   devUrl: external_exports.string().optional(),
   /** Approval policy: paranoid = ask everything the CLI would ask; balanced =
    * same (default); trusting = auto-approve low-risk, ask only high-risk. */
-  policy: ApprovalPolicySchema
+  policy: ApprovalPolicySchema,
+  intelligenceMode: IntelligenceModeSchema
 });
 var SessionInfoSchema = external_exports.object({
   id: external_exports.string(),
@@ -10978,12 +12165,23 @@ var SessionInfoSchema = external_exports.object({
   effort: external_exports.enum(["low", "medium", "high", "max"]).optional(),
   /** Whether a run is active or prompts are queued right now. */
   busy: external_exports.boolean(),
-  queuedPrompts: external_exports.number().int()
+  queuedPrompts: external_exports.number().int(),
+  /** Per-session budget caps (Execution Plan 1) — undefined means no cap set. */
+  budgetCostUsdCap: external_exports.number().optional(),
+  budgetMinutesCap: external_exports.number().int().optional()
 });
 var HostInfoSchema = external_exports.object({
   hostname: external_exports.string(),
   os: external_exports.string(),
-  daemonVersion: external_exports.string()
+  daemonVersion: external_exports.string(),
+  /** Wake-on-LAN/WiFi capability, detected per device (Execution Plan 7) —
+   * never assumed from the OS alone. Absent only if no probe has completed
+   * yet (e.g. mid-startup). */
+  wolCapability: external_exports.enum(["supported", "wifi-limited", "unsupported"]).optional(),
+  /** Human-readable reason behind wolCapability — always present alongside
+   * it, since a bare enum can't explain itself. */
+  wolReason: external_exports.string().optional(),
+  wolCheckedAtMs: external_exports.number().int().optional()
 });
 
 // ../shared/src/protocol-v2.ts
@@ -11017,6 +12215,12 @@ var ClientMessageSchema = external_exports.discriminatedUnion("type", [
     answer: external_exports.string().optional()
   }),
   external_exports.object({ type: external_exports.literal("resume"), afterSeq: external_exports.number().int().nonnegative() }),
+  external_exports.object({
+    type: external_exports.literal("handover-response"),
+    sessionId: external_exports.string(),
+    handoverId: external_exports.string(),
+    accept: external_exports.boolean()
+  }),
   external_exports.object({
     type: external_exports.literal("drop-send"),
     blobId: external_exports.string(),
@@ -11047,7 +12251,10 @@ var ClientMessageSchema = external_exports.discriminatedUnion("type", [
     model: external_exports.string().optional(),
     archived: external_exports.boolean().optional(),
     permissionMode: external_exports.enum(["guarded", "plan", "acceptEdits", "bypass"]).optional(),
-    effort: external_exports.enum(["low", "medium", "high", "max"]).optional()
+    effort: external_exports.enum(["low", "medium", "high", "max"]).optional(),
+    /** Per-session budget caps (Execution Plan 1). null clears an existing cap. */
+    budgetCostUsdCap: external_exports.number().positive().nullable().optional(),
+    budgetMinutesCap: external_exports.number().int().positive().nullable().optional()
   }),
   /** Start a fresh agent conversation inside the session. */
   external_exports.object({ type: external_exports.literal("session-reset"), sessionId: external_exports.string() }),
@@ -11057,6 +12264,29 @@ var ClientMessageSchema = external_exports.discriminatedUnion("type", [
     workspace: external_exports.string(),
     policy: ApprovalPolicySchema
   }),
+  /** Set a workspace's Offhand Intelligence mode (Execution Plan 8). */
+  external_exports.object({
+    type: external_exports.literal("intelligence-set"),
+    workspace: external_exports.string(),
+    mode: IntelligenceModeSchema
+  }),
+  /** Like `prompt`, but routes through Offhand Intelligence first — the
+   * daemon replies with `intelligence-review` instead of queueing
+   * immediately, and queueing happens only after `intelligence-response`. */
+  external_exports.object({
+    type: external_exports.literal("intelligence-prepare"),
+    sessionId: external_exports.string(),
+    prompt: external_exports.string().min(1),
+    attachments: external_exports.array(external_exports.object({ blobId: external_exports.string(), name: external_exports.string(), mime: external_exports.string() })).optional()
+  }),
+  /** Resolves a pending `intelligence-review` — useContext=false sends the
+   * plain original prompt, never a dead end that discards it. */
+  external_exports.object({
+    type: external_exports.literal("intelligence-response"),
+    sessionId: external_exports.string(),
+    reviewId: external_exports.string(),
+    useContext: external_exports.boolean()
+  }),
   // History RPC (request/response by rpcId; responses are not in the seq log)
   external_exports.object({
     type: external_exports.literal("history-request"),
@@ -11081,7 +12311,24 @@ var ClientMessageSchema = external_exports.discriminatedUnion("type", [
     type: external_exports.literal("fs-list"),
     rpcId: external_exports.string(),
     path: external_exports.string().optional()
-  })
+  }),
+  /** Mobile-first session bootstrap (Execution Plan 5): create a new project
+   * folder from the phone's workspace browser, no laptop needed first. */
+  external_exports.object({
+    type: external_exports.literal("fs-create-folder"),
+    rpcId: external_exports.string(),
+    path: external_exports.string(),
+    name: external_exports.string().min(1)
+  }),
+  /** Re-run the Wake-on-LAN/WiFi capability probe (Execution Plan 7) — an
+   * explicit "check again" action, since drivers/BIOS settings/network type
+   * can change after first setup. */
+  external_exports.object({ type: external_exports.literal("wol-recheck") }),
+  /** One-tap install: run a runner's own vendor install command on the
+   * daemon's machine. Only valid for a runner whose manifest entry carries
+   * `installCommand` — the daemon refuses (with a reply, not a hang) for
+   * any other runnerId. */
+  external_exports.object({ type: external_exports.literal("runner-install"), rpcId: external_exports.string(), runnerId: external_exports.string() })
 ]);
 var ReceiptSchema = external_exports.object({
   runId: external_exports.string(),
@@ -11139,6 +12386,37 @@ var ServerMessageSchema = external_exports.discriminatedUnion("type", [
     size: external_exports.number().int().nonnegative(),
     direction: external_exports.enum(["to-phone", "to-pc"])
   }),
+  /** The daemon's own relay connection dropped/came back — logged durably
+   * (unlike the relay's live `presence` frame) so a phone that wasn't
+   * listening at the time can still reconstruct "laptop asleep since 11pm"
+   * from history (Execution Plan 6's digest). Not tied to any run. */
+  external_exports.object({ type: external_exports.literal("device-offline"), seq: external_exports.number().int(), atMs: external_exports.number().int() }),
+  external_exports.object({
+    type: external_exports.literal("device-reconnected"),
+    seq: external_exports.number().int(),
+    atMs: external_exports.number().int(),
+    offlineForMs: external_exports.number().int().nonnegative()
+  }),
+  /** Offhand Intelligence (Execution Plan 8) proposed a context block for a
+   * prompt not yet queued to any runner — not a RunEvent, since no run
+   * exists at this point. `filesSelected` is a quick summary for the sheet
+   * header; the full reasoning lives in `block` itself. */
+  external_exports.object({
+    type: external_exports.literal("intelligence-review"),
+    sessionId: external_exports.string(),
+    seq: external_exports.number().int(),
+    reviewId: external_exports.string(),
+    originalPrompt: external_exports.string(),
+    block: external_exports.string(),
+    filesSelected: external_exports.number().int()
+  }),
+  external_exports.object({
+    type: external_exports.literal("intelligence-resolved"),
+    sessionId: external_exports.string(),
+    seq: external_exports.number().int(),
+    reviewId: external_exports.string(),
+    useContext: external_exports.boolean()
+  }),
   // RPC responses (not seq-logged)
   external_exports.object({
     type: external_exports.literal("history-response"),
@@ -11164,7 +12442,21 @@ var ServerMessageSchema = external_exports.discriminatedUnion("type", [
     rpcId: external_exports.string(),
     path: external_exports.string(),
     parent: external_exports.string().nullable(),
-    dirs: external_exports.array(FsDirSchema)
+    dirs: external_exports.array(FsDirSchema),
+    /** Set only by fs-create-folder on failure — the generic top-level
+     * `error` message carries no rpcId, so it can never resolve a specific
+     * pending RPC (see client.ts's rpc()); this keeps the failure correctly
+     * routed back to whoever asked, with the listing unchanged either way. */
+    error: external_exports.string().optional()
+  }),
+  /** Reply to `runner-install` — always sent, success or failure, never a
+   * silent hang. On failure `message` carries the real error (e.g. npm's
+   * own stderr tail), not a generic "install failed". */
+  external_exports.object({
+    type: external_exports.literal("runner-install-response"),
+    rpcId: external_exports.string(),
+    ok: external_exports.boolean(),
+    message: external_exports.string()
   }),
   external_exports.object({ type: external_exports.literal("error"), message: external_exports.string() })
 ]);
@@ -11188,7 +12480,8 @@ var RelayFrameSchema = external_exports.discriminatedUnion("kind", [
    */
   external_exports.object({
     kind: external_exports.literal("notify"),
-    notice: external_exports.enum(["approval", "drop", "done", "error", "progress"]),
+    notice: external_exports.enum(["approval", "drop", "done", "error", "progress", "handover", "limit-hit"]),
+    /** 'approval'/'handover' only — the approval/handover id being acted on. */
     id: external_exports.string().optional(),
     sessionId: external_exports.string().optional(),
     /** 'progress' only — a bare action count, never the action itself (no content in push). */
@@ -11196,6 +12489,16 @@ var RelayFrameSchema = external_exports.discriminatedUnion("kind", [
   }),
   /** relay → daemon: verdict delivered via push-notification action button. */
   external_exports.object({ kind: external_exports.literal("verdict"), approvalId: external_exports.string(), approve: external_exports.boolean() }),
+  /** relay → daemon: handover accept/decline from a push-notification action
+   * button (Execution Plan 6) — same "opaque ids only" shape as `verdict`,
+   * with `chatSessionId` since handover-response needs it to look up the
+   * pending proposal. */
+  external_exports.object({
+    kind: external_exports.literal("handover-verdict"),
+    handoverId: external_exports.string(),
+    chatSessionId: external_exports.string(),
+    accept: external_exports.boolean()
+  }),
   external_exports.object({ kind: external_exports.literal("ping") }),
   external_exports.object({ kind: external_exports.literal("pong") })
 ]);
@@ -41803,6 +43106,36 @@ var LocalSessionServer = class {
       }
       return;
     }
+    if (req.method === "POST" && req.url === "/status") {
+      try {
+        const chunks = [];
+        for await (const c2 of req) chunks.push(c2);
+        const body = JSON.parse(Buffer.concat(chunks).toString());
+        if (typeof body.sessionId === "string" && typeof body.text === "string" && body.text.trim()) {
+          this.manager.recordStatusUpdate(body.sessionId, body.text.trim());
+        }
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify({ ok: true }));
+      } catch (e) {
+        res.writeHead(400, { "content-type": "application/json" });
+        res.end(JSON.stringify({ ok: false, message: `bad status request: ${String(e)}` }));
+      }
+      return;
+    }
+    if (req.method === "POST" && req.url === "/context") {
+      try {
+        const chunks = [];
+        for await (const c2 of req) chunks.push(c2);
+        const body = JSON.parse(Buffer.concat(chunks).toString());
+        const result = typeof body.sessionId === "string" && typeof body.query === "string" && body.query.trim() ? await this.manager.buildContextFor(body.sessionId, body.query.trim()) : null;
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify(result ?? { block: null, filesSelected: 0 }));
+      } catch (e) {
+        res.writeHead(400, { "content-type": "application/json" });
+        res.end(JSON.stringify({ block: null, filesSelected: 0, message: `bad context request: ${String(e)}` }));
+      }
+      return;
+    }
     res.writeHead(404);
     res.end();
   }
@@ -41838,8 +43171,19 @@ var RelayClient = class {
   heartbeat = null;
   detach = null;
   stopped = false;
+  /** Set when a heartbeat ping goes out; cleared by ANY inbound frame. If
+   * still set on the next tick, nothing has answered in a full interval —
+   * the connection is a zombie (readyState still reports OPEN even though
+   * the underlying TCP connection died silently, e.g. after laptop sleep or
+   * a NAT/firewall idle timeout — no close/error event fires on its own). */
+  awaitingPongSince = null;
   /** sessionId → tool-call count for the in-flight run (opaque count only, never the action). */
   toolCounts = /* @__PURE__ */ new Map();
+  /** True once we've been online at least once — a failed first connection
+   * attempt isn't "going offline" (there was nothing to lose), so the very
+   * first successful open never logs a reconnect. */
+  everConnected = false;
+  offlineSinceMs = null;
   start() {
     this.connect();
   }
@@ -41854,8 +43198,13 @@ var RelayClient = class {
   }
   connect() {
     if (this.stopped) return;
+    console.log(`relay: connecting (${this.relayUrl})`);
     const ws = new wrapper_default(this.url());
     this.ws = ws;
+    const slowStartTimer = setTimeout(() => {
+      console.log("relay: still connecting \u2014 the hosted relay may be waking up from a cold start (can take up to a minute)");
+    }, 8e3);
+    const clearSlowStartTimer = () => clearTimeout(slowStartTimer);
     const send = (msg) => {
       if (ws.readyState === wrapper_default.OPEN) {
         const envelope = seal(msg, this.keys.tx);
@@ -41895,24 +43244,52 @@ var RelayClient = class {
             JSON.stringify({ kind: "notify", notice: "error", sessionId: msg.sessionId })
           );
         }
+        if (msg.type === "run-event" && msg.event.type === "handover-proposed") {
+          ws.send(
+            JSON.stringify({
+              kind: "notify",
+              notice: "handover",
+              id: msg.event.id,
+              sessionId: msg.sessionId
+            })
+          );
+        }
+        if (msg.type === "run-event" && msg.event.type === "limit-hit") {
+          ws.send(
+            JSON.stringify({ kind: "notify", notice: "limit-hit", sessionId: msg.sessionId })
+          );
+        }
         if (msg.type === "drop" && msg.direction === "to-phone") {
           ws.send(JSON.stringify({ kind: "notify", notice: "drop" }));
         }
       }
     };
     ws.on("open", () => {
+      clearSlowStartTimer();
       this.backoffMs = 500;
+      this.awaitingPongSince = null;
       console.log(`relay: connected (${this.relayUrl})`);
+      if (this.everConnected && this.offlineSinceMs !== null) {
+        this.manager.recordDeviceReconnected(Date.now() - this.offlineSinceMs);
+      }
+      this.everConnected = true;
+      this.offlineSinceMs = null;
       this.detach = this.manager.attach(send);
       send(this.manager.hello());
       void this.manager.manifest().then(send);
       this.heartbeat = setInterval(() => {
-        if (ws.readyState === wrapper_default.OPEN) {
-          ws.send(JSON.stringify({ kind: "ping" }));
+        if (ws.readyState !== wrapper_default.OPEN) return;
+        if (this.awaitingPongSince !== null) {
+          console.log("relay: no response since last heartbeat \u2014 reconnecting");
+          ws.terminate();
+          return;
         }
+        this.awaitingPongSince = Date.now();
+        ws.send(JSON.stringify({ kind: "ping" }));
       }, HEARTBEAT_MS);
     });
     ws.on("message", (raw) => {
+      this.awaitingPongSince = null;
       let frame;
       try {
         frame = parseRelayFrame(raw.toString());
@@ -41926,6 +43303,18 @@ var RelayClient = class {
         );
         return;
       }
+      if (frame.kind === "handover-verdict") {
+        this.manager.handle(
+          {
+            type: "handover-response",
+            sessionId: frame.chatSessionId,
+            handoverId: frame.handoverId,
+            accept: frame.accept
+          },
+          send
+        );
+        return;
+      }
       if (frame.kind !== "peer") return;
       try {
         const envelope = EnvelopeSchema.parse(frame.payload);
@@ -41938,7 +43327,12 @@ var RelayClient = class {
       console.error(`relay: ${err.message}`);
     });
     ws.on("close", () => {
+      clearSlowStartTimer();
       this.cleanup();
+      if (this.everConnected && this.offlineSinceMs === null) {
+        this.offlineSinceMs = Date.now();
+        this.manager.recordDeviceOffline();
+      }
       if (this.stopped) return;
       console.log(`relay: disconnected \u2014 retrying in ${this.backoffMs}ms`);
       setTimeout(() => this.connect(), this.backoffMs);
@@ -41954,7 +43348,7 @@ var RelayClient = class {
 };
 
 // ../daemon/src/pairing.ts
-import { existsSync as existsSync7, readFileSync as readFileSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4 } from "node:fs";
+import { existsSync as existsSync8, readFileSync as readFileSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
 import { join as join8 } from "node:path";
 import { randomInt } from "node:crypto";
@@ -41964,7 +43358,7 @@ var POLL_MS = 2e3;
 var POLL_TIMEOUT_MS = 10 * 60 * 1e3;
 async function ensurePairing(relayUrl2, forceNew = false, webUrl2 = "https://offhand-web.onrender.com") {
   await ready;
-  if (!forceNew && existsSync7(PAIRING_PATH)) {
+  if (!forceNew && existsSync8(PAIRING_PATH)) {
     const f2 = JSON.parse(readFileSync4(PAIRING_PATH, "utf8"));
     const kp2 = { publicKey: fromB64u(f2.daemonPublicKey), secretKey: fromB64u(f2.daemonSecretKey) };
     const phonePk = fromB64u(f2.phonePublicKey);
@@ -42118,6 +43512,7 @@ var ApprovalBroker = class {
   }
 };
 function classifyRisk(toolName, input) {
+  if (toolName === "offhand_send_file") return "high";
   const i2 = input ?? {};
   const text = [toolName, i2.command, i2.file_path, i2.path, i2.filepath].filter((x2) => typeof x2 === "string").join(" ");
   return /\b(rm|del|rmdir|rd|format|mkfs|shutdown|reboot|kill|drop\s+table|truncate|git\s+push\s+--force|--hard)\b/i.test(
@@ -42171,9 +43566,9 @@ function buildPreview(toolName, input) {
   return void 0;
 }
 function formatUnifiedDiff(diff) {
-  const lines = diff.split("\n");
-  const hunkStart = lines.findIndex((l2) => l2.startsWith("@@"));
-  return (hunkStart >= 0 ? lines.slice(hunkStart) : lines).join("\n").trimEnd();
+  return diff.split("\n").filter(
+    (l2) => !l2.startsWith("index ") && !l2.startsWith("Index:") && !/^={3,}$/.test(l2) && !/^(new|deleted) file mode /.test(l2) && !/^(old|new) mode /.test(l2)
+  ).join("\n").trimEnd();
 }
 function truncate6(s2, max) {
   return s2.length <= max ? s2 : s2.slice(0, max - 1) + "\u2026";
@@ -42213,12 +43608,12 @@ async function downloadArtifact(relayUrl2, sessionId, blobId, keys) {
 
 // ../daemon/src/autostart.ts
 import { homedir as homedir8 } from "node:os";
-import { join as join10, resolve as resolve4, dirname as dirname3 } from "node:path";
-import { existsSync as existsSync8, readFileSync as readFileSync5, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5, rmSync } from "node:fs";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { join as join10, resolve as resolve4, dirname as dirname4 } from "node:path";
+import { existsSync as existsSync9, readFileSync as readFileSync5, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5, rmSync } from "node:fs";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { spawnSync } from "node:child_process";
 import { tmpdir as tmpdir3 } from "node:os";
-var __dirname2 = dirname3(fileURLToPath3(import.meta.url));
+var __dirname2 = dirname4(fileURLToPath4(import.meta.url));
 var SHORTCUT_NAME = "OffhandDaemon.lnk";
 var OFFHAND_HOME = process.env.OFFHAND_HOME ?? join10(homedir8(), ".offhand");
 function getStartupDir() {
@@ -42235,27 +43630,23 @@ function getWrapperPath() {
 function getShortcutPath() {
   return join10(getStartupDir(), SHORTCUT_NAME);
 }
-function buildWrapperScript(config) {
-  const projectRoot = resolve4(__dirname2, "..", "..");
-  const wsArgs2 = config.workspaces.map((w2) => `--workspace "${w2}"`).join(" ");
-  const relayArg = config.relayUrl ? `--relay "${config.relayUrl}"` : "";
-  const devUrlArg = config.devUrl ? `--dev-url "${config.devUrl}"` : "";
-  const portArg = `--port ${config.port}`;
-  const approvalArg = `--approval-timeout ${config.approvalTimeout ?? 300}`;
-  const webUrlArg = `--web-url "${config.webUrl ?? "https://offhand-web.onrender.com"}"`;
-  const parts = [
-    "pnpm --filter @offhand/daemon dev",
-    wsArgs2,
-    relayArg,
-    devUrlArg,
-    portArg,
-    approvalArg,
-    webUrlArg
-  ].filter(Boolean);
-  const cmd = parts.join(" ");
-  return `@echo off
-cd /d "${projectRoot}"
-${cmd}
+function buildWrapperScript(config2, entry = process.argv[1] ?? "", execPath = process.execPath) {
+  const wsArgs2 = config2.workspaces.map((w2) => `--workspace "${w2}"`).join(" ");
+  const relayArg = config2.relayUrl ? `--relay "${config2.relayUrl}"` : "";
+  const devUrlArg = config2.devUrl ? `--dev-url "${config2.devUrl}"` : "";
+  const portArg = `--port ${config2.port}`;
+  const approvalArg = `--approval-timeout ${config2.approvalTimeout ?? 300}`;
+  const webUrlArg = `--web-url "${config2.webUrl ?? "https://offhand-web.onrender.com"}"`;
+  const args2 = [wsArgs2, relayArg, devUrlArg, portArg, approvalArg, webUrlArg].filter(Boolean).join(" ");
+  if (entry.endsWith(".ts")) {
+    const projectRoot = resolve4(__dirname2, "..", "..");
+    return `@echo off\r
+cd /d "${projectRoot}"\r
+pnpm --filter @offhand/daemon dev -- ${args2}\r
+`;
+  }
+  return `@echo off\r
+"${execPath}" "${entry}" ${args2}\r
 `;
 }
 function createShortcut(targetPath, shortcutPath) {
@@ -42276,11 +43667,11 @@ $Shortcut.Save()`;
   return { success: result.status === 0, output: result.stdout + result.stderr };
 }
 function checkShortcutExists(shortcutPath) {
-  return existsSync8(shortcutPath);
+  return existsSync9(shortcutPath);
 }
-function installAutostart(config) {
+function installAutostart(config2) {
   const wrapperPath = getWrapperPath();
-  const script = buildWrapperScript(config);
+  const script = buildWrapperScript(config2);
   writeFileSync4(wrapperPath, script);
   const shortcutPath = getShortcutPath();
   const result = createShortcut(wrapperPath, shortcutPath);
@@ -42296,7 +43687,7 @@ function getAutostartStatus() {
   const shortcutPath = getShortcutPath();
   const installed = checkShortcutExists(shortcutPath);
   const wrapperPath = getWrapperPath();
-  const wrapperExists = existsSync8(wrapperPath);
+  const wrapperExists = existsSync9(wrapperPath);
   let details = `Shortcut: ${shortcutPath} (${installed ? "EXISTS" : "MISSING"})`;
   if (wrapperExists) {
     details += `
@@ -42304,14 +43695,13 @@ Wrapper: ${wrapperPath} (EXISTS)`;
   }
   return { installed, details };
 }
-function saveConfig(config) {
+function saveConfig(config2) {
   const configPath = join10(OFFHAND_HOME, "autostart.json");
-  writeFileSync4(configPath, JSON.stringify(config, null, 2));
+  writeFileSync4(configPath, JSON.stringify(config2, null, 2));
 }
 function getConfigFromStore() {
-  const workspaces = ["C:\\Users\\udbha\\dev\\offhand"];
   return {
-    workspaces,
+    workspaces: [],
     port: 4317,
     relayUrl: void 0,
     devUrl: void 0,
@@ -42354,7 +43744,7 @@ var devUrl = argValue("--dev-url");
 var store = new Store();
 var wsArgs = argValues("--workspace").map((w2) => resolve5(w2));
 for (const w2 of wsArgs) {
-  if (!existsSync9(w2)) {
+  if (!existsSync10(w2)) {
     console.error(`workspace does not exist: ${w2}`);
     process.exit(1);
   }
@@ -42363,10 +43753,11 @@ for (const w2 of wsArgs) {
 if (store.listWorkspaces().length === 0) store.upsertWorkspace(process.cwd(), devUrl);
 var broker = new ApprovalBroker(approvalTimeoutMs);
 var approvalUrl = `http://127.0.0.1:${port}/approval`;
+var statusUrl = approvalUrl.replace(/\/approval$/, "/status");
 var runners = [
   new ClaudeCodeRunner(broker, approvalUrl),
   new CopilotCliRunner(),
-  new OpenCodeRunner(broker),
+  new OpenCodeRunner(broker, statusUrl),
   new CodexCliRunner(),
   new CursorAgentRunner(),
   new GeminiCliRunner()
@@ -42387,25 +43778,20 @@ if (m2.type === "manifest") {
 new LocalSessionServer(manager, port, broker);
 console.log(`  local     : ws://127.0.0.1:${port}`);
 console.log(`  approvals : timeout ${approvalTimeoutMs / 1e3}s then auto-deny`);
-var autostartStatus = getAutostartStatus();
-if (!autostartStatus.installed) {
-  console.log(`  autostart : installing...`);
-  const config = getConfigFromStore();
-  config.workspaces = store.listWorkspaces().map((w2) => w2.path);
-  config.port = port;
-  config.relayUrl = relayUrl;
-  config.devUrl = devUrl;
-  config.approvalTimeout = approvalTimeoutMs / 1e3;
-  config.webUrl = webUrl;
-  saveConfig(config);
-  const { success, output } = installAutostart(config);
-  if (success) {
-    console.log(`  autostart : installed (runs on login)`);
-  } else {
-    console.warn(`  autostart : failed to install: ${output}`);
-  }
+var wasInstalled = getAutostartStatus().installed;
+var config = getConfigFromStore();
+config.workspaces = store.listWorkspaces().map((w2) => w2.path);
+config.port = port;
+config.relayUrl = relayUrl;
+config.devUrl = devUrl;
+config.approvalTimeout = approvalTimeoutMs / 1e3;
+config.webUrl = webUrl;
+saveConfig(config);
+var { success, output } = installAutostart(config);
+if (success) {
+  console.log(`  autostart : ${wasInstalled ? "refreshed" : "installed"} (runs on login)`);
 } else {
-  console.log(`  autostart : already installed`);
+  console.warn(`  autostart : failed to ${wasInstalled ? "refresh" : "install"}: ${output}`);
 }
 if (relayUrl) {
   const pairing = await ensurePairing(relayUrl, forceRepair, webUrl);