offhands 0.1.4 → 0.1.7

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,16 @@ 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"];
   loggedIn() {
     return existsSync(join(homedir(), ".claude", ".credentials.json"));
   }
@@ -4988,7 +5021,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
+            }
           }
         }
       };
@@ -5174,6 +5215,10 @@ 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.
   /** [command, ...prefixArgs] resolved once. */
   resolved = null;
   resolveCommand() {
@@ -5299,6 +5344,7 @@ stderr: ${stderrTail}` : ""}`
 
 // ../daemon/src/runners/opencode-cli.ts
 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";
@@ -5307,79 +5353,61 @@ import { delimiter as delimiter2, join as join3 } from "node:path";
 function mapOpenCodeEvent(value) {
   if (typeof value !== "object" || value === null) return [];
   const v2 = value;
-  const type = typeof v2.type === "string" ? v2.type : "";
   const part = v2.part ?? {};
-  const partType = typeof part.type === "string" ? part.type : "";
-  if (type === "text") {
+  const partType = typeof part.type === "string" ? part.type : typeof v2.type === "string" ? v2.type : "";
+  if (partType === "text") {
     const text = typeof part.text === "string" ? part.text : "";
     return text ? [{ type: "text", chunk: text }] : [];
   }
-  if (type === "thinking" || partType === "thinking") {
-    const thinking = typeof part.thinking === "string" ? part.thinking : typeof part.text === "string" ? part.text : "";
+  if (partType === "reasoning") {
+    const thinking = typeof part.text === "string" ? part.text : "";
     return thinking ? [{ type: "thinking", chunk: thinking }] : [];
   }
-  if (type === "tool_call" || partType === "tool_call") {
-    const name = firstString2(part, "toolName", "name", "tool") ?? "tool";
-    const input = part.input;
-    const summary = input ? firstString2(input, "command", "path", "file", "summary", "description", "query") ?? "" : "";
+  if (partType === "tool") {
+    const name = typeof part.tool === "string" ? part.tool : "tool";
+    const state = part.state ?? {};
+    const input = state.input;
+    const summary = input ? firstString2(input, "command", "filePath", "path", "file", "pattern", "query", "url") ?? "" : "";
+    const status = typeof state.status === "string" ? state.status : void 0;
+    if (status === "error") {
+      const errMsg = typeof state.error === "string" ? state.error : "tool call failed";
+      return [{ type: "tool", name, summary: `${name}: ${truncate3(errMsg, 120)}` }];
+    }
     return [{ type: "tool", name, summary: summary ? `${name}: ${truncate3(summary, 120)}` : name }];
   }
-  if (type === "step_start" || partType === "step-start") {
-    return [];
-  }
-  if (type === "step_finish" || partType === "step-finish") {
+  if (partType === "step-start") return [];
+  if (partType === "step-finish") {
     const reason = typeof part.reason === "string" ? part.reason : "stop";
-    const isError = reason === "error" || reason === "failed";
     const usage = extractUsageFromPart(part);
-    if (isError) {
-      const message = typeof part.error === "string" ? part.error : "run failed";
+    if (reason === "error") {
+      const message = firstString2(part, "error", "message") ?? "run failed";
       const events2 = [{ type: "error", message }];
       if (usage) events2.push(usage);
       return events2;
     }
+    if (reason !== "stop") return usage ? [usage] : [];
     const events = [{ type: "done", summary: "" }];
     if (usage) events.push(usage);
     return events;
   }
-  if (type === "permission_request" || type === "permission.request") {
-    const partData = part.data;
-    const id = firstString2(partData, "id", "permissionId", "id") ?? crypto.randomUUID();
-    const action = firstString2(partData, "toolName", "action", "command") ?? "action";
-    const detail = firstString2(partData, "detail", "description", "message") ?? "";
-    const risk = firstString2(partData, "risk") === "high" ? "high" : "low";
-    const preview = firstString2(partData, "preview", "diff", "command") ?? void 0;
-    const question = partData?.question ? mapQuestion(partData.question) : void 0;
-    return [{
-      type: "approval",
-      id,
-      action,
-      detail,
-      risk,
-      preview,
-      question
-    }];
-  }
-  if (type === "error") {
-    const message = firstString2(v2, "message", "error", "detail", "result") ?? firstString2(part, "message", "error") ?? "unknown error";
+  if (!part.type && typeof v2.type === "string" && v2.type === "error") {
+    const message = firstString2(v2, "message", "error", "detail", "result") ?? "unknown error";
     return [{ type: "error", message }];
   }
-  if (type === "session_created" || type === "session.updated" || type === "session.created") {
-    return [];
-  }
   return [];
 }
 function extractOpenCodeSessionId(value) {
   if (typeof value !== "object" || value === null) return null;
   const v2 = value;
   const part = v2.part ?? {};
-  return firstString2(v2, "sessionId", "session_id", "sessionID", "id") ?? firstString2(part, "sessionId", "session_id", "sessionID", "id") ?? null;
+  return firstString2(v2, "sessionID", "sessionId", "session_id") ?? firstString2(part, "sessionID", "sessionId", "session_id") ?? null;
 }
 function extractUsageFromPart(part) {
   const tokens = part.tokens;
-  const costUsd = typeof part.cost === "number" ? part.cost : typeof part.costUsd === "number" ? part.costUsd : void 0;
+  const costUsd = typeof part.cost === "number" ? part.cost : void 0;
   if (!tokens && costUsd === void 0) return null;
   const n2 = (k2) => typeof tokens?.[k2] === "number" ? tokens[k2] : 0;
-  const contextTokens = n2("total") + n2("input") + n2("inputTokens") + n2("input_tokens") + n2("cacheReadInputTokens") + n2("cache_read_input_tokens") + n2("cacheCreationInputTokens") + n2("cache_creation_input_tokens") + n2("output") + n2("outputTokens") + n2("output_tokens") + n2("reasoning") + n2("reasoningTokens") + n2("reasoning_tokens");
+  const contextTokens = tokens && typeof tokens.total === "number" ? tokens.total : n2("input") + n2("output") + n2("reasoning");
   if (contextTokens <= 0 && costUsd === void 0) return null;
   return {
     type: "usage",
@@ -5388,19 +5416,8 @@ function extractUsageFromPart(part) {
     ...costUsd !== void 0 ? { costUsd } : {}
   };
 }
-function mapQuestion(q2) {
-  if (typeof q2 !== "object" || q2 === null) return void 0;
-  const qq = q2;
-  const text = typeof qq.text === "string" ? qq.text : "";
-  const options = Array.isArray(qq.options) ? qq.options.filter((o2) => typeof o2 === "object" && o2 !== null).map((o2) => ({
-    label: typeof o2.label === "string" ? o2.label : "",
-    description: typeof o2.description === "string" ? o2.description : void 0
-  })) : [];
-  const multiSelect = typeof qq.multiSelect === "boolean" ? qq.multiSelect : void 0;
-  if (!text && options.length === 0) return void 0;
-  return { text, options, multiSelect };
-}
 function firstString2(obj, ...keys) {
+  if (!obj) return void 0;
   for (const k2 of keys) {
     const val = obj[k2];
     if (typeof val === "string" && val !== "") return val;
@@ -5412,15 +5429,27 @@ function truncate3(s2, max) {
 }
 
 // ../daemon/src/runners/opencode-cli.ts
+var POLL_INTERVAL_MS = 500;
 var OpenCodeRunner = class {
+  constructor(broker2) {
+    this.broker = broker2;
+  }
   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"];
   /** [command, ...prefixArgs] resolved once. */
   resolved = null;
   modelsCache = [];
+  // Lazily-started, shared `opencode serve` instance backing startViaHttpApi.
+  serverPort = null;
+  serverProcess = null;
+  serverStarting = null;
   resolveCommand() {
     if (this.resolved) return this.resolved;
     if (process.platform === "win32") {
@@ -5482,16 +5511,16 @@ 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 models = lines.map((l2) => l2.trim()).filter((l2) => l2 && !l2.startsWith("opencode/"));
+            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", {
               value: models,
@@ -5513,6 +5542,13 @@ var OpenCodeRunner = class {
     return existsSync3(join3(homedir3(), ".local", "share", "opencode", "auth.json"));
   }
   start(run, callbacks) {
+    const mode = run.permissionMode ?? "guarded";
+    if (this.broker && (mode === "guarded" || mode === "acceptEdits")) {
+      return this.startViaHttpApi(run, mode, callbacks);
+    }
+    return this.startViaCli(run, mode, callbacks);
+  }
+  startViaCli(run, mode, callbacks) {
     const queue = new AsyncEventQueue();
     const parser = new NdjsonParser();
     let child;
@@ -5537,8 +5573,7 @@ var OpenCodeRunner = class {
       ...cmd.slice(1),
       "run",
       "--format",
-      "json",
-      "--no-color"
+      "json"
     ];
     if (run.model) {
       args2.push("--model", run.model);
@@ -5546,12 +5581,10 @@ var OpenCodeRunner = class {
     if (run.resumeConversationId) {
       args2.push("--session", run.resumeConversationId);
     }
-    const mode = run.permissionMode ?? "guarded";
-    if (mode === "bypass") {
-      args2.push("--auto");
-    } else if (mode === "plan") {
+    if (mode === "plan") {
       args2.push("--agent", "plan");
     } else {
+      args2.push("--auto");
     }
     if (run.effort) {
       const variantMap = { low: "minimal", medium: "high", high: "max", max: "max" };
@@ -5622,17 +5655,304 @@ stderr: ${stderrTail}` : ""}`
     });
     return {
       events: queue,
-      respond: (approvalId, ok, answer) => {
+      // No broker (or bypass/plan, which never ask) — nothing to answer.
+      respond: () => {
       },
       cancel: () => child.kill()
     };
   }
+  startViaHttpApi(run, mode, callbacks) {
+    const queue = new AsyncEventQueue();
+    const emit = (events) => {
+      for (const e of events) queue.push(e);
+    };
+    const broker2 = this.broker;
+    const directory = run.workspace;
+    const encDir = encodeURIComponent(directory);
+    let cancelled = false;
+    let sessionId = run.resumeConversationId ?? null;
+    let port2 = null;
+    let detachBroker;
+    const pendingQuestions = /* @__PURE__ */ new Map();
+    const cleanup = () => {
+      detachBroker?.();
+      queue.close();
+    };
+    void (async () => {
+      try {
+        port2 = await this.ensureServer();
+      } catch (e) {
+        emit([{ type: "error", message: `failed to start opencode server: ${String(e)}` }]);
+        cleanup();
+        return;
+      }
+      if (cancelled) {
+        cleanup();
+        return;
+      }
+      const base = `http://127.0.0.1:${port2}`;
+      detachBroker = broker2.attach((ev) => queue.push(ev));
+      try {
+        if (!sessionId) {
+          const modelRef2 = parseModelRef(run.model);
+          const body = { permission: buildPermissionRuleset(mode) };
+          if (modelRef2) body.model = { id: modelRef2.modelId, providerID: modelRef2.providerId };
+          const session = await httpJson(`${base}/session?directory=${encDir}`, "POST", body);
+          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) });
+        }
+        const promptBody = { parts };
+        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, baselineMessageIds, () => cancelled);
+      } catch (e) {
+        if (!cancelled) emit([{ type: "error", message: `opencode HTTP API error: ${String(e)}` }]);
+      } finally {
+        cleanup();
+      }
+    })();
+    return {
+      events: queue,
+      respond: (approvalId, ok, answer) => {
+        const settleQuestion = pendingQuestions.get(approvalId);
+        if (settleQuestion) {
+          pendingQuestions.delete(approvalId);
+          settleQuestion(ok, answer);
+          return;
+        }
+        broker2.resolve(approvalId, ok, answer);
+      },
+      cancel: () => {
+        cancelled = true;
+        if (port2 && sessionId) {
+          const abortUrl = `http://127.0.0.1:${port2}/session/${sessionId}/abort?directory=${encDir}`;
+          void httpJson(abortUrl, "POST", {}, true).catch(() => {
+          });
+        }
+      }
+    };
+  }
+  /** Poll session messages + pending permissions/questions until the turn finishes. */
+  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();
+    let sawTerminal = false;
+    while (!isCancelled() && !sawTerminal) {
+      await sleep(POLL_INTERVAL_MS);
+      if (isCancelled()) break;
+      try {
+        const pending = await httpJson(`${base}/permission?directory=${encDir}`, "GET");
+        for (const p2 of pending) {
+          if (p2.sessionID !== sessionId || seenPermissions.has(p2.id)) continue;
+          seenPermissions.add(p2.id);
+          void this.answerPermission(base, encDir, p2, broker2);
+        }
+      } catch {
+      }
+      try {
+        const pendingQ = await httpJson(`${base}/question?directory=${encDir}`, "GET");
+        for (const q2 of pendingQ) {
+          if (q2.sessionID !== sessionId || seenQuestions.has(q2.id)) continue;
+          seenQuestions.add(q2.id);
+          void this.answerQuestion(base, encDir, q2, emit, pendingQuestions);
+        }
+      } catch {
+      }
+      let messages;
+      try {
+        messages = await httpJson(`${base}/session/${sessionId}/message?directory=${encDir}`, "GET");
+      } catch {
+        continue;
+      }
+      const result = processMessages(messages, baselineMessageIds, emittedParts);
+      emit(result.events);
+      if (result.sawTerminal) sawTerminal = true;
+    }
+  }
+  /** Route one pending permission through the shared broker, then reply. */
+  async answerPermission(base, encDir, p2, broker2) {
+    const input = { ...p2.metadata };
+    const verdict = await broker2.submit(p2.permission, input);
+    try {
+      await httpJson(`${base}/permission/${p2.id}/reply?directory=${encDir}`, "POST", {
+        reply: verdict.approve ? "once" : "reject",
+        ...verdict.message ? { message: verdict.message } : {}
+      }, true);
+    } catch {
+    }
+  }
+  /** Surface an OpenCode "question" (its AskUserQuestion equivalent) as a
+   * real approval-with-options card, wait for the phone's pick, then answer
+   * through the question API's own reply/reject endpoints. */
+  async answerQuestion(base, encDir, q2, emit, pendingQuestions) {
+    const first = q2.questions[0];
+    if (!first) return;
+    const options = first.options.map((o2) => ({ label: o2.label, description: o2.description }));
+    const preview = [first.question, ...options.map((o2, n2) => `${n2 + 1}. ${o2.label}${o2.description ? ` \u2014 ${o2.description}` : ""}`)].join("\n");
+    emit([{
+      type: "approval",
+      id: q2.id,
+      action: "question",
+      detail: truncate4(first.question, 200),
+      risk: "low",
+      preview: truncate4(preview, 600),
+      question: { text: first.question, options, multiSelect: first.multiple }
+    }]);
+    const verdict = await new Promise((resolve6) => {
+      pendingQuestions.set(q2.id, (ok, answer) => resolve6({ ok, answer }));
+    });
+    emit([{
+      type: "approval-result",
+      id: q2.id,
+      approve: verdict.ok,
+      ...verdict.answer ? { answer: verdict.answer } : {}
+    }]);
+    try {
+      if (verdict.ok && verdict.answer) {
+        await httpJson(`${base}/question/${q2.id}/reply?directory=${encDir}`, "POST", { answers: [[verdict.answer]] }, true);
+      } else {
+        await httpJson(`${base}/question/${q2.id}/reject?directory=${encDir}`, "POST", {}, true);
+      }
+    } 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 () => {
+      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"
+      });
+      proc.on("exit", () => {
+        if (this.serverProcess === proc) {
+          this.serverProcess = null;
+          this.serverPort = null;
+        }
+      });
+      await waitForServerReady(port2);
+      this.serverProcess = proc;
+      this.serverPort = port2;
+      return port2;
+    })();
+    try {
+      return await this.serverStarting;
+    } finally {
+      this.serverStarting = null;
+    }
+  }
 };
+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") {
+    return [
+      ...base,
+      { permission: "edit", pattern: "*", action: "allow" },
+      { permission: "bash", pattern: "*", action: "ask" },
+      { permission: "webfetch", pattern: "*", action: "ask" }
+    ];
+  }
+  return [
+    ...base,
+    { permission: "edit", pattern: "*", action: "ask" },
+    { permission: "bash", pattern: "*", action: "ask" },
+    { permission: "webfetch", pattern: "*", action: "ask" }
+  ];
+}
+function parseModelRef(model) {
+  if (!model) return null;
+  const idx = model.indexOf("/");
+  if (idx < 0) return null;
+  return { providerId: model.slice(0, idx), modelId: model.slice(idx + 1) };
+}
+function fileUrl(path) {
+  const normalised = path.replace(/\\/g, "/");
+  return `file://${normalised.startsWith("/") ? "" : "/"}${normalised}`;
+}
+function truncate4(s2, max) {
+  return s2.length <= max ? s2 : s2.slice(0, max - 1) + "\u2026";
+}
+async function httpJson(url, method, body, expectNoContent = false) {
+  const res = await fetch(url, {
+    method,
+    headers: body !== void 0 ? { "content-type": "application/json" } : void 0,
+    body: body !== void 0 ? JSON.stringify(body) : void 0
+  });
+  if (!res.ok) throw new Error(`opencode API ${method} ${url} -> ${res.status}`);
+  if (expectNoContent || res.status === 204) return void 0;
+  return res.json();
+}
+function findFreePort() {
+  return new Promise((resolve6, reject) => {
+    const srv = createServer();
+    srv.unref();
+    srv.on("error", reject);
+    srv.listen(0, "127.0.0.1", () => {
+      const address = srv.address();
+      const port2 = typeof address === "object" && address ? address.port : 0;
+      srv.close(() => resolve6(port2));
+    });
+  });
+}
+async function waitForServerReady(port2, timeoutMs = 2e4) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      const res = await fetch(`http://127.0.0.1:${port2}/doc`);
+      if (res.ok) return;
+    } catch {
+    }
+    await sleep(150);
+  }
+  throw new Error(`opencode serve did not become ready on port ${port2}`);
+}
+function sleep(ms) {
+  return new Promise((resolve6) => setTimeout(resolve6, 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 { 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 dirname2, join as join6, basename as basename3, parse as parse2, resolve as resolve3 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
@@ -5748,7 +6068,7 @@ function summarizeConversation(path, workspace) {
   return {
     conversationId: basename(path, ".jsonl"),
     workspace,
-    firstPrompt: truncate4(firstPrompt || "(empty prompt)", 120),
+    firstPrompt: truncate5(firstPrompt || "(empty prompt)", 120),
     lastActiveMs: Math.floor(statSync(path).mtimeMs),
     messageCount
   };
@@ -5774,7 +6094,7 @@ function userMessageText(value) {
 function collapseText(text) {
   return text.replace(/\s+/g, " ").trim();
 }
-function truncate4(text, max) {
+function truncate5(text, max) {
   return text.length <= max ? text : `${text.slice(0, max - 1)}\u2026`;
 }
 function safeReadDir(path) {
@@ -5979,6 +6299,267 @@ 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/session-manager.ts
 function resolveDaemonVersion() {
   try {
@@ -5990,6 +6571,9 @@ function resolveDaemonVersion() {
   }
 }
 var DAEMON_VERSION = resolveDaemonVersion();
+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;
@@ -6004,6 +6588,14 @@ var SessionManager = class {
   // sessionId → queued prompts
   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;
@@ -6021,6 +6613,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) {
@@ -6028,10 +6635,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()
     };
   }
@@ -6042,7 +6655,8 @@ 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] } : {}
     }));
     const workspaces = await Promise.all(
       this.store.listWorkspaces().map((w2) => workspaceInfo(w2))
@@ -6137,6 +6751,41 @@ 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 }
+        }));
+        const q2 = this.queues.get(session.id) ?? [];
+        q2.push(prompt);
+        this.queues.set(session.id, q2);
+        this.pump(session.id);
+        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);
@@ -6160,7 +6809,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;
@@ -6193,8 +6844,56 @@ 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;
     }
   }
+  /** 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 }
+    }));
+  }
+  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);
@@ -6237,10 +6936,17 @@ 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 sentPrompt = session.conversationId ? prompt : `${MOBILE_SESSION_PREAMBLE_BASE}${hasStatusTool ? MOBILE_SESSION_PREAMBLE_STATUS_TOOL : ""}
+
+${prompt}`;
     const handle = runner.start(
       {
         runId,
-        prompt,
+        sessionId: session.id,
+        prompt: sentPrompt,
         workspace: session.workspace,
         ...session.model ? { model: session.model } : {},
         ...session.conversationId ? { resumeConversationId: session.conversationId } : {},
@@ -6273,6 +6979,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);
@@ -6304,7 +7021,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;
@@ -6321,16 +7096,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 };
 }
 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);
 }
@@ -6395,6 +7170,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'`);
@@ -6408,6 +7192,14 @@ 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 {
+    }
   }
   // ---- sessions -------------------------------------------------------------
   createSession(workspace, runnerId, model, label) {
@@ -6421,7 +7213,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)
@@ -6441,7 +7235,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) {
@@ -6452,8 +7248,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 {
@@ -6467,7 +7275,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 ---------------------------------------------------------
@@ -6538,6 +7348,32 @@ var Store = class {
   setWorkspacePolicy(path, policy) {
     this.db.prepare(`UPDATE workspaces SET policy = ? WHERE path = ?`).run(policy, 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) {
@@ -6548,6 +7384,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;
@@ -6557,7 +7394,7 @@ function searchableText(msg) {
 }
 
 // ../daemon/src/local-server.ts
-import { createServer } from "node:http";
+import { createServer as createServer2 } from "node:http";
 
 // ../node_modules/.pnpm/ws@8.21.3/node_modules/ws/wrapper.mjs
 var import_stream = __toESM(require_stream(), 1);
@@ -10617,11 +11454,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(),
@@ -10666,12 +11534,67 @@ 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()
   })
 ]);
 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(),
@@ -10696,7 +11619,11 @@ 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()
 });
 var ApprovalPolicySchema = external_exports.enum(["paranoid", "balanced", "trusting"]);
 var WorkspaceInfoSchema = external_exports.object({
@@ -10723,12 +11650,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
@@ -10762,6 +11700,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(),
@@ -10792,7 +11736,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() }),
@@ -10826,7 +11773,19 @@ 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") })
 ]);
 var ReceiptSchema = external_exports.object({
   runId: external_exports.string(),
@@ -10884,6 +11843,17 @@ 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()
+  }),
   // RPC responses (not seq-logged)
   external_exports.object({
     type: external_exports.literal("history-response"),
@@ -10909,7 +11879,12 @@ 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()
   }),
   external_exports.object({ type: external_exports.literal("error"), message: external_exports.string() })
 ]);
@@ -10933,7 +11908,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). */
@@ -10941,6 +11917,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") })
 ]);
@@ -11014,9 +12000,9 @@ if (typeof Module.getRandomValue === "undefined") {
     Module.getRandomValue = randomValuesStandard;
   } catch (e) {
     try {
-      crypto2 = null;
+      crypto = null;
       randomValueNodeJS = function() {
-        var buf = crypto2["randomBytes"](4);
+        var buf = crypto["randomBytes"](4);
         return (buf[0] << 24 | buf[1] << 16 | buf[2] << 8 | buf[3]) >>> 0;
       };
       randomValueNodeJS();
@@ -11029,7 +12015,7 @@ if (typeof Module.getRandomValue === "undefined") {
 var window_;
 var crypto_;
 var randomValuesStandard;
-var crypto2;
+var crypto;
 var randomValueNodeJS;
 var _Module = Module;
 Module.ready = new Promise(function(resolve6, reject) {
@@ -37923,7 +38909,7 @@ Module.ready = new Promise(function(resolve6, reject) {
           try {
             var window_ = "object" === typeof window ? window : self;
             var crypto_ = typeof window_.crypto !== "undefined" ? window_.crypto : window_.msCrypto;
-            crypto_ = crypto_ === void 0 ? crypto2 : crypto_;
+            crypto_ = crypto_ === void 0 ? crypto : crypto_;
             var randomValuesStandard = function() {
               var buf = new Uint32Array(1);
               crypto_.getRandomValues(buf);
@@ -37933,9 +38919,9 @@ Module.ready = new Promise(function(resolve6, reject) {
             Module3.getRandomValue = randomValuesStandard;
           } catch (e) {
             try {
-              var crypto2 = null;
+              var crypto = null;
               var randomValueNodeJS = function() {
-                var buf = crypto2["randomBytes"](4);
+                var buf = crypto["randomBytes"](4);
                 return (buf[0] << 24 | buf[1] << 16 | buf[2] << 8 | buf[3]) >>> 0;
               };
               randomValueNodeJS();
@@ -38581,7 +39567,7 @@ Module.ready = new Promise(function(resolve6, reject) {
       try {
         var window_ = "object" === typeof window ? window : self;
         var crypto_ = typeof window_.crypto !== "undefined" ? window_.crypto : window_.msCrypto;
-        crypto_ = crypto_ === void 0 ? crypto2 : crypto_;
+        crypto_ = crypto_ === void 0 ? crypto : crypto_;
         var randomValuesStandard = function() {
           var buf = new Uint32Array(1);
           crypto_.getRandomValues(buf);
@@ -38591,9 +39577,9 @@ Module.ready = new Promise(function(resolve6, reject) {
         Module2.getRandomValue = randomValuesStandard;
       } catch (e) {
         try {
-          var crypto2 = null;
+          var crypto = null;
           var randomValueNodeJS = function() {
-            var buf = crypto2["randomBytes"](4);
+            var buf = crypto["randomBytes"](4);
             return (buf[0] << 24 | buf[1] << 16 | buf[2] << 8 | buf[3]) >>> 0;
           };
           randomValueNodeJS();
@@ -41515,7 +42501,7 @@ var LocalSessionServer = class {
   constructor(manager2, port2, broker2) {
     this.manager = manager2;
     this.broker = broker2;
-    const http = createServer((req, res) => void this.onRequest(req, res));
+    const http = createServer2((req, res) => void this.onRequest(req, res));
     this.wss = new import_websocket_server.default({ server: http });
     this.wss.on("connection", (ws) => this.onConnection(ws));
     http.on("error", (err) => {
@@ -41548,6 +42534,22 @@ 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;
+    }
     res.writeHead(404);
     res.end();
   }
@@ -41583,8 +42585,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();
   }
@@ -41599,8 +42612,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);
@@ -41640,24 +42658,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());
@@ -41671,6 +42717,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);
@@ -41683,7 +42741,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);
@@ -41699,7 +42762,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";
@@ -41709,7 +42772,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);
@@ -41864,7 +42927,7 @@ var ApprovalBroker = class {
 };
 function classifyRisk(toolName, input) {
   const i2 = input ?? {};
-  const text = [toolName, i2.command, i2.file_path, i2.path].filter((x2) => typeof x2 === "string").join(" ");
+  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(
     text
   ) ? "high" : "low";
@@ -41873,11 +42936,11 @@ function summariseInput(input) {
   if (typeof input !== "object" || input === null) return String(input ?? "");
   const i2 = input;
   const q2 = firstQuestion(i2);
-  if (q2) return truncate5(q2.text, 200);
-  for (const key of ["command", "file_path", "path", "url", "pattern", "description"]) {
-    if (typeof i2[key] === "string" && i2[key] !== "") return truncate5(`${key}: ${i2[key]}`, 200);
+  if (q2) return truncate6(q2.text, 200);
+  for (const key of ["command", "file_path", "filepath", "path", "url", "pattern", "description"]) {
+    if (typeof i2[key] === "string" && i2[key] !== "") return truncate6(`${key}: ${i2[key]}`, 200);
   }
-  return truncate5(JSON.stringify(input), 200);
+  return truncate6(JSON.stringify(input), 200);
 }
 function firstQuestion(i2) {
   if (!Array.isArray(i2.questions) || i2.questions.length === 0) return void 0;
@@ -41895,7 +42958,7 @@ function buildPreview(toolName, input) {
   const q2 = firstQuestion(i2);
   if (q2) {
     const lines = [q2.text, ...q2.options.map((o2, n2) => `${n2 + 1}. ${o2.label}${o2.description ? ` \u2014 ${o2.description}` : ""}`)];
-    return truncate5(lines.join("\n"), 600);
+    return truncate6(lines.join("\n"), 600);
   }
   if (/^(Edit|MultiEdit)/.test(toolName) && typeof i2.new_string === "string") {
     const oldS = typeof i2.old_string === "string" ? i2.old_string : "";
@@ -41903,15 +42966,24 @@ function buildPreview(toolName, input) {
       ...oldS.split("\n").map((l2) => `- ${l2}`),
       ...i2.new_string.split("\n").map((l2) => `+ ${l2}`)
     ];
-    return truncate5(lines.join("\n"), 600);
+    return truncate6(lines.join("\n"), 600);
   }
   if (/^Write/.test(toolName) && typeof i2.content === "string") {
-    return truncate5(i2.content.split("\n").map((l2) => `+ ${l2}`).join("\n"), 600);
+    return truncate6(i2.content.split("\n").map((l2) => `+ ${l2}`).join("\n"), 600);
+  }
+  if (typeof i2.diff === "string" && i2.diff.trim()) {
+    return truncate6(formatUnifiedDiff(i2.diff), 600);
   }
-  if (typeof i2.command === "string") return truncate5(`$ ${i2.command}`, 600);
+  if (typeof i2.url === "string") return truncate6(`\u2192 ${i2.url}`, 600);
+  if (typeof i2.command === "string") return truncate6(`$ ${i2.command}`, 600);
   return void 0;
 }
-function truncate5(s2, max) {
+function formatUnifiedDiff(diff) {
+  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";
 }
 
@@ -41950,7 +43022,7 @@ 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 { existsSync as existsSync9, readFileSync as readFileSync5, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5, rmSync } from "node:fs";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { spawnSync } from "node:child_process";
 import { tmpdir as tmpdir3 } from "node:os";
@@ -41971,27 +43043,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) {
@@ -42012,11 +43080,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);
@@ -42032,7 +43100,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 += `
@@ -42040,14 +43108,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,
@@ -42090,7 +43157,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);
   }
@@ -42102,7 +43169,7 @@ var approvalUrl = `http://127.0.0.1:${port}/approval`;
 var runners = [
   new ClaudeCodeRunner(broker, approvalUrl),
   new CopilotCliRunner(),
-  new OpenCodeRunner(),
+  new OpenCodeRunner(broker),
   new CodexCliRunner(),
   new CursorAgentRunner(),
   new GeminiCliRunner()
@@ -42123,25 +43190,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);