@shipers-dev/multi 0.51.0 → 0.63.0

package/dist/index.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env bun
 // @bun
+import { createRequire } from "node:module";
 var __defProp = Object.defineProperty;
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
@@ -15,6 +16,7 @@ var __export = (target, all) => {
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // ../../node_modules/effect/dist/esm/Function.js
 function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
@@ -27970,7 +27972,7 @@ function finalize(ctx, schema) {
     result.$schema = "http://json-schema.org/draft-07/schema#";
   } else if (ctx.target === "draft-04") {
     result.$schema = "http://json-schema.org/draft-04/schema#";
-  } else if (ctx.target === "openapi-3.0") {} else {}
+  } else if (ctx.target === "openapi-3.0") {}
   if (ctx.external?.uri) {
     const id3 = ctx.external.registry.get(schema)?.id;
     if (!id3)
@@ -28235,7 +28237,7 @@ var formatMap, stringProcessor = (schema, ctx, _json, _params) => {
     if (val === undefined) {
       if (ctx.unrepresentable === "throw") {
         throw new Error("Literal `undefined` cannot be represented in JSON Schema");
-      } else {}
+      }
     } else if (typeof val === "bigint") {
       if (ctx.unrepresentable === "throw") {
         throw new Error("BigInt literals cannot be represented in JSON Schema");
@@ -33196,6 +33198,35 @@ function isPidAlive(pid) {
     return false;
   }
 }
+function listAdapterProcs() {
+  try {
+    const r = spawnSync("ps", ["-axo", "pid=,ppid=,command="], { encoding: "utf8" });
+    if (r.status !== 0)
+      return [];
+    const out = [];
+    for (const line of (r.stdout || "").split(`
+`)) {
+      const m = line.match(/^\s*(\d+)\s+(\d+)\s+(.*)$/);
+      if (!m)
+        continue;
+      const command = m[3];
+      if (!command.includes("claude-code-acp") && !command.includes("acpx"))
+        continue;
+      out.push({ pid: parseInt(m[1], 10), ppid: parseInt(m[2], 10), command });
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+function killOne(pid, log3, label, command) {
+  log3(`[reap] ${label} pid=${pid} cmd=${command.slice(0, 120)}`);
+  tryKill(pid, "SIGTERM");
+  setTimeout(() => {
+    if (isPidAlive(pid))
+      tryKill(pid, "SIGKILL");
+  }, 1500).unref?.();
+}
 function reapStaleAdapters(log3 = () => {}) {
   ensureDir();
   let entries2 = [];
@@ -33247,8 +33278,37 @@ function reapStaleAdapters(log3 = () => {}) {
     } catch {}
     reaped++;
   }
+  const accountedFor = new Set;
+  try {
+    for (const name of readdirSync2(ADAPTERS_DIR)) {
+      const m = name.match(/^(\d+)\.json$/);
+      if (m)
+        accountedFor.add(parseInt(m[1], 10));
+    }
+  } catch {}
+  for (const p of listAdapterProcs()) {
+    if (p.ppid !== 1)
+      continue;
+    if (accountedFor.has(p.pid))
+      continue;
+    killOne(p.pid, log3, "killing pidfile-less orphan", p.command);
+    reaped++;
+  }
   return reaped;
 }
+function killDaemonChildren(daemonPid, log3 = () => {}) {
+  let killed = 0;
+  for (const p of listAdapterProcs()) {
+    if (p.ppid !== daemonPid)
+      continue;
+    killOne(p.pid, log3, "daemon-exit killing", p.command);
+    try {
+      unlinkSync3(pidfilePath(p.pid));
+    } catch {}
+    killed++;
+  }
+  return killed;
+}
 var ADAPTERS_DIR;
 var init_adapter_pidfile = __esm(() => {
   ADAPTERS_DIR = join7(homedir(), ".multi", "adapters");
@@ -33456,8 +33516,20 @@ async function runAcp(opts) {
     return { stopReason, sessionId: activeSessionId, summaryText };
   } finally {
     try {
-      child.kill();
+      child.kill("SIGTERM");
     } catch {}
+    const killTimer = setTimeout(() => {
+      try {
+        child.kill("SIGKILL");
+      } catch {}
+    }, 3000);
+    try {
+      killTimer.unref?.();
+    } catch {}
+    try {
+      await child.exited;
+    } catch {}
+    clearTimeout(killTimer);
     if (typeof child.pid === "number")
       removeAdapterPidfile(child.pid);
   }
@@ -34148,12 +34220,12 @@ function parsePlanBlocks(text) {
   }
   return { actions, errors: errors3 };
 }
-var PLAN_SCHEMA_VERSION = 6, Priority, AssigneeType, IssueStatus, SessionRole, SkillFile, EvalPolicy, PlanActionSchema, PlanEnvelopeSchema, UiBlockSchema, UI_FENCE_RE, FENCE_RE;
+var PLAN_SCHEMA_VERSION = 10, Priority, AssigneeType, IssueStatus, SessionRole, SkillFile, EvalPolicy, PlanActionSchema, PlanEnvelopeSchema, UiBlockSchema, UI_FENCE_RE, FENCE_RE;
 var init_plans = __esm(() => {
   init_zod();
   Priority = exports_external.enum(["low", "medium", "high"]);
   AssigneeType = exports_external.enum(["human", "agent"]);
-  IssueStatus = exports_external.enum(["todo", "in_progress", "blocked", "done", "archived", "failed", "stopped", "cancelled"]);
+  IssueStatus = exports_external.enum(["todo", "in_progress", "blocked", "done", "archived", "failed", "stopped"]);
   SessionRole = exports_external.enum(["implementer", "reviewer", "test-fixer"]);
   SkillFile = exports_external.object({ path: exports_external.string().min(1), content: exports_external.string() });
   EvalPolicy = exports_external.object({
@@ -34193,6 +34265,14 @@ var init_plans = __esm(() => {
       id: exports_external.string().min(1),
       assignee_id: exports_external.string().min(1)
     }),
+    exports_external.object({
+      type: exports_external.literal("handoff"),
+      target_agent_id: exports_external.string().min(1),
+      prompt: exports_external.string().min(1).max(8000),
+      expect: exports_external.enum(["summary", "patch"]).optional(),
+      return_to: exports_external.string().min(1).optional(),
+      title: exports_external.string().min(1).max(200).optional()
+    }),
     exports_external.object({
       type: exports_external.literal("issue.comment"),
       id: exports_external.string().min(1),
@@ -34222,6 +34302,18 @@ var init_plans = __esm(() => {
       query: exports_external.string().min(1).max(500),
       limit: exports_external.number().int().min(1).max(100).optional()
     }),
+    exports_external.object({
+      type: exports_external.literal("issue.get"),
+      id: exports_external.string().min(1)
+    }),
+    exports_external.object({
+      type: exports_external.literal("issue.start"),
+      id: exports_external.string().min(1)
+    }),
+    exports_external.object({
+      type: exports_external.literal("issue.stop"),
+      id: exports_external.string().min(1)
+    }),
     exports_external.object({
       type: exports_external.literal("agent.create"),
       name: exports_external.string().min(1).max(120),
@@ -34268,6 +34360,20 @@ var init_plans = __esm(() => {
       score: exports_external.number().min(0).max(1),
       feedback: exports_external.string().min(1).max(8000),
       scores: exports_external.record(exports_external.string(), exports_external.number().min(0).max(1)).optional()
+    }),
+    exports_external.object({
+      type: exports_external.literal("memory.search"),
+      project_id: exports_external.string().optional(),
+      query: exports_external.string().min(1).max(1000),
+      limit: exports_external.number().int().min(1).max(50).optional()
+    }),
+    exports_external.object({
+      type: exports_external.literal("memory.write"),
+      project_id: exports_external.string().optional(),
+      text: exports_external.string().min(1).max(20000),
+      summary: exports_external.string().max(2000).optional(),
+      kind: exports_external.string().min(1).max(64).optional(),
+      source_id: exports_external.string().min(1).max(256).optional()
     })
   ]);
   PlanEnvelopeSchema = exports_external.object({
@@ -34345,13 +34451,13 @@ var init_chat = __esm(() => {
     title: exports_external.string().min(1).max(200),
     primary_agent_id: exports_external.string().nullable().optional(),
     device_id: exports_external.string().nullable().optional(),
-    runtime: exports_external.string().nullable().optional()
+    runtime: exports_external.string().nullable().optional(),
+    working_dir: exports_external.string().nullable().optional(),
+    branch: exports_external.string().nullable().optional()
   });
   UpdateChatBodySchema = exports_external.object({
     title: exports_external.string().min(1).max(200).optional(),
-    primary_agent_id: exports_external.string().nullable().optional(),
-    device_id: exports_external.string().nullable().optional(),
-    runtime: exports_external.string().nullable().optional()
+    primary_agent_id: exports_external.string().nullable().optional()
   });
 });
 // ../lib/index.ts
@@ -34665,14 +34771,28 @@ function log3(msg) {
   appendFileSync4(LOG_PATH3, line);
   process.stdout.write(line);
 }
-function nestedIssueBase(apiUrl, wsId, projectId, issueId) {
-  return `${apiUrl}/api/workspaces/${wsId}/projects/${projectId}/issues/${issueId}`;
-}
 async function patchIssueStatus(apiUrl, wsId, issueId, status3) {
+  if (status3 === "todo") {
+    throw new Error("patchIssueStatus: cannot return an issue to todo (Phase 4 one-way invariant)");
+  }
   if (!wsId)
     return { success: false, error: "no workspace id" };
   return apiClient.post(`${apiUrl}/api/workspaces/${wsId}/agent/issues/mutate`, { action: "update", id: issueId, status: status3 });
 }
+async function postBoundChatMessage(apiUrl, task, body, authorKind = "agent") {
+  const wsId = task?.tenant_workspace_id ?? null;
+  if (!wsId)
+    return;
+  try {
+    await apiClient.post(`${apiUrl}/api/workspaces/${wsId}/agent/issues/mutate`, {
+      action: "comment",
+      id: task.issue_id,
+      body
+    });
+  } catch (e) {
+    log3(`[bound-chat] post failed: ${String(e).slice(0, 200)}`);
+  }
+}
 async function markStopped(apiUrl, task, reason) {
   const wsId = task?.tenant_workspace_id ?? null;
   const pid = task?.project_id ?? null;
@@ -34682,14 +34802,7 @@ async function markStopped(apiUrl, task, reason) {
       await patchIssueStatus(apiUrl, wsId, issueId, "stopped");
   } catch {}
   try {
-    if (wsId && pid) {
-      await apiClient.post(`${nestedIssueBase(apiUrl, wsId, pid, issueId)}/comments`, {
-        author_type: "agent",
-        author_id: "daemon",
-        author_name: "daemon",
-        body: `⏹ Stopped: ${reason}`
-      });
-    }
+    await postBoundChatMessage(apiUrl, task, `⏹ Stopped: ${reason}`);
   } catch {}
   await postStream(apiUrl, issueId, "stopped", { reason });
 }
@@ -34803,48 +34916,18 @@ async function handleRunTask(apiUrl, deviceId, task, detected, ctx) {
   if (task.from_comment_id && task.tenant_workspace_id && task.project_id) {
     const baseDir = workingDir || join12(MULTI_DIR4, "tmp", issueId);
     const inDir = join12(baseDir, ".multi-in", task.from_comment_id);
-    attachmentRefs = await downloadCommentAttachments(apiUrl, task.tenant_workspace_id, task.project_id, issueId, task.from_comment_id, inDir);
-    if (attachmentRefs.length)
-      log3(`  fetched ${attachmentRefs.length} attachment(s) → ${inDir}`);
+    try {
+      attachmentRefs = await downloadCommentAttachments(apiUrl, task.tenant_workspace_id, task.project_id, issueId, task.from_comment_id, inDir);
+      if (attachmentRefs.length)
+        log3(`  fetched ${attachmentRefs.length} attachment(s) → ${inDir}`);
+    } catch (e) {
+      log3(`[from_comment_id] attachment fetch failed — comments table may be gone (Phase 6): ${String(e).slice(0, 200)}`);
+    }
   }
   const outDir = join12(workingDir || join12(MULTI_DIR4, "tmp", issueId), ".multi-out");
-  let liveCommentId;
-  let liveBody = "";
   let hadError = false;
   let hasAssistantText = false;
-  let liveCommentPromise = null;
   let memorySummary = null;
-  const ensureLiveComment = () => {
-    if (liveCommentId)
-      return Promise.resolve();
-    if (!ISSUE_BASE)
-      return Promise.resolve();
-    if (!liveCommentPromise) {
-      liveCommentPromise = apiClient.post(`${ISSUE_BASE}/comments`, {
-        author_type: "agent",
-        author_id: task.agent_id,
-        author_name: "agent",
-        body: "…"
-      }).then((res) => {
-        liveCommentId = res.data?.id;
-      });
-    }
-    return liveCommentPromise;
-  };
-  const patchLive = async (body) => {
-    if (!liveCommentId || !ISSUE_BASE)
-      return;
-    try {
-      await apiClient.patch(`${ISSUE_BASE}/comments/${liveCommentId}`, { body: body || "…" });
-    } catch {}
-  };
-  const postComment = async (body) => {
-    if (!ISSUE_BASE)
-      return;
-    try {
-      await apiClient.post(`${ISSUE_BASE}/comments`, { author_type: "agent", author_id: task.agent_id, author_name: "agent", body });
-    } catch {}
-  };
   const turn = {
     blocks: [],
     tools: new Map,
@@ -34947,18 +35030,7 @@ _${bits.join(" · ")}_`);
 
 `) || "…";
   };
-  let renderScheduled = false;
-  const schedulePatch = () => {
-    if (renderScheduled)
-      return;
-    renderScheduled = true;
-    queueMicrotask(async () => {
-      renderScheduled = false;
-      try {
-        await patchLive(render2());
-      } catch {}
-    });
-  };
+  const schedulePatch = () => {};
   const eventHandler = async (event) => {
     if (event.event_type === "error")
       hadError = true;
@@ -34971,7 +35043,6 @@ _${bits.join(" · ")}_`);
         break;
       }
       case "assistant_text": {
-        await ensureLiveComment();
         appendText(p.text);
         hasAssistantText = true;
         schedulePatch();
@@ -34979,7 +35050,6 @@ _${bits.join(" · ")}_`);
       }
       case "stdout": {
         if (p.line) {
-          await ensureLiveComment();
           appendText((turn.blocks.length ? `
 ` : "") + p.line);
           hasAssistantText = true;
@@ -34988,14 +35058,12 @@ _${bits.join(" · ")}_`);
         break;
       }
       case "tool_call": {
-        await ensureLiveComment();
         const id3 = p.id || `anon-${turn.tools.size}`;
         upsertTool(id3, { tool: p.tool, kind: p.kind, status: p.status, input: p.input });
         schedulePatch();
         break;
       }
       case "tool_result": {
-        await ensureLiveComment();
         const lastToolId = [...turn.blocks].reverse().find((b) => b.kind === "tool")?.id;
         const id3 = p.tool_use_id || lastToolId;
         const entry = id3 ? turn.tools.get(id3) : undefined;
@@ -35012,7 +35080,6 @@ _${bits.join(" · ")}_`);
         break;
       }
       case "result": {
-        await ensureLiveComment();
         if (p.is_error)
           hadError = true;
         if (!hasAssistantText && p.result) {
@@ -35024,7 +35091,6 @@ _${bits.join(" · ")}_`);
         break;
       }
       case "error": {
-        await ensureLiveComment();
         turn.error = p.message || "error";
         schedulePatch();
         break;
@@ -35251,10 +35317,33 @@ ${userPart}` : userPart;
       for await (const event of runner(task))
         await eventHandler(event);
     }
-    if (liveCommentId && task.tenant_workspace_id && task.project_id) {
-      const n = await uploadOutputDir(apiUrl, task.tenant_workspace_id, task.project_id, task.issue_id, liveCommentId, outDir);
-      if (n > 0)
-        log3(`  \uD83D\uDCCE uploaded ${n} output file(s)`);
+    const finalBody = (() => {
+      const parts2 = [];
+      for (const b of turn.blocks) {
+        if (b.kind === "text") {
+          if (b.text)
+            parts2.push(b.text);
+        } else if (b.kind === "tool") {
+          const t = turn.tools.get(b.id);
+          if (t)
+            parts2.push(`- \uD83D\uDD27 ${t.tool}${t.status === "completed" ? " ✓" : t.status === "failed" ? " ✗" : ""}`);
+        }
+      }
+      return parts2.join(`
+`).trim();
+    })();
+    if (finalBody)
+      await postBoundChatMessage(apiUrl, task, finalBody);
+    if (existsSync12(outDir)) {
+      const files = readdirSync3(outDir).filter((f) => {
+        try {
+          return statSync2(join12(outDir, f)).isFile();
+        } catch {
+          return false;
+        }
+      });
+      if (files.length > 0)
+        log3(`  [Phase 4.5] agent wrote ${files.length} file(s) to .multi-out; attachments via chat upload not wired in this path`);
     }
     if (ctx) {
       const fullText = turn.blocks.filter((b) => b.kind === "text").map((b) => b.text).join(`
@@ -35264,15 +35353,14 @@ ${userPart}` : userPart;
         const summary5 = await executePlanActions(apiUrl, task, actions, ctx, parseErrors);
         if (summary5) {
           try {
-            if (ISSUE_BASE)
-              await apiClient.post(`${ISSUE_BASE}/comments`, { author_type: "agent", author_id: task.agent_id, author_name: "agent", body: summary5 });
+            await postBoundChatMessage(apiUrl, task, summary5);
           } catch {}
         }
       }
     }
     if (!hasAssistantText && !hadError) {
       const stopReason = turn.result?.stopReason || "unknown";
-      await postComment(`⚠️ Agent returned no output (stopReason=${stopReason}). Adapter may be stuck on a stale session — try starting a new issue or clearing session_id.`);
+      await postBoundChatMessage(apiUrl, task, `⚠️ Agent returned no output (stopReason=${stopReason}). Adapter may be stuck on a stale session — try starting a new issue or clearing session_id.`);
       log3(`  ⚠ ${task.key} produced no assistant output (stopReason=${stopReason})`);
     }
     if (ctx?.runEntry?.stopped) {
@@ -35305,7 +35393,7 @@ ${userPart}` : userPart;
       log3(`  ⏹ ${task.key} stopped (${msg})`);
     } else {
       await postStream(apiUrl, issueId, "error", { message: msg });
-      await postComment(`❌ spawn error: ${msg}`);
+      await postBoundChatMessage(apiUrl, task, `❌ spawn error: ${msg}`);
       if (ISSUE_BASE)
         await apiClient.post(`${ISSUE_BASE}/fail`, {});
       log3(`  ✗ ${task.key} failed: ${msg}`);
@@ -35366,15 +35454,24 @@ Issue actions:
   {"type":"issue.delete","id":"<issue id or key>"},
   {"type":"issue.delete_where","status":"todo"},
   {"type":"issue.list","status":"todo","assignee_id":"<agent id>","limit":20},
-  {"type":"issue.search","query":"flaky tests","limit":10}
+  {"type":"issue.search","query":"flaky tests","limit":10},
+  {"type":"issue.get","id":"<issue id or key>"},
+  {"type":"issue.start","id":"<issue id or key>"},
+  {"type":"issue.stop","id":"<issue id or key>"},
+  {"type":"memory.search","query":"how does the deploy pipeline work","limit":10},
+  {"type":"memory.write","text":"Long-form note worth remembering across sessions...","summary":"short index hint","kind":"agent_note"}
 ]}
 \`\`\`
 
 Status values: \`todo\` | \`in_progress\` | \`blocked\` | \`done\` | \`archived\` | \`failed\`. **Use \`blocked\` (NOT \`done\`) when you are pausing to wait on a human decision** — confirmation, a choice between approaches, or missing context. Marking such an issue \`done\` is wrong: the work isn't finished, you're waiting on review. Use \`archived\` to hide a completed/abandoned issue from default views.
 
+**\`todo\` is a one-way exit.** Once an issue moves to any other status, it cannot return to \`todo\`. Use \`blocked\` to pause an issue that needs human input.
+
 Prefer the bulk \`issue.delete_where\` over \`issue.list\` + per-issue \`issue.delete\` when the user's intent matches a filter ("delete all todo issues", "remove anything assigned to agent X"). It runs in one turn instead of two.
 
-Read actions (\`issue.list\`, \`issue.search\`) return the matched rows in the action summary comment. Use them to look up issue ids/keys before \`update\` / \`delegate\` / \`issue.delete\` ONLY when the per-row filter isn't enough (e.g. you need to inspect titles before acting).
+Read actions (\`issue.list\`, \`issue.search\`, \`issue.get\`, \`memory.search\`) return the matched rows in the action summary message posted to the issue's bound chat. Use them to look up issue ids/keys before \`update\` / \`delegate\` / \`issue.delete\` ONLY when the per-row filter isn't enough (e.g. you need to inspect titles before acting). Use \`issue.get\` to deep-read a single issue (status, autonomy, assignee, live dispatch, bound chat) before deciding to start/stop it. \`issue.start\` dispatches the assigned agent (no-op if no agent is assigned). \`issue.stop\` gracefully stops the live dispatch; safe to call on a non-running issue.
+
+Memory actions are project-scoped persistent storage (FTS5 + vector). Use \`memory.search\` to recall facts learned in past sessions; the hits land in the next-turn context like \`issue.search\`. Use \`memory.write\` sparingly to record durable notes (decisions, gotchas, references) that will be useful to future agents on this project — not transient task state. \`kind\` defaults to \`agent_note\`; use a stable kind string (e.g. \`decision\`, \`gotcha\`) if you want to filter later.
 
 Agent + skill self-service (use sparingly — only when you genuinely need a new capability that isn't covered by an existing agent or skill):
 
@@ -35424,7 +35521,7 @@ async function executePlanActions(apiUrl, parentTask, actions, ctx, parseErrors
       results.push({ type: "note", status: "note", message: `${blocked3} non-update action(s) blocked (planning depth limit ${PLANNING_DEPTH_LIMIT})` });
     }
   }
-  const SUBCAPS = { "agent.create": 2, "skill.create": 3, "skill.attach": 5, "skill.detach": 5, "agent.update": 5, "session.create": 3 };
+  const SUBCAPS = { "agent.create": 2, "skill.create": 3, "skill.attach": 5, "skill.detach": 5, "agent.update": 5, "session.create": 3, "memory.search": 5, "memory.write": 5, "issue.get": 10, "issue.start": 3, "issue.stop": 3 };
   const counts = {};
   actions = actions.filter((a) => {
     const cap = SUBCAPS[a.type];
@@ -35606,6 +35703,93 @@ async function executePlanActions(apiUrl, parentTask, actions, ctx, parseErrors
           lines.push(`  - **${r.key}** [${r.status}] ${r.title}`);
         }
         results.push({ type: "issue.search", status: "ok", count: rows.length, query: a.query });
+      } else if (a.type === "issue.get") {
+        const res = await apiClient.post(queryUrl, { kind: "get", id: a.id }, { headers });
+        if (!res.success) {
+          lines.push(`- [err] issue.get ${a.id}: ${res.error || res.status}`);
+          results.push({ type: "issue.get", status: "error", error: String(res.error || res.status), label: a.id });
+          continue;
+        }
+        const r = res.data || {};
+        const dispatchLine = r.live_dispatch ? ` dispatch=${r.live_dispatch.status}` : " dispatch=none";
+        lines.push(`- [ok] issue.get **${r.key}** [${r.status}]${r.assignee_id ? ` @${r.assignee_id}` : ""} autonomy=${r.autonomy_level}${dispatchLine}`);
+        lines.push(`  - ${r.title}`);
+        if (r.bound_chat_id)
+          lines.push(`  - bound chat: ${r.bound_chat_id}`);
+        if (r.live_dispatch?.last_error)
+          lines.push(`  - last error: ${r.live_dispatch.last_error}`);
+        results.push({ type: "issue.get", status: "ok", issue_id: r.id, key: r.key, issue_status: r.status, autonomy_level: r.autonomy_level, assignee_id: r.assignee_id, bound_chat_id: r.bound_chat_id, live_dispatch_status: r.live_dispatch?.status ?? null });
+      } else if (a.type === "issue.start") {
+        const res = await apiClient.post(mutateUrl, { action: "start", id: a.id }, { headers });
+        if (!res.success) {
+          lines.push(`- [err] issue.start ${a.id}: ${res.error || res.status}`);
+          results.push({ type: "issue.start", status: "error", error: String(res.error || res.status), label: a.id });
+          continue;
+        }
+        const r = res.data || {};
+        lines.push(r.dispatched ? `- [ok] issue.start ${r.key || a.id} -> dispatched` : `- [warn] issue.start ${r.key || a.id} not dispatched (autonomy=${r.autonomy_level} or no online device)`);
+        results.push({ type: "issue.start", status: "ok", issue_id: r.id || a.id, key: r.key, dispatched: !!r.dispatched, dispatch_id: r.dispatch_id ?? null, autonomy_level: r.autonomy_level });
+      } else if (a.type === "issue.stop") {
+        const res = await apiClient.post(mutateUrl, { action: "stop", id: a.id }, { headers });
+        if (!res.success) {
+          lines.push(`- [err] issue.stop ${a.id}: ${res.error || res.status}`);
+          results.push({ type: "issue.stop", status: "error", error: String(res.error || res.status), label: a.id });
+          continue;
+        }
+        const r = res.data || {};
+        lines.push(r.was_running ? `- [ok] issue.stop ${r.key || a.id} -> stopped` : `- [ok] issue.stop ${r.key || a.id} (nothing was running)`);
+        results.push({ type: "issue.stop", status: "ok", issue_id: r.id || a.id, key: r.key, was_running: !!r.was_running });
+      } else if (a.type === "memory.search") {
+        const projectId = a.project_id || parentProjectId;
+        if (!projectId) {
+          lines.push(`- [err] memory.search "${a.query}": no project_id`);
+          results.push({ type: "memory.search", status: "error", error: "no project_id", label: a.query });
+          continue;
+        }
+        const limit = a.limit ?? 10;
+        const qs = new URLSearchParams({ project_id: projectId, q: a.query, limit: String(limit) });
+        const res = await apiClient.get(`${apiUrl}/api/memory/search?${qs.toString()}`);
+        if (!res.success) {
+          lines.push(`- [err] memory.search "${a.query}": ${res.error || res.status}`);
+          results.push({ type: "memory.search", status: "error", error: String(res.error || res.status), label: a.query });
+          continue;
+        }
+        const rows = Array.isArray(res.data?.rows) ? res.data.rows : [];
+        if (!rows.length) {
+          lines.push(`- [ok] memory.search "${a.query}": 0 hits`);
+          results.push({ type: "memory.search", status: "ok", count: 0, query: a.query });
+          continue;
+        }
+        lines.push(`- [ok] memory.search "${a.query}": ${rows.length} hit(s)`);
+        for (const r of rows) {
+          const summary5 = (r.summary || r.text || "").replace(/\s+/g, " ").slice(0, 200);
+          lines.push(`  - [${r.source_kind || "memory"}] ${summary5}`);
+        }
+        results.push({ type: "memory.search", status: "ok", count: rows.length, query: a.query });
+      } else if (a.type === "memory.write") {
+        const projectId = a.project_id || parentProjectId;
+        if (!projectId) {
+          lines.push(`- [err] memory.write: no project_id`);
+          results.push({ type: "memory.write", status: "error", error: "no project_id" });
+          continue;
+        }
+        const body = {
+          project_id: projectId,
+          source_kind: a.kind || "agent_note",
+          source_id: a.source_id || `${parentTask.agent_id || "agent"}:${parentTask.issue_id || ""}:${Date.now()}`,
+          agent_id: parentTask.agent_id || null,
+          text: a.text,
+          summary: a.summary || null
+        };
+        const res = await apiClient.post(`${apiUrl}/api/memory/write`, body);
+        if (!res.success) {
+          lines.push(`- [err] memory.write: ${res.error || res.status}`);
+          results.push({ type: "memory.write", status: "error", error: String(res.error || res.status) });
+          continue;
+        }
+        const row = res.data?.row || {};
+        lines.push(`- [ok] memory.write -> ${row.id || "(no id)"}${row.embedding_id ? " (embedded)" : ""}`);
+        results.push({ type: "memory.write", status: "ok", memory_id: row.id, embedded: !!row.embedding_id });
       } else if (a.type === "agent.create") {
         if (!parentWsId) {
           lines.push(`- [err] agent.create "${a.name}": no tenant workspace id`);
@@ -35847,56 +36031,6 @@ function authTokenHeader() {
     return null;
   }
 }
-async function uploadOutputDir(apiUrl, wsId, projectId, issueId, commentId, dir) {
-  if (!existsSync12(dir))
-    return 0;
-  const files = [];
-  const walk = (d, depth = 0) => {
-    if (depth > 3)
-      return;
-    for (const name of readdirSync3(d)) {
-      const p = join12(d, name);
-      try {
-        const st = statSync2(p);
-        if (st.isDirectory())
-          walk(p, depth + 1);
-        else if (st.isFile())
-          files.push(p);
-      } catch {}
-    }
-  };
-  walk(dir);
-  if (!files.length)
-    return 0;
-  const token = authTokenHeader();
-  const issueBase = `${apiUrl}/api/workspaces/${wsId}/projects/${projectId}/issues/${issueId}`;
-  let uploaded = 0;
-  for (const f of files) {
-    try {
-      const data = readFileSync10(f);
-      const form = new FormData;
-      const blob = new Blob([data]);
-      form.append("file", blob, f.split("/").pop() || "file");
-      const headers = {};
-      if (token)
-        headers.Authorization = token;
-      const res = await fetch(`${issueBase}/comments/${commentId}/attachments`, {
-        method: "POST",
-        body: form,
-        headers
-      });
-      if (res.ok) {
-        uploaded++;
-        try {
-          unlinkSync6(f);
-        } catch {}
-      }
-    } catch (e) {
-      log3(`upload failed for ${f}: ${String(e)}`);
-    }
-  }
-  return uploaded;
-}
 function pickRunner(detected, preferType) {
   const forceStub = process.env.MULTI_STUB === "1";
   if (forceStub || !detected.length)
@@ -36170,6 +36304,116 @@ var init_run_task = __esm(() => {
   SKILLS_DIR2 = join12(MULTI_DIR4, "skills");
 });
 
+// src/_impl/worktree-create.ts
+var exports_worktree_create = {};
+__export(exports_worktree_create, {
+  removeWorktree: () => removeWorktree2,
+  materialiseWorktree: () => materialiseWorktree,
+  codename: () => codename
+});
+import { homedir as homedir3 } from "os";
+import { existsSync as existsSync13 } from "fs";
+import { join as join13 } from "path";
+function codename() {
+  const c = CITY_CODENAMES[Math.floor(Math.random() * CITY_CODENAMES.length)];
+  const suffix = Math.random().toString(36).slice(2, 6);
+  return `${c}-${suffix}`;
+}
+async function run5(cmd, cwd) {
+  const proc = Bun.spawn(cmd, { cwd, stdout: "pipe", stderr: "pipe" });
+  const [stdout, stderr] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text()
+  ]);
+  await proc.exited;
+  return { ok: proc.exitCode === 0, stdout: stdout.trim(), stderr: stderr.trim() };
+}
+async function materialiseWorktree(opts) {
+  const { baseDir, name, log: log4 } = opts;
+  if (!existsSync13(baseDir)) {
+    throw new Error(`base_dir does not exist: ${baseDir}`);
+  }
+  const top = await run5(["git", "rev-parse", "--show-toplevel"], baseDir);
+  if (!top.ok || !top.stdout) {
+    throw new Error(`base_dir is not in a git repo: ${baseDir}`);
+  }
+  const repoRoot = top.stdout;
+  let baseBranch = opts.baseBranch;
+  if (!baseBranch) {
+    const head5 = await run5(["git", "rev-parse", "--abbrev-ref", "HEAD"], repoRoot);
+    baseBranch = head5.ok ? head5.stdout : "HEAD";
+  }
+  const worktreesDir = join13(homedir3(), ".multi", "worktrees");
+  const path = join13(worktreesDir, name);
+  if (existsSync13(path)) {
+    throw new Error(`worktree path already exists: ${path}`);
+  }
+  const branch = `multi/${name}`;
+  log4(`worktree: creating ${path} (branch ${branch} off ${baseBranch})`);
+  const create = await run5(["git", "worktree", "add", "-b", branch, path, baseBranch], repoRoot);
+  if (!create.ok) {
+    throw new Error(`git worktree add failed: ${create.stderr || create.stdout}`);
+  }
+  return { path, branch, base_branch: baseBranch, name };
+}
+async function removeWorktree2(path, log4) {
+  if (!existsSync13(path)) {
+    return { ok: true };
+  }
+  const r = await run5(["git", "worktree", "remove", "--force", path], path);
+  if (!r.ok) {
+    log4(`worktree remove failed: ${r.stderr || r.stdout}`);
+    return { ok: false, error: r.stderr || r.stdout };
+  }
+  return { ok: true };
+}
+var CITY_CODENAMES;
+var init_worktree_create = __esm(() => {
+  CITY_CODENAMES = [
+    "raleigh",
+    "yokohama",
+    "sydney",
+    "porto",
+    "kyoto",
+    "bristol",
+    "oslo",
+    "havana",
+    "lisbon",
+    "tallinn",
+    "salem",
+    "marrakech",
+    "perth",
+    "boise",
+    "nantes",
+    "munich",
+    "asheville",
+    "stockholm",
+    "halifax",
+    "kolkata",
+    "tucson",
+    "valencia",
+    "kazan",
+    "savannah",
+    "lyon",
+    "iquitos",
+    "wuhan",
+    "leeds",
+    "ankara",
+    "auckland",
+    "geneva",
+    "izmir",
+    "anchorage",
+    "split",
+    "kigali",
+    "miami",
+    "kazan",
+    "krakow",
+    "bilbao",
+    "calgary",
+    "dakar"
+  ];
+});
+
 // ../lib/chat-doc.ts
 import { LoroDoc, LoroMap, LoroList } from "loro-crdt";
 function appendMessage(doc2, msg) {
@@ -36259,8 +36503,8 @@ var init_chat_doc = __esm(() => {
 });
 
 // src/_impl/chat-peer.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync10, readFileSync as readFileSync11, writeFileSync as writeFileSync8 } from "fs";
-import { dirname as dirname10, join as join13 } from "path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync10, readFileSync as readFileSync11, writeFileSync as writeFileSync8 } from "fs";
+import { dirname as dirname10, join as join14 } from "path";
 import { LoroDoc as LoroDoc2 } from "loro-crdt";
 
 class ChatPeer {
@@ -36272,19 +36516,20 @@ class ChatPeer {
   dirtySinceWrite = 0;
   seenIds = new Set;
   closed = false;
+  localSubs = new Map;
   firstFrameSinceConnect = true;
   reconnectTimer = null;
   constructor(opts) {
     this.opts = opts;
     this.chatId = opts.chatId;
-    this.snapshotPath = join13(MULTI_DIR, "chats", `${opts.chatId}.loro`);
+    this.snapshotPath = join14(MULTI_DIR, "chats", `${opts.chatId}.loro`);
     this.doc = this.loadFromDisk();
     for (const m of listMessages(this.doc))
       this.seenIds.add(m.id);
   }
   loadFromDisk() {
     try {
-      if (existsSync13(this.snapshotPath)) {
+      if (existsSync14(this.snapshotPath)) {
         const bytes = readFileSync11(this.snapshotPath);
         return importSnapshot(new Uint8Array(bytes));
       }
@@ -36292,7 +36537,7 @@ class ChatPeer {
     return new LoroDoc2;
   }
   persist() {
-    if (!existsSync13(dirname10(this.snapshotPath)))
+    if (!existsSync14(dirname10(this.snapshotPath)))
       mkdirSync10(dirname10(this.snapshotPath), { recursive: true });
     writeFileSync8(this.snapshotPath, exportSnapshot(this.doc));
     this.dirtySinceWrite = 0;
@@ -36448,14 +36693,70 @@ class ChatPeer {
     }, 3000);
   }
   sendLoro(update5) {
-    if (!this.ws || this.ws.readyState !== 1)
-      return;
     const frame = new Uint8Array(1 + update5.byteLength);
     frame[0] = FRAME_LORO;
     frame.set(update5, 1);
+    if (this.ws && this.ws.readyState === 1) {
+      try {
+        this.ws.send(frame);
+      } catch {}
+    }
+    this.broadcastLocal(frame, null);
+  }
+  broadcastLocal(frame, except) {
+    for (const [token, send] of this.localSubs) {
+      if (token === except)
+        continue;
+      try {
+        send(frame);
+      } catch {}
+    }
+  }
+  addLocalSubscriber(send) {
+    const token = Symbol("local-chat-sub");
+    this.localSubs.set(token, send);
+    return {
+      token,
+      close: () => {
+        this.localSubs.delete(token);
+      }
+    };
+  }
+  buildSnapshotGreet() {
+    const snap = exportSnapshot(this.doc);
+    const frame = new Uint8Array(1 + snap.byteLength);
+    frame[0] = FRAME_LORO;
+    frame.set(snap, 1);
+    return frame;
+  }
+  ingestLocalUpdate(update5, fromToken) {
+    const before2 = new Set(this.seenIds);
     try {
-      this.ws.send(frame);
-    } catch {}
+      applyUpdate(this.doc, update5);
+    } catch {
+      return;
+    }
+    const frame = new Uint8Array(1 + update5.byteLength);
+    frame[0] = FRAME_LORO;
+    frame.set(update5, 1);
+    if (this.ws && this.ws.readyState === 1) {
+      try {
+        this.ws.send(frame);
+      } catch {}
+    }
+    this.broadcastLocal(frame, fromToken);
+    for (const m of listMessages(this.doc)) {
+      if (before2.has(m.id))
+        continue;
+      this.seenIds.add(m.id);
+      if (m.author?.kind === "user" && !m.partial && this.opts.onUserMessage) {
+        const cb = this.opts.onUserMessage;
+        Promise.resolve().then(() => cb(m, this)).catch((e) => this.opts.log(`[chat ${this.chatId}] onUserMessage error: ${e.message}`));
+      }
+    }
+    this.dirtySinceWrite++;
+    if (this.dirtySinceWrite >= 8)
+      this.persist();
   }
   sendJson(obj) {
     if (!this.ws || this.ws.readyState !== 1)
@@ -36475,13 +36776,20 @@ class ChatPeer {
     const tag3 = buf[0];
     if (tag3 === FRAME_LORO) {
       const before2 = new Set(this.seenIds);
+      const updateBytes = buf.subarray(1);
       try {
-        applyUpdate(this.doc, buf.subarray(1));
+        applyUpdate(this.doc, updateBytes);
       } catch {
         return;
       }
       const isFirstFrame = this.firstFrameSinceConnect;
       this.firstFrameSinceConnect = false;
+      if (!isFirstFrame && this.localSubs.size > 0) {
+        const frame = new Uint8Array(1 + updateBytes.byteLength);
+        frame[0] = FRAME_LORO;
+        frame.set(updateBytes, 1);
+        this.broadcastLocal(frame, null);
+      }
       for (const m of listMessages(this.doc)) {
         if (before2.has(m.id))
           continue;
@@ -36837,6 +37145,100 @@ async function executeChatPlanActions(actionsIn, parseErrors, ctx) {
           lines.push(`  - **${r.key}** [${r.status}] ${r.title}`);
         results.push({ type: "issue.search", status: "ok", count: rows.length, query: a.query });
         tally(true);
+      } else if (a.type === "issue.get") {
+        const res = await apiClient.post(queryUrl, { kind: "get", id: a.id }, { headers });
+        if (!res.success) {
+          lines.push(`- [err] issue.get ${a.id}: ${res.error || res.status}`);
+          results.push({ type: "issue.get", status: "error", error: String(res.error || res.status), label: a.id });
+          tally(false);
+          continue;
+        }
+        const r = res.data || {};
+        const dispatchLine = r.live_dispatch ? ` dispatch=${r.live_dispatch.status}` : " dispatch=none";
+        lines.push(`- [ok] issue.get **${r.key}** [${r.status}]${r.assignee_id ? ` @${r.assignee_id}` : ""} autonomy=${r.autonomy_level}${dispatchLine}`);
+        lines.push(`  - ${r.title}`);
+        if (r.bound_chat_id)
+          lines.push(`  - bound chat: ${r.bound_chat_id}`);
+        if (r.live_dispatch?.last_error)
+          lines.push(`  - last error: ${r.live_dispatch.last_error}`);
+        results.push({ type: "issue.get", status: "ok", issue_id: r.id, key: r.key, issue_status: r.status, autonomy_level: r.autonomy_level, assignee_id: r.assignee_id, bound_chat_id: r.bound_chat_id, live_dispatch_status: r.live_dispatch?.status ?? null });
+        tally(true);
+      } else if (a.type === "issue.start") {
+        const res = await apiClient.post(mutateUrl, { action: "start", id: a.id }, { headers });
+        if (!res.success) {
+          lines.push(`- [err] issue.start ${a.id}: ${res.error || res.status}`);
+          results.push({ type: "issue.start", status: "error", error: String(res.error || res.status), label: a.id });
+          tally(false);
+          continue;
+        }
+        const r = res.data || {};
+        lines.push(r.dispatched ? `- [ok] issue.start ${r.key || a.id} -> dispatched` : `- [warn] issue.start ${r.key || a.id} not dispatched (autonomy=${r.autonomy_level} or no online device)`);
+        results.push({ type: "issue.start", status: "ok", issue_id: r.id || a.id, key: r.key, dispatched: !!r.dispatched, dispatch_id: r.dispatch_id ?? null, autonomy_level: r.autonomy_level });
+        tally(true);
+      } else if (a.type === "issue.stop") {
+        const res = await apiClient.post(mutateUrl, { action: "stop", id: a.id }, { headers });
+        if (!res.success) {
+          lines.push(`- [err] issue.stop ${a.id}: ${res.error || res.status}`);
+          results.push({ type: "issue.stop", status: "error", error: String(res.error || res.status), label: a.id });
+          tally(false);
+          continue;
+        }
+        const r = res.data || {};
+        lines.push(r.was_running ? `- [ok] issue.stop ${r.key || a.id} -> stopped` : `- [ok] issue.stop ${r.key || a.id} (nothing was running)`);
+        results.push({ type: "issue.stop", status: "ok", issue_id: r.id || a.id, key: r.key, was_running: !!r.was_running });
+        tally(true);
+      } else if (a.type === "memory.search") {
+        const project_id = a.project_id || ctx.projectId;
+        if (!project_id) {
+          lines.push(`- [err] memory.search "${a.query}": project_id required (chat has no pinned project)`);
+          results.push({ type: "memory.search", status: "error", error: "project_id required (chat has no pinned project)", label: a.query });
+          tally(false);
+          continue;
+        }
+        const limit = a.limit ?? 10;
+        const qs = new URLSearchParams({ project_id, q: a.query, limit: String(limit) });
+        const res = await apiClient.get(`${ctx.apiUrl}/api/memory/search?${qs.toString()}`);
+        if (!res.success) {
+          lines.push(`- [err] memory.search "${a.query}": ${res.error || res.status}`);
+          results.push({ type: "memory.search", status: "error", error: String(res.error || res.status), label: a.query });
+          tally(false);
+          continue;
+        }
+        const rows = Array.isArray(res.data?.rows) ? res.data.rows : [];
+        lines.push(`- [ok] memory.search "${a.query}": ${rows.length} hit(s)`);
+        for (const r of rows) {
+          const summary5 = (r.summary || r.text || "").replace(/\s+/g, " ").slice(0, 200);
+          lines.push(`  - [${r.source_kind || "memory"}] ${summary5}`);
+        }
+        results.push({ type: "memory.search", status: "ok", count: rows.length, query: a.query });
+        tally(true);
+      } else if (a.type === "memory.write") {
+        const project_id = a.project_id || ctx.projectId;
+        if (!project_id) {
+          lines.push(`- [err] memory.write: project_id required (chat has no pinned project)`);
+          results.push({ type: "memory.write", status: "error", error: "project_id required (chat has no pinned project)" });
+          tally(false);
+          continue;
+        }
+        const body = {
+          project_id,
+          source_kind: a.kind || "agent_note",
+          source_id: a.source_id || `chat:${ctx.chatId}:${Date.now()}`,
+          agent_id: ctx.agentId || null,
+          text: a.text,
+          summary: a.summary || null
+        };
+        const res = await apiClient.post(`${ctx.apiUrl}/api/memory/write`, body);
+        if (!res.success) {
+          lines.push(`- [err] memory.write: ${res.error || res.status}`);
+          results.push({ type: "memory.write", status: "error", error: String(res.error || res.status) });
+          tally(false);
+          continue;
+        }
+        const row = res.data?.row || {};
+        lines.push(`- [ok] memory.write -> ${row.id || "(no id)"}${row.embedding_id ? " (embedded)" : ""}`);
+        results.push({ type: "memory.write", status: "ok", memory_id: row.id, embedded: !!row.embedding_id });
+        tally(true);
       } else if (a.type === "agent.create") {
         const res = await apiClient.post(agentsMutateUrl, {
           action: "create",
@@ -36952,10 +37354,77 @@ var init_chat_plan_actions = __esm(() => {
     "skill.detach": 5,
     "agent.update": 5,
     "session.create": 3,
-    "issue.comment": 5
+    "issue.comment": 5,
+    "memory.search": 5,
+    "memory.write": 5,
+    "issue.get": 10,
+    "issue.start": 3,
+    "issue.stop": 3
   };
 });
 
+// src/_impl/chat-attachments.ts
+import { existsSync as existsSync15, mkdirSync as mkdirSync11, writeFileSync as writeFileSync9 } from "fs";
+import { dirname as dirname11, join as join15 } from "path";
+function safeName(n) {
+  return n.replace(/[^A-Za-z0-9._-]+/g, "_").slice(0, 80) || "file";
+}
+async function downloadUserAttachments(opts) {
+  const { apiUrl, authToken: authToken2, workspaceId, chatId, cwd, message, log: log4 } = opts;
+  const atts = message.attachments || [];
+  if (atts.length === 0)
+    return [];
+  const baseRel = join15(".multi", "attachments", message.id);
+  const baseAbs = join15(cwd, baseRel);
+  if (!existsSync15(baseAbs))
+    mkdirSync11(baseAbs, { recursive: true });
+  const out = [];
+  for (const a of atts) {
+    if (!a.url)
+      continue;
+    const fname = safeName(a.name);
+    const relPath = join15(baseRel, fname);
+    const absPath = join15(cwd, relPath);
+    if (existsSync15(absPath)) {
+      out.push({ attachment: a, absPath, relPath });
+      continue;
+    }
+    try {
+      const base = a.url.startsWith("http") ? a.url : `${apiUrl.replace(/\/$/, "")}${a.url}`;
+      const sep = base.includes("?") ? "&" : "?";
+      const url2 = `${base}${sep}token=${encodeURIComponent(authToken2)}`;
+      const res = await fetch(url2);
+      if (!res.ok) {
+        log4(`[chat ${chatId}] attachment ${a.id} fetch ${res.status}`);
+        continue;
+      }
+      const buf = new Uint8Array(await res.arrayBuffer());
+      if (!existsSync15(dirname11(absPath)))
+        mkdirSync11(dirname11(absPath), { recursive: true });
+      writeFileSync9(absPath, buf);
+      out.push({ attachment: a, absPath, relPath });
+    } catch (e) {
+      log4(`[chat ${chatId}] attachment ${a.id} err: ${e.message}`);
+    }
+  }
+  return out;
+}
+function renderAttachmentPreamble(fetched) {
+  if (fetched.length === 0)
+    return "";
+  const lines = fetched.map((f) => {
+    const sizeBit = typeof f.attachment.size === "number" ? ` (${f.attachment.size}B)` : "";
+    return `- ${f.relPath}${sizeBit}`;
+  });
+  return [
+    `[multi system note — the user attached files; they are saved in the working directory:]`,
+    ...lines,
+    ``
+  ].join(`
+`);
+}
+var init_chat_attachments = () => {};
+
 // src/_impl/chat-supervisor.ts
 async function runChatTurnWithPeer(peer, opts) {
   const { apiUrl, authToken: authToken2, workspaceId, chatId, messageId, log: log4 } = opts;
@@ -36973,6 +37442,45 @@ async function runChatTurnWithPeer(peer, opts) {
   }
   await processUserMessage(chat2, msg, peer, { apiUrl, authToken: authToken2, workspaceId, log: log4 });
 }
+function buildIssueContextMarkdown(issue2) {
+  const key = issue2.key ?? issue2.id ?? "";
+  const title = issue2.title ?? "";
+  const description = typeof issue2.description === "string" ? issue2.description.trim() : "";
+  const priority = issue2.priority ?? null;
+  const status3 = issue2.status ?? null;
+  const MAX_DESC = 8 * 1024;
+  const desc = description.length > MAX_DESC ? description.slice(0, MAX_DESC) + `
+
+[…truncated]` : description;
+  const out = [];
+  out.push(`## Issue ${key}: ${title}`);
+  if (desc) {
+    out.push("");
+    out.push(desc);
+  }
+  const meta3 = [];
+  if (priority)
+    meta3.push(`priority: ${priority}`);
+  if (status3)
+    meta3.push(`status: ${status3}`);
+  if (meta3.length) {
+    out.push("");
+    out.push(`_${meta3.join(" · ")}_`);
+  }
+  return out.join(`
+`);
+}
+async function fetchIssueContext(apiUrl, workspaceId, authToken2, issueId) {
+  try {
+    const r = await fetch(`${apiUrl}/api/workspaces/${workspaceId}/issues/${issueId}`, { headers: { authorization: `Bearer ${authToken2}` } });
+    if (!r.ok)
+      return null;
+    const issue2 = await r.json();
+    return buildIssueContextMarkdown(issue2);
+  } catch {
+    return null;
+  }
+}
 async function fetchAgents(apiUrl, workspaceId, authToken2) {
   const headers = { authorization: `Bearer ${authToken2}` };
   try {
@@ -36995,6 +37503,9 @@ function resolveAgentFromMention(agents, mentioned) {
 async function resolveCwd(apiUrl, workspaceId, authToken2, chat2) {
   if (!chat2.project_id || !chat2.device_id)
     return;
+  if (chat2.working_dir) {
+    return chat2.working_dir;
+  }
   const headers = { authorization: `Bearer ${authToken2}` };
   try {
     const r = await fetch(`${apiUrl}/api/workspaces/${workspaceId}/projects/${chat2.project_id}/devices`, { headers });
@@ -37079,21 +37590,28 @@ async function processUserMessage(chat2, userMsg, peer, ctx) {
     if (typeof r.filename === "string")
       out.filename = r.filename;
     if (typeof r.command === "string")
-      out.command = String(r.command).slice(0, 400);
+      out.command = r.command;
     if (typeof r.pattern === "string")
-      out.pattern = String(r.pattern).slice(0, 200);
+      out.pattern = r.pattern;
     if (typeof r.query === "string")
-      out.query = String(r.query).slice(0, 200);
+      out.query = r.query;
     if (typeof r.url === "string")
       out.url = r.url;
+    if (typeof r.old_string === "string")
+      out.old_string = r.old_string;
+    if (typeof r.new_string === "string")
+      out.new_string = r.new_string;
+    if (typeof r.replace_all === "boolean")
+      out.replace_all = r.replace_all;
+    if (typeof r.content === "string")
+      out.content = r.content;
     return Object.keys(out).length ? out : undefined;
   };
   const summarizeContent = (raw) => {
     const bytes = raw?.length ?? 0;
     const lines = raw ? raw.split(`
 `).length : 0;
-    const trimmed = raw && raw.length > 240 ? raw.slice(0, 240) + "…" : raw || "";
-    return { content: trimmed, bytes, lines };
+    return { content: raw || "", bytes, lines };
   };
   const mapToolKind = (raw) => {
     const s = (raw || "").toLowerCase();
@@ -37231,7 +37749,42 @@ async function processUserMessage(chat2, userMsg, peer, ctx) {
       return null;
     }
   };
-  await runOneTurn(userMsg.text, true);
+  let attachmentPrefix = "";
+  if (cwd && userMsg.attachments && userMsg.attachments.length > 0) {
+    try {
+      const fetched = await downloadUserAttachments({
+        apiUrl,
+        authToken: authToken2,
+        workspaceId,
+        chatId: chat2.id,
+        cwd,
+        message: userMsg,
+        log: log4
+      });
+      attachmentPrefix = renderAttachmentPreamble(fetched);
+      if (fetched.length > 0)
+        log4(`[chat ${chat2.id}] attachments: ${fetched.length} ready`);
+    } catch (e) {
+      log4(`[chat ${chat2.id}] attachment download err: ${e.message}`);
+    }
+  }
+  let issueCtxBlock = "";
+  if (chat2.issue_id && !issueContextSent.has(chat2.id)) {
+    const ctx2 = await fetchIssueContext(apiUrl, workspaceId, authToken2, chat2.issue_id);
+    if (ctx2) {
+      issueCtxBlock = `${ctx2}
+
+---
+
+## New message
+
+`;
+      log4(`[chat ${chat2.id}] injected issue context (${ctx2.length} chars)`);
+    }
+  }
+  await runOneTurn(`${issueCtxBlock}${attachmentPrefix}${userMsg.text}`, true);
+  if (issueCtxBlock)
+    issueContextSent.add(chat2.id);
   const firstPlan = await execAndPostPlan();
   if (firstPlan && firstPlan.ok > 0) {
     const resultText = firstPlan.lines.join(`
@@ -37330,6 +37883,11 @@ Action vocabulary:
   {"type":"issue.delete_where","status":"todo","limit":50},
   {"type":"issue.list","status":"todo","limit":20},
   {"type":"issue.search","query":"flaky tests","limit":10},
+  {"type":"issue.get","id":"<issue id or key>"},
+  {"type":"issue.start","id":"<issue id or key>"},
+  {"type":"issue.stop","id":"<issue id or key>"},
+  {"type":"memory.search","query":"deploy pipeline","limit":10},
+  {"type":"memory.write","text":"durable note worth recalling next session","summary":"short hint","kind":"agent_note"},
   {"type":"agent.create","name":"refactor-bot","prompt":"...","allowed_tools":["Read","Edit","Bash"]},
   {"type":"agent.update","id":"ag_xxx","prompt":"..."},
   {"type":"skill.create","name":"run-tests","description":"...","body":"---\\nname: run-tests\\n---\\n..."},
@@ -37341,7 +37899,9 @@ Action vocabulary:
 Rules:
 - Omit the block entirely if no actions are needed. Don't emit empty arrays.
 - Status values for \`update\`: \`todo\` | \`in_progress\` | \`blocked\` | \`done\` | \`archived\` | \`failed\`. **Use \`blocked\` (NOT \`done\`) when the issue is paused waiting on a human decision** — confirmation, choice, or missing context. Marking such an issue \`done\` misrepresents finished work. Use \`archived\` to hide a completed/abandoned issue from default views.
-- Max 10 actions per turn. Sub-caps: agent.create=2, skill.create=3, agent.update=5, skill.attach/detach=5, session.create=3, issue.comment=5.
+- Max 10 actions per turn. Sub-caps: agent.create=2, skill.create=3, agent.update=5, skill.attach/detach=5, session.create=3, issue.comment=5, memory.search=5, memory.write=5, issue.get=10, issue.start=3, issue.stop=3.
+- Use \`issue.get\` to inspect an issue's current state (status, autonomy, assignee, live dispatch, bound chat) — the result lands in the next-turn summary. \`issue.start\` dispatches the assigned agent (equivalent to mentioning them); honors the autonomy gate. \`issue.stop\` gracefully stops a running dispatch; safe to call on a non-running issue (no-op).
+- Memory actions are project-scoped persistent notes (FTS5 + vector). \`memory.search\` returns hits in the action summary; the agent reads them next turn. \`memory.write\` records durable facts for future sessions — use sparingly, not for transient task state. Both require a pinned project.
 - Chat-initiated agent.create / agent.update / skill.attach are auto-approved (the user is reading this reply right now). skill.create still queues for human review.
 - Use \`issue.comment\` with \`@<agent name>\` mention to dispatch an agent on an existing issue. Plain comments without an @mention are recorded but do not trigger a run. Issues whose autonomy is \`manual\` will not dispatch.
 - To create an issue AND assign/dispatch it to an agent in the same turn, set \`assignee_type\` + \`assignee_id\` directly on the \`create\` action. Do NOT emit a separate \`delegate\` or \`issue.comment\` action referring to a brand-new issue in the same plan block — actions execute as a flat list and the new issue's id/key is not available to later actions in the same block. \`delegate\` and \`issue.comment\` are for issues that already exist before this turn.
@@ -37364,11 +37924,14 @@ Rules:
 
 ${agentsBlock}`;
 }
+var issueContextSent;
 var init_chat_supervisor = __esm(() => {
   init_chat_peer();
   init_chat_turn();
   init_chat_plan_actions();
+  init_chat_attachments();
   init_lib();
+  issueContextSent = new Set;
 });
 
 // src/_impl/chat-session-registry.ts
@@ -37481,6 +38044,9 @@ var init_chat_session_registry = __esm(() => {
       }
       s.inFlight = runTurn(s, k, messageId, ctx, chatId);
     },
+    ensurePeer(wsId, chatId, ctx) {
+      return ensureSession(wsId, chatId, ctx).peer;
+    },
     async closeAll() {
       for (const [k, s] of sessions) {
         clearIdle(s);
@@ -38115,7 +38681,7 @@ import { parseArgs } from "util";
 // package.json
 var package_default = {
   name: "@shipers-dev/multi",
-  version: "0.51.0",
+  version: "0.63.0",
   type: "module",
   bin: {
     "multi-agent": "./dist/index.js"
@@ -38495,8 +39061,6 @@ revision=${Date.now()}
   }
 }
 function writeManagedAgent(slug, agent, skillsForAgent) {
-  if (agent.type !== "claude-code")
-    return;
   mkdirSync4(CLAUDE_AGENTS, { recursive: true });
   const out = join6(CLAUDE_AGENTS, `${slug}.md`);
   safeRmManaged(out);
@@ -39030,7 +39594,7 @@ var killStaleConnects = () => {
     const cmd = m[2];
     if (!Number.isFinite(pid) || pid === self || pid === parent)
       continue;
-    if (!/@shipers-dev\/multi\/dist\/index\.js/.test(cmd) && !/multi-agent/.test(cmd))
+    if (!/@shipers-dev\/multi\/dist\/index\.js/.test(cmd) && !/multi-agent/.test(cmd) && !/multi-daemon/.test(cmd))
       continue;
     if (!/\bconnect\b/.test(cmd))
       continue;
@@ -39193,22 +39757,24 @@ init_client();
 init_detect();
 init_run_task();
 import { Database as Database3 } from "bun:sqlite";
-import { existsSync as existsSync14, mkdirSync as mkdirSync11, writeFileSync as writeFileSync9, unlinkSync as unlinkSync7 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join14 } from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync12, writeFileSync as writeFileSync10, unlinkSync as unlinkSync7 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join16 } from "path";
 init_adapter_pidfile();
 init_errors();
-var MULTI_DIR5 = join14(homedir3(), ".multi");
-var PID_PATH2 = join14(MULTI_DIR5, "agent.pid");
-var PORT_PATH2 = join14(MULTI_DIR5, "agent.port");
-var STOP_PATH2 = join14(MULTI_DIR5, "stop.flag");
-var TASKS_DB_PATH3 = join14(MULTI_DIR5, "tasks.db");
+var MULTI_DIR5 = join16(homedir4(), ".multi");
+var PID_PATH2 = join16(MULTI_DIR5, "agent.pid");
+var PORT_PATH2 = join16(MULTI_DIR5, "agent.port");
+var STOP_PATH2 = join16(MULTI_DIR5, "stop.flag");
+var TASKS_DB_PATH3 = join16(MULTI_DIR5, "tasks.db");
+var LOCAL_SERVER_DIR = process.env.MULTI_HOME || join16(homedir4(), ".multi");
+var LOCAL_SERVER_PATH = join16(LOCAL_SERVER_DIR, "local-server.json");
 function ensureDirs2() {
-  if (!existsSync14(MULTI_DIR5))
-    mkdirSync11(MULTI_DIR5, { recursive: true });
-  const logs = join14(MULTI_DIR5, "logs");
-  if (!existsSync14(logs))
-    mkdirSync11(logs, { recursive: true });
+  if (!existsSync16(MULTI_DIR5))
+    mkdirSync12(MULTI_DIR5, { recursive: true });
+  const logs = join16(MULTI_DIR5, "logs");
+  if (!existsSync16(logs))
+    mkdirSync12(logs, { recursive: true });
 }
 function isLocalApi(url2) {
   try {
@@ -39500,15 +40066,18 @@ var daemonProgram = ({ cfg, apiUrl }) => exports_Effect.gen(function* () {
   if (cfg.authToken)
     setAuthToken(cfg.authToken);
   ensureDirs2();
-  if (existsSync14(STOP_PATH2))
+  if (existsSync16(STOP_PATH2))
     unlinkSync7(STOP_PATH2);
   const reaped = reapStaleAdapters((m) => log3(m));
   if (reaped > 0)
     log3(`reaped ${reaped} stale adapter${reaped === 1 ? "" : "s"}`);
   const detected = yield* exports_Effect.promise(() => detectAgents());
-  const localMode = isLocalApi(apiUrl);
+  const skipTunnel = process.env.MULTI_NO_TUNNEL === "1";
+  const localMode = isLocalApi(apiUrl) || skipTunnel;
   log3(`daemon device=${cfg.deviceId} pid=${process.pid}`);
-  log3(`   API: ${apiUrl}${localMode ? " (local — cloudflared skipped)" : ""}`);
+  log3(`   API: ${apiUrl}${localMode ? skipTunnel && !isLocalApi(apiUrl) ? " (no-tunnel mode)" : " (local — cloudflared skipped)" : ""}`);
+  log3(`   PATH=${(process.env.PATH || "").slice(0, 500)}`);
+  log3(`   detected: ${JSON.stringify(detected.map((d) => ({ type: d.type, path: d.path })))}`);
   log3(`   runtimes: ${detected.map((d) => d.type).join(", ") || "stub"}`);
   const db2 = openTasksDb();
   db2.run("UPDATE tasks SET status = 'queued' WHERE status = 'running'");
@@ -39520,128 +40089,573 @@ var daemonProgram = ({ cfg, apiUrl }) => exports_Effect.gen(function* () {
   const stopDeferred = yield* exports_Deferred.make();
   const port = yield* exports_Effect.promise(() => pickFreePort());
   const expectedAuth = `Bearer ${cfg.dispatchSecret}`;
+  const corsHeaders = (origin) => ({
+    "Access-Control-Allow-Origin": origin || "*",
+    "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+    "Access-Control-Allow-Headers": "Authorization, Content-Type",
+    "Access-Control-Max-Age": "600",
+    Vary: "Origin"
+  });
+  const withCors = (res, origin) => {
+    for (const [k, v] of Object.entries(corsHeaders(origin))) {
+      res.headers.set(k, v);
+    }
+    return res;
+  };
   const server = Bun.serve({
     port,
     hostname: "127.0.0.1",
-    fetch(req) {
+    fetch(req, server2) {
       const url2 = new URL(req.url);
-      if (url2.pathname === "/health")
-        return Response.json({ ok: true, device_id: cfg.deviceId });
-      if (url2.pathname === "/run" && req.method === "POST") {
-        if (req.headers.get("authorization") !== expectedAuth)
-          return new Response("unauthorized", { status: 401 });
-        return (async () => {
-          try {
-            const body = await req.json();
-            const t = body?.task || {};
-            const taskId = t.issue_id ? `${t.issue_id}-${Date.now()}` : crypto.randomUUID();
-            db2.run("INSERT INTO tasks (id, status, payload, agent_id, issue_id) VALUES (?, 'queued', ?, ?, ?)", [taskId, JSON.stringify(t), t.agent_id ?? null, t.issue_id ?? null]);
-            const pos = db2.query("SELECT COUNT(*) AS c FROM tasks WHERE status = 'queued' AND created_at <= (SELECT created_at FROM tasks WHERE id = ?)").get(taskId)?.c ?? 1;
-            if (t.issue_id)
-              postStream(apiUrl, t.issue_id, "queued", { queue_position: pos });
-            if (t.dispatch_id && cfg.workspaceId)
-              ackDispatch(apiUrl, cfg.workspaceId, t.dispatch_id, cfg.authToken);
-            try {
-              exports_Queue.unsafeOffer(wakeQ, undefined);
-            } catch {}
-            return Response.json({ accepted: true, task_id: taskId }, { status: 202 });
-          } catch (e) {
-            return Response.json({ error: String(e) }, { status: 400 });
+      const origin = req.headers.get("origin");
+      if (req.method === "OPTIONS") {
+        return new Response(null, { status: 204, headers: corsHeaders(origin) });
+      }
+      {
+        const m = /^\/chat-sync\/([^/]+)$/.exec(url2.pathname);
+        if (m && req.headers.get("upgrade") === "websocket") {
+          const token = url2.searchParams.get("token") || "";
+          if (token !== cfg.dispatchSecret) {
+            return new Response("unauthorized", { status: 401 });
           }
-        })();
+          if (!cfg.workspaceId || !cfg.authToken || !cfg.deviceId) {
+            return new Response("daemon not configured", { status: 503 });
+          }
+          const chatId = decodeURIComponent(m[1]);
+          const ok = server2.upgrade(req, {
+            data: { kind: "chat-sync", chatId, wsId: cfg.workspaceId }
+          });
+          if (!ok)
+            return new Response("upgrade failed", { status: 500 });
+          return;
+        }
       }
-      if (url2.pathname === "/run-chat-turn" && req.method === "POST") {
-        if (req.headers.get("authorization") !== expectedAuth)
-          return new Response("unauthorized", { status: 401 });
-        return (async () => {
-          try {
-            const body = await req.json();
-            if (!body?.chat_id || !body?.message_id) {
-              return Response.json({ error: "chat_id and message_id required" }, { status: 400 });
+      const route = () => {
+        if (url2.pathname === "/health")
+          return Response.json({ ok: true, device_id: cfg.deviceId });
+        if (url2.pathname === "/files" && req.method === "GET") {
+          if (req.headers.get("authorization") !== expectedAuth)
+            return new Response("unauthorized", { status: 401 });
+          return (async () => {
+            try {
+              const dir = url2.searchParams.get("dir") || "";
+              if (!dir || !dir.startsWith("/")) {
+                return Response.json({ error: "absolute dir required" }, { status: 400 });
+              }
+              const showHidden = url2.searchParams.get("hidden") === "1";
+              const { readdir } = await import("fs/promises");
+              const path = await import("path");
+              const entries2 = await readdir(dir, { withFileTypes: true });
+              const repoRoot = await (async () => {
+                try {
+                  const p = Bun.spawn(["git", "rev-parse", "--show-toplevel"], {
+                    cwd: dir,
+                    stdout: "pipe",
+                    stderr: "ignore"
+                  });
+                  const out3 = (await new Response(p.stdout).text()).trim();
+                  await p.exited;
+                  return p.exitCode === 0 && out3 ? out3 : null;
+                } catch {
+                  return null;
+                }
+              })();
+              const status3 = new Map;
+              if (repoRoot) {
+                try {
+                  const p = Bun.spawn(["git", "status", "--porcelain=v1", "--ignored", "-z"], { cwd: repoRoot, stdout: "pipe", stderr: "ignore" });
+                  const out3 = await new Response(p.stdout).text();
+                  await p.exited;
+                  if (p.exitCode === 0) {
+                    const parts2 = out3.split("\x00").filter((s) => s.length > 0);
+                    for (let i = 0;i < parts2.length; i++) {
+                      const entry = parts2[i];
+                      const code = entry.slice(0, 2);
+                      const rel = entry.slice(3);
+                      if (code[0] === "R" || code[0] === "C")
+                        i++;
+                      const abs = path.join(repoRoot, rel);
+                      const kind = code === "!!" ? "ignored" : code === "??" ? "untracked" : code.includes("D") ? "deleted" : code.includes("A") ? "added" : code.includes("R") ? "renamed" : code.includes("M") ? "modified" : "tracked";
+                      status3.set(abs.replace(/\/$/, ""), kind);
+                    }
+                  }
+                } catch {}
+              }
+              const lookupStatus = (abs, isDir) => {
+                const trimmed = abs.replace(/\/$/, "");
+                if (status3.has(trimmed))
+                  return status3.get(trimmed);
+                if (isDir) {
+                  for (let p = trimmed;p && p !== repoRoot; p = p.replace(/\/[^/]*$/, "")) {
+                    const s = status3.get(p);
+                    if (s === "ignored" || s === "untracked")
+                      return s;
+                    if (!p.includes("/"))
+                      break;
+                  }
+                }
+                if (!repoRoot)
+                  return "tracked";
+                return "tracked";
+              };
+              const out2 = entries2.filter((e) => showHidden || !e.name.startsWith(".")).map((e) => {
+                const abs = path.join(dir, e.name);
+                return {
+                  name: e.name,
+                  path: abs,
+                  is_dir: e.isDirectory(),
+                  status: lookupStatus(abs, e.isDirectory())
+                };
+              }).sort((a, b) => a.is_dir === b.is_dir ? a.name.localeCompare(b.name) : a.is_dir ? -1 : 1);
+              return Response.json({ dir, repo_root: repoRoot, entries: out2 });
+            } catch (e) {
+              return Response.json({ error: String(e) }, { status: 400 });
             }
-            if (!cfg.workspaceId || !cfg.authToken || !cfg.deviceId) {
-              return Response.json({ error: "daemon not configured" }, { status: 503 });
+          })();
+        }
+        if (url2.pathname === "/worktree/create" && req.method === "POST") {
+          if (req.headers.get("authorization") !== expectedAuth)
+            return new Response("unauthorized", { status: 401 });
+          return (async () => {
+            try {
+              const body = await req.json();
+              if (!body?.base_dir || !body.base_dir.startsWith("/")) {
+                return Response.json({ error: "absolute base_dir required" }, { status: 400 });
+              }
+              const { codename: codename2, materialiseWorktree: materialiseWorktree2 } = await Promise.resolve().then(() => (init_worktree_create(), exports_worktree_create));
+              const name = (body.name || codename2()).replace(/[^a-zA-Z0-9_-]/g, "-").slice(0, 40);
+              const result = await materialiseWorktree2({
+                baseDir: body.base_dir,
+                baseBranch: body.base_branch || null,
+                name,
+                chatId: body.chat_id || null,
+                log: (m) => log3(m)
+              });
+              return Response.json(result);
+            } catch (e) {
+              return Response.json({ error: String(e.message || e) }, { status: 400 });
             }
-            const { chatSessionRegistry: chatSessionRegistry2 } = await Promise.resolve().then(() => (init_chat_session_registry(), exports_chat_session_registry));
-            chatSessionRegistry2.ensureAndProcess(cfg.workspaceId, body.chat_id, body.message_id, {
-              apiUrl,
-              authToken: cfg.authToken,
-              workspaceId: cfg.workspaceId,
-              deviceId: cfg.deviceId,
-              log: log3
-            }).catch((e) => log3(`[chat ${body.chat_id}] runChatTurn error: ${e.message}`));
-            return Response.json({ accepted: true }, { status: 202 });
-          } catch (e) {
-            return Response.json({ error: String(e) }, { status: 400 });
-          }
-        })();
-      }
-      if (url2.pathname === "/run-supervisor-tick" && req.method === "POST") {
-        if (req.headers.get("authorization") !== expectedAuth)
-          return new Response("unauthorized", { status: 401 });
-        return (async () => {
-          try {
-            const body = await req.json();
-            if (!body?.tick_id || !body?.callback_url || !body?.callback_token) {
-              return Response.json({ error: "tick_id, callback_url, callback_token required" }, { status: 400 });
+          })();
+        }
+        if (url2.pathname === "/worktree/delete" && req.method === "POST") {
+          if (req.headers.get("authorization") !== expectedAuth)
+            return new Response("unauthorized", { status: 401 });
+          return (async () => {
+            try {
+              const body = await req.json();
+              if (!body?.path || !body.path.startsWith("/")) {
+                return Response.json({ error: "absolute path required" }, { status: 400 });
+              }
+              const { removeWorktree: removeWorktree3 } = await Promise.resolve().then(() => (init_worktree_create(), exports_worktree_create));
+              const result = await removeWorktree3(body.path, (m) => log3(m));
+              return Response.json(result);
+            } catch (e) {
+              return Response.json({ error: String(e.message || e) }, { status: 400 });
             }
-            const { runSupervisorTick: runSupervisorTick2 } = await Promise.resolve().then(() => (init_supervisor_tick(), exports_supervisor_tick));
-            runSupervisorTick2({
-              apiUrl,
-              tickId: body.tick_id,
-              projectId: body.project_id,
-              system: body.system,
-              user: body.user,
-              callbackUrl: body.callback_url,
-              callbackToken: body.callback_token,
-              log: log3
-            }).catch((e) => log3(`[sup ${body.tick_id}] runSupervisorTick error: ${e.message}`));
-            return Response.json({ accepted: true }, { status: 202 });
-          } catch (e) {
-            return Response.json({ error: String(e) }, { status: 400 });
-          }
-        })();
-      }
-      if (url2.pathname === "/stop" && req.method === "POST") {
-        if (req.headers.get("authorization") !== expectedAuth)
-          return new Response("unauthorized", { status: 401 });
-        return (async () => {
-          try {
-            const { issue_id } = await req.json();
-            if (!issue_id)
-              return Response.json({ error: "issue_id required" }, { status: 400 });
-            const entries2 = Array.from(running3.values()).filter((e) => e.issueId === issue_id);
-            if (!entries2.length) {
-              db2.run("UPDATE tasks SET status = 'failed', error = 'stopped before start', finished_at = unixepoch() WHERE issue_id = ? AND status = 'queued'", [issue_id]);
-              return Response.json({ ok: true, state: "queued-cancelled" });
+          })();
+        }
+        if (url2.pathname === "/branch" && req.method === "GET") {
+          if (req.headers.get("authorization") !== expectedAuth)
+            return new Response("unauthorized", { status: 401 });
+          return (async () => {
+            try {
+              const dir = url2.searchParams.get("dir") || "";
+              if (!dir || !dir.startsWith("/")) {
+                return Response.json({ error: "absolute dir required" }, { status: 400 });
+              }
+              const runGit = async (args2) => {
+                const proc = Bun.spawn(["git", ...args2], {
+                  cwd: dir,
+                  stdout: "pipe",
+                  stderr: "ignore"
+                });
+                const out2 = (await new Response(proc.stdout).text()).trim();
+                await proc.exited;
+                return { ok: proc.exitCode === 0, out: out2 };
+              };
+              const branchR = await runGit(["branch", "--show-current"]);
+              const branch = branchR.ok ? branchR.out || null : null;
+              const upstreamR = await runGit(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"]);
+              const upstream = upstreamR.ok ? upstreamR.out || null : null;
+              let ahead = 0;
+              let behind = 0;
+              const unpushed = [];
+              if (upstream) {
+                const countR = await runGit(["rev-list", "--left-right", "--count", `${upstream}...HEAD`]);
+                if (countR.ok) {
+                  const [b, a] = countR.out.split(/\s+/);
+                  behind = Number(b) || 0;
+                  ahead = Number(a) || 0;
+                }
+                if (ahead > 0) {
+                  const logR = await runGit(["log", `${upstream}..HEAD`, "--pretty=format:%h\x1F%s", "-n", "50"]);
+                  if (logR.ok && logR.out) {
+                    for (const line of logR.out.split(`
+`)) {
+                      const idx = line.indexOf("\x1F");
+                      if (idx === -1)
+                        continue;
+                      unpushed.push({ sha: line.slice(0, idx), subject: line.slice(idx + 1) });
+                    }
+                  }
+                }
+              } else if (branch) {
+                const logR = await runGit(["log", "HEAD", "--not", "--remotes", "--pretty=format:%h\x1F%s", "-n", "50"]);
+                if (logR.ok && logR.out) {
+                  for (const line of logR.out.split(`
+`)) {
+                    const idx = line.indexOf("\x1F");
+                    if (idx === -1)
+                      continue;
+                    unpushed.push({ sha: line.slice(0, idx), subject: line.slice(idx + 1) });
+                  }
+                  ahead = unpushed.length;
+                }
+              }
+              return Response.json({ dir, branch, upstream, ahead, behind, unpushed });
+            } catch (e) {
+              return Response.json({ error: String(e) }, { status: 400 });
+            }
+          })();
+        }
+        if (url2.pathname === "/changes" && req.method === "GET") {
+          if (req.headers.get("authorization") !== expectedAuth)
+            return new Response("unauthorized", { status: 401 });
+          return (async () => {
+            try {
+              const dir = url2.searchParams.get("dir") || "";
+              if (!dir || !dir.startsWith("/")) {
+                return Response.json({ error: "absolute dir required" }, { status: 400 });
+              }
+              const rootP = Bun.spawn(["git", "rev-parse", "--show-toplevel"], {
+                cwd: dir,
+                stdout: "pipe",
+                stderr: "ignore"
+              });
+              const repoRoot = (await new Response(rootP.stdout).text()).trim();
+              await rootP.exited;
+              const proc = Bun.spawn(["git", "status", "--porcelain=v1", "-z"], {
+                cwd: dir,
+                stdout: "pipe",
+                stderr: "pipe"
+              });
+              const out2 = await new Response(proc.stdout).text();
+              const errOut = await new Response(proc.stderr).text();
+              await proc.exited;
+              if (proc.exitCode !== 0) {
+                return Response.json({ dir, changes: [], error: errOut.trim() || "git failed" });
+              }
+              const changes = [];
+              const parts2 = out2.split("\x00").filter((p) => p.length > 0);
+              for (let i = 0;i < parts2.length; i++) {
+                const entry = parts2[i];
+                const code = entry.slice(0, 2);
+                let p = entry.slice(3);
+                if (code[0] === "R" || code[0] === "C") {
+                  i++;
+                }
+                changes.push({ code, path: p });
+              }
+              return Response.json({ dir, repo_root: repoRoot || null, changes });
+            } catch (e) {
+              return Response.json({ error: String(e) }, { status: 400 });
+            }
+          })();
+        }
+        if (url2.pathname === "/read-file" && req.method === "GET") {
+          if (req.headers.get("authorization") !== expectedAuth)
+            return new Response("unauthorized", { status: 401 });
+          return (async () => {
+            try {
+              const p = url2.searchParams.get("path") || "";
+              if (!p || !p.startsWith("/")) {
+                return Response.json({ error: "absolute path required" }, { status: 400 });
+              }
+              const fs3 = await import("fs/promises");
+              const stat = await fs3.stat(p);
+              if (stat.isDirectory()) {
+                return Response.json({ error: "is a directory" }, { status: 400 });
+              }
+              const MAX = 2097152;
+              if (stat.size > MAX) {
+                return Response.json({ path: p, size: stat.size, truncated: true, error: `file too large (${stat.size} bytes)` }, { status: 413 });
+              }
+              const buf = await fs3.readFile(p);
+              const head5 = buf.subarray(0, Math.min(8192, buf.length));
+              let nonPrint = 0;
+              for (let i = 0;i < head5.length; i++) {
+                const b = head5[i];
+                if (b === 0) {
+                  nonPrint = head5.length;
+                  break;
+                }
+                if (b < 9 || b > 13 && b < 32)
+                  nonPrint++;
+              }
+              const isBinary = head5.length > 0 && nonPrint / head5.length > 0.3;
+              if (isBinary) {
+                return Response.json({ path: p, size: stat.size, binary: true });
+              }
+              return Response.json({ path: p, size: stat.size, content: buf.toString("utf8") });
+            } catch (e) {
+              return Response.json({ error: String(e.message || e) }, { status: 400 });
+            }
+          })();
+        }
+        if (url2.pathname === "/diff" && req.method === "GET") {
+          if (req.headers.get("authorization") !== expectedAuth)
+            return new Response("unauthorized", { status: 401 });
+          return (async () => {
+            try {
+              const p = url2.searchParams.get("path") || "";
+              if (!p || !p.startsWith("/")) {
+                return Response.json({ error: "absolute path required" }, { status: 400 });
+              }
+              const path = await import("path");
+              const repoDir = path.dirname(p);
+              const rootP = Bun.spawn(["git", "rev-parse", "--show-toplevel"], {
+                cwd: repoDir,
+                stdout: "pipe",
+                stderr: "ignore"
+              });
+              const rootOut = (await new Response(rootP.stdout).text()).trim();
+              await rootP.exited;
+              if (rootP.exitCode !== 0 || !rootOut) {
+                return Response.json({ path: p, diff: "", error: "not a git repo" });
+              }
+              const proc = Bun.spawn(["git", "diff", "HEAD", "--", p], { cwd: rootOut, stdout: "pipe", stderr: "pipe" });
+              const out2 = await new Response(proc.stdout).text();
+              const err = await new Response(proc.stderr).text();
+              await proc.exited;
+              if (proc.exitCode !== 0) {
+                return Response.json({ path: p, diff: "", error: err.trim() || "git diff failed" });
+              }
+              return Response.json({ path: p, diff: out2 });
+            } catch (e) {
+              return Response.json({ error: String(e.message || e) }, { status: 400 });
             }
-            for (const entry of entries2) {
-              entry.stopped = true;
-              entry.stopReason = "user requested";
+          })();
+        }
+        if (url2.pathname === "/run" && req.method === "POST") {
+          if (req.headers.get("authorization") !== expectedAuth)
+            return new Response("unauthorized", { status: 401 });
+          return (async () => {
+            try {
+              const body = await req.json();
+              const t = body?.task || {};
+              const taskId = t.issue_id ? `${t.issue_id}-${Date.now()}` : crypto.randomUUID();
+              db2.run("INSERT INTO tasks (id, status, payload, agent_id, issue_id) VALUES (?, 'queued', ?, ?, ?)", [taskId, JSON.stringify(t), t.agent_id ?? null, t.issue_id ?? null]);
+              const pos = db2.query("SELECT COUNT(*) AS c FROM tasks WHERE status = 'queued' AND created_at <= (SELECT created_at FROM tasks WHERE id = ?)").get(taskId)?.c ?? 1;
+              if (t.issue_id)
+                postStream(apiUrl, t.issue_id, "queued", { queue_position: pos });
+              if (t.dispatch_id && cfg.workspaceId)
+                ackDispatch(apiUrl, cfg.workspaceId, t.dispatch_id, cfg.authToken);
               try {
-                entry.child?.kill("SIGTERM");
+                exports_Queue.unsafeOffer(wakeQ, undefined);
               } catch {}
-              setTimeout(() => {
+              return Response.json({ accepted: true, task_id: taskId }, { status: 202 });
+            } catch (e) {
+              return Response.json({ error: String(e) }, { status: 400 });
+            }
+          })();
+        }
+        {
+          const m = /^\/chat-snapshot\/([^/]+)$/.exec(url2.pathname);
+          if (m && req.method === "GET") {
+            const token = url2.searchParams.get("token") || "";
+            const headerToken = req.headers.get("authorization") === expectedAuth;
+            if (!headerToken && token !== cfg.dispatchSecret) {
+              return new Response("unauthorized", { status: 401 });
+            }
+            if (!cfg.workspaceId || !cfg.authToken || !cfg.deviceId) {
+              return new Response("daemon not configured", { status: 503 });
+            }
+            const chatId = decodeURIComponent(m[1]);
+            return (async () => {
+              const { chatSessionRegistry: chatSessionRegistry2 } = await Promise.resolve().then(() => (init_chat_session_registry(), exports_chat_session_registry));
+              const peer = chatSessionRegistry2.ensurePeer(cfg.workspaceId, chatId, {
+                apiUrl,
+                authToken: cfg.authToken,
+                workspaceId: cfg.workspaceId,
+                deviceId: cfg.deviceId,
+                log: log3
+              });
+              const greet = peer.buildSnapshotGreet();
+              return new Response(greet.subarray(1), {
+                headers: { "content-type": "application/octet-stream" }
+              });
+            })();
+          }
+        }
+        if (url2.pathname === "/run-chat-turn" && req.method === "POST") {
+          if (req.headers.get("authorization") !== expectedAuth)
+            return new Response("unauthorized", { status: 401 });
+          return (async () => {
+            try {
+              const body = await req.json();
+              if (!body?.chat_id || !body?.message_id) {
+                return Response.json({ error: "chat_id and message_id required" }, { status: 400 });
+              }
+              if (!cfg.workspaceId || !cfg.authToken || !cfg.deviceId) {
+                return Response.json({ error: "daemon not configured" }, { status: 503 });
+              }
+              const { chatSessionRegistry: chatSessionRegistry2 } = await Promise.resolve().then(() => (init_chat_session_registry(), exports_chat_session_registry));
+              chatSessionRegistry2.ensureAndProcess(cfg.workspaceId, body.chat_id, body.message_id, {
+                apiUrl,
+                authToken: cfg.authToken,
+                workspaceId: cfg.workspaceId,
+                deviceId: cfg.deviceId,
+                log: log3
+              }).catch((e) => log3(`[chat ${body.chat_id}] runChatTurn error: ${e.message}`));
+              return Response.json({ accepted: true }, { status: 202 });
+            } catch (e) {
+              return Response.json({ error: String(e) }, { status: 400 });
+            }
+          })();
+        }
+        if (url2.pathname === "/run-supervisor-tick" && req.method === "POST") {
+          if (req.headers.get("authorization") !== expectedAuth)
+            return new Response("unauthorized", { status: 401 });
+          return (async () => {
+            try {
+              const body = await req.json();
+              if (!body?.tick_id || !body?.callback_url || !body?.callback_token) {
+                return Response.json({ error: "tick_id, callback_url, callback_token required" }, { status: 400 });
+              }
+              const { runSupervisorTick: runSupervisorTick2 } = await Promise.resolve().then(() => (init_supervisor_tick(), exports_supervisor_tick));
+              runSupervisorTick2({
+                apiUrl,
+                tickId: body.tick_id,
+                projectId: body.project_id,
+                system: body.system,
+                user: body.user,
+                callbackUrl: body.callback_url,
+                callbackToken: body.callback_token,
+                log: log3
+              }).catch((e) => log3(`[sup ${body.tick_id}] runSupervisorTick error: ${e.message}`));
+              return Response.json({ accepted: true }, { status: 202 });
+            } catch (e) {
+              return Response.json({ error: String(e) }, { status: 400 });
+            }
+          })();
+        }
+        if (url2.pathname === "/stop" && req.method === "POST") {
+          if (req.headers.get("authorization") !== expectedAuth)
+            return new Response("unauthorized", { status: 401 });
+          return (async () => {
+            try {
+              const { issue_id } = await req.json();
+              if (!issue_id)
+                return Response.json({ error: "issue_id required" }, { status: 400 });
+              const entries2 = Array.from(running3.values()).filter((e) => e.issueId === issue_id);
+              if (!entries2.length) {
+                db2.run("UPDATE tasks SET status = 'failed', error = 'stopped before start', finished_at = unixepoch() WHERE issue_id = ? AND status = 'queued'", [issue_id]);
+                return Response.json({ ok: true, state: "queued-cancelled" });
+              }
+              for (const entry of entries2) {
+                entry.stopped = true;
+                entry.stopReason = "user requested";
                 try {
-                  entry.child?.kill("SIGKILL");
+                  entry.child?.kill("SIGTERM");
                 } catch {}
-              }, 1500);
+                setTimeout(() => {
+                  try {
+                    entry.child?.kill("SIGKILL");
+                  } catch {}
+                }, 1500);
+              }
+              return Response.json({ ok: true, state: "running-signalled" });
+            } catch (e) {
+              return Response.json({ error: String(e) }, { status: 400 });
             }
-            return Response.json({ ok: true, state: "running-signalled" });
-          } catch (e) {
-            return Response.json({ error: String(e) }, { status: 400 });
-          }
-        })();
+          })();
+        }
+        return new Response("not found", { status: 404 });
+      };
+      const out = route();
+      return out instanceof Promise ? out.then((r) => withCors(r, origin)) : withCors(out, origin);
+    },
+    websocket: {
+      async open(ws) {
+        const data = ws.data;
+        if (!data || data.kind !== "chat-sync")
+          return;
+        if (!cfg.workspaceId || !cfg.authToken || !cfg.deviceId) {
+          try {
+            ws.close(1011, "daemon not configured");
+          } catch {}
+          return;
+        }
+        const { chatSessionRegistry: chatSessionRegistry2 } = await Promise.resolve().then(() => (init_chat_session_registry(), exports_chat_session_registry));
+        const peer = chatSessionRegistry2.ensurePeer(data.wsId, data.chatId, {
+          apiUrl,
+          authToken: cfg.authToken,
+          workspaceId: cfg.workspaceId,
+          deviceId: cfg.deviceId,
+          log: log3
+        });
+        const sub = peer.addLocalSubscriber((frame) => {
+          try {
+            ws.sendBinary(frame);
+          } catch {}
+        });
+        ws.data.peerToken = sub.token;
+        ws.data.unsubscribe = sub.close;
+        try {
+          ws.sendBinary(peer.buildSnapshotGreet());
+        } catch {}
+      },
+      async message(ws, message) {
+        const data = ws.data;
+        if (!data || data.kind !== "chat-sync" || !data.peerToken)
+          return;
+        if (typeof message === "string")
+          return;
+        const buf = message instanceof Uint8Array ? message : new Uint8Array(message);
+        if (buf.byteLength < 1)
+          return;
+        const tag3 = buf[0];
+        if (tag3 === 1) {
+          const { chatSessionRegistry: chatSessionRegistry2 } = await Promise.resolve().then(() => (init_chat_session_registry(), exports_chat_session_registry));
+          const peer = chatSessionRegistry2.ensurePeer(data.wsId, data.chatId, {
+            apiUrl,
+            authToken: cfg.authToken,
+            workspaceId: cfg.workspaceId,
+            deviceId: cfg.deviceId,
+            log: log3
+          });
+          peer.ingestLocalUpdate(buf.subarray(1), data.peerToken);
+        }
+      },
+      close(ws) {
+        const data = ws.data;
+        if (data?.unsubscribe) {
+          try {
+            data.unsubscribe();
+          } catch {}
+        }
       }
-      return new Response("not found", { status: 404 });
     }
   });
   log3(`Local server: http://127.0.0.1:${port}`);
   try {
-    writeFileSync9(PORT_PATH2, String(port));
+    writeFileSync10(PORT_PATH2, String(port));
+  } catch {}
+  try {
+    writeFileSync10(PID_PATH2, String(process.pid));
   } catch {}
   try {
-    writeFileSync9(PID_PATH2, String(process.pid));
+    if (!existsSync16(LOCAL_SERVER_DIR))
+      mkdirSync12(LOCAL_SERVER_DIR, { recursive: true });
+    writeFileSync10(LOCAL_SERVER_PATH, JSON.stringify({
+      url: `http://127.0.0.1:${port}`,
+      port,
+      token: cfg.dispatchSecret,
+      device_id: cfg.deviceId,
+      workspace_id: cfg.workspaceId,
+      api_url: apiUrl,
+      pid: process.pid
+    }, null, 2));
   } catch {}
   let tunnel;
   if (localMode) {
@@ -39705,7 +40719,7 @@ var daemonProgram = ({ cfg, apiUrl }) => exports_Effect.gen(function* () {
       let probeFailures = 0;
       while (true) {
         yield* exports_Effect.sleep(exports_Duration.seconds(120));
-        if (existsSync14(STOP_PATH2)) {
+        if (existsSync16(STOP_PATH2)) {
           yield* exports_Deferred.succeed(stopDeferred, "stop flag");
           return;
         }
@@ -39730,7 +40744,7 @@ var daemonProgram = ({ cfg, apiUrl }) => exports_Effect.gen(function* () {
     yield* exports_Effect.forkIn(daemonScope)(exports_Effect.gen(function* () {
       while (true) {
         yield* exports_Effect.sleep(exports_Duration.seconds(5));
-        if (existsSync14(STOP_PATH2)) {
+        if (existsSync16(STOP_PATH2)) {
           yield* exports_Deferred.succeed(stopDeferred, "stop flag");
           return;
         }
@@ -39769,13 +40783,22 @@ var daemonProgram = ({ cfg, apiUrl }) => exports_Effect.gen(function* () {
   if (inFlight.length) {
     yield* exports_Effect.race(exports_Fiber.interruptAll(inFlight), exports_Effect.sleep(exports_Duration.seconds(10)));
   }
+  try {
+    const killed = killDaemonChildren(process.pid, (m) => log3(m));
+    if (killed > 0)
+      log3(`killed ${killed} adapter child${killed === 1 ? "" : "ren"} on shutdown`);
+  } catch (e) {
+    log3(`adapter shutdown sweep failed: ${String(e)}`);
+  }
   yield* exports_Scope.close(daemonScope, exports_Exit.void).pipe(exports_Effect.catchAll(() => exports_Effect.void));
-  if (existsSync14(PID_PATH2))
+  if (existsSync16(PID_PATH2))
     unlinkSync7(PID_PATH2);
-  if (existsSync14(STOP_PATH2))
+  if (existsSync16(STOP_PATH2))
     unlinkSync7(STOP_PATH2);
-  if (existsSync14(PORT_PATH2))
+  if (existsSync16(PORT_PATH2))
     unlinkSync7(PORT_PATH2);
+  if (existsSync16(LOCAL_SERVER_PATH))
+    unlinkSync7(LOCAL_SERVER_PATH);
   db2.close();
   log3("disconnected");
 });
@@ -39788,7 +40811,81 @@ async function daemonMain(opts) {
 }
 
 // src/commands/connect.ts
+init_detect();
 init_outbox();
+
+// src/_impl/pair-flow.ts
+import { existsSync as existsSync17, mkdirSync as mkdirSync13, writeFileSync as writeFileSync11 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join17 } from "path";
+var LOCAL_SERVER_DIR2 = process.env.MULTI_HOME || join17(homedir5(), ".multi");
+var LOCAL_SERVER_PATH2 = join17(LOCAL_SERVER_DIR2, "local-server.json");
+function writePairingInfo(payload) {
+  try {
+    if (!existsSync17(LOCAL_SERVER_DIR2))
+      mkdirSync13(LOCAL_SERVER_DIR2, { recursive: true });
+    writeFileSync11(LOCAL_SERVER_PATH2, JSON.stringify(payload, null, 2));
+  } catch {}
+}
+async function awaitPairing(apiUrl, deviceName, opts = {}) {
+  const log4 = opts.log ?? ((m) => console.log(m));
+  const timeoutMs = opts.timeoutMs ?? 10 * 60 * 1000;
+  const startRes = await fetch(`${apiUrl}/api/pair/start`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      name: deviceName,
+      platform: opts.platform ?? process.platform,
+      arch: opts.arch ?? process.arch,
+      os_version: opts.osVersion ?? process.version,
+      detected_runtimes: opts.detectedRuntimes ?? []
+    })
+  });
+  if (!startRes.ok) {
+    throw new Error(`pair/start failed: ${startRes.status} ${await startRes.text()}`);
+  }
+  const start3 = await startRes.json();
+  const code = start3.code;
+  const pairUrl = `${apiUrl}/pair/${code}`;
+  writePairingInfo({
+    status: "pairing",
+    pair_code: code,
+    pair_url: pairUrl,
+    device_name: deviceName,
+    api_url: apiUrl,
+    expires_at: start3.expires_at
+  });
+  log4(`pair: code=${code} url=${pairUrl}`);
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, 3000));
+    let res;
+    try {
+      res = await fetch(`${apiUrl}/api/pair/poll/${code}`);
+    } catch {
+      continue;
+    }
+    if (res.status === 410)
+      throw new Error("Pairing expired.");
+    if (!res.ok)
+      continue;
+    const j = await res.json();
+    if (j.status === "approved" && j.device_id && j.token) {
+      return {
+        device_id: j.device_id,
+        token: j.token,
+        dispatch_secret: j.dispatch_secret ?? null,
+        workspace_id: j.workspace_id ?? null
+      };
+    }
+  }
+  throw new Error("Pairing timed out.");
+}
+function deviceNameFromEnv() {
+  return process.env.MULTI_DEVICE_NAME || process.env.HOSTNAME || process.env.COMPUTERNAME || "Multi Desktop";
+}
+
+// src/commands/connect.ts
 init_paths();
 init_errors();
 var connectCmd = exports_Effect.fn("connectCmd")(function* () {
@@ -39796,9 +40893,28 @@ var connectCmd = exports_Effect.fn("connectCmd")(function* () {
   const logger = yield* Logger4;
   const api2 = yield* Api2;
   yield* config2.ensureDirs;
-  const cfg = yield* config2.load;
-  if (!cfg.deviceId) {
-    return yield* exports_Effect.fail(new UsageError({ message: "Not registered. Run 'multi-agent setup' first." }));
+  let cfg = yield* config2.load;
+  if (!cfg.deviceId || !cfg.authToken) {
+    const apiUrl = cfg.apiUrl || process.env.MULTI_API || process.env.MULTI_API_URL || "https://multi-api.adnb3r.workers.dev";
+    const name = deviceNameFromEnv();
+    const detected = yield* exports_Effect.promise(() => detectAgents());
+    yield* logger.log(`connect: no device registered — starting pair flow for "${name}" ` + `(runtimes: ${detected.map((d) => d.type).join(", ") || "none"})`);
+    const bundle = yield* exports_Effect.tryPromise({
+      try: () => awaitPairing(apiUrl, name, {
+        log: (m) => console.log(m),
+        detectedRuntimes: detected.map((d) => d.type)
+      }),
+      catch: (cause3) => new ApiError({ url: `${apiUrl}/api/pair/start`, status: 0, message: cause3.message })
+    });
+    yield* config2.save({
+      apiUrl,
+      deviceId: bundle.device_id,
+      authToken: bundle.token,
+      dispatchSecret: bundle.dispatch_secret ?? undefined,
+      workspaceId: bundle.workspace_id ?? undefined
+    });
+    cfg = yield* config2.load;
+    yield* logger.log(`connect: paired device=${cfg.deviceId} workspace=${cfg.workspaceId}`);
   }
   if (!cfg.dispatchSecret) {
     return yield* exports_Effect.fail(new UsageError({ message: "Missing dispatch secret. Re-pair via 'multi-agent setup'." }));
@@ -39835,6 +40951,250 @@ ${err?.stack ?? ""}`);
   }).pipe(exports_Effect.ensuring(exports_Effect.sync(() => stopFlusher())));
 });
 
+// src/commands/service.ts
+init_esm();
+import { existsSync as existsSync18, readFileSync as readFileSync12 } from "fs";
+import { homedir as homedir6, platform } from "os";
+import { join as join18 } from "path";
+init_errors();
+init_paths();
+var LABEL = "dev.shipers.multi.daemon";
+var HOME5 = homedir6();
+var PLIST_PATH = join18(HOME5, "Library", "LaunchAgents", `${LABEL}.plist`);
+var SYSTEMD_UNIT_PATH = join18(HOME5, ".config", "systemd", "user", "multi-daemon.service");
+var isMac = () => platform() === "darwin";
+var isLinux = () => platform() === "linux";
+var isRunningPid = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var readPid = () => {
+  try {
+    if (!existsSync18(PID_PATH))
+      return null;
+    const n = Number(readFileSync12(PID_PATH, "utf8").trim());
+    return Number.isFinite(n) && n > 0 ? n : null;
+  } catch {
+    return null;
+  }
+};
+var resolveBinary = exports_Effect.fn("service.resolveBinary")(function* () {
+  const proc = Bun.spawn(["which", "multi-agent"], { stdout: "pipe", stderr: "pipe" });
+  yield* exports_Effect.promise(() => proc.exited);
+  const out = yield* exports_Effect.promise(() => new Response(proc.stdout).text());
+  const path = out.trim();
+  if (!path || !existsSync18(path)) {
+    return yield* exports_Effect.fail(new DaemonError({
+      message: "Could not find `multi-agent` on PATH. Install with: bun install -g @shipers-dev/multi"
+    }));
+  }
+  return path;
+});
+var run6 = exports_Effect.fn("service.run")(function* (cmd, args2) {
+  const proc = Bun.spawn([cmd, ...args2], { stdout: "pipe", stderr: "pipe" });
+  yield* exports_Effect.promise(() => proc.exited);
+  const stdout = yield* exports_Effect.promise(() => new Response(proc.stdout).text());
+  const stderr = yield* exports_Effect.promise(() => new Response(proc.stderr).text());
+  if (proc.exitCode !== 0) {
+    return yield* exports_Effect.fail(new SpawnError({
+      cmd: `${cmd} ${args2.join(" ")}`,
+      cause: stderr || stdout || `exit ${proc.exitCode}`
+    }));
+  }
+  return { stdout, stderr };
+});
+var buildPlist = (binary, env) => {
+  const envEntries = Object.entries(env).map(([k, v]) => `      <key>${k}</key>
+      <string>${escapeXml(v)}</string>`).join(`
+`);
+  const logDir = join18(MULTI_DIR, "logs");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${escapeXml(binary)}</string>
+    <string>connect</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>WorkingDirectory</key>
+  <string>${escapeXml(HOME5)}</string>
+  <key>StandardOutPath</key>
+  <string>${escapeXml(join18(logDir, "launchd.out.log"))}</string>
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(join18(logDir, "launchd.err.log"))}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+${envEntries}
+  </dict>
+  <key>ProcessType</key>
+  <string>Interactive</string>
+</dict>
+</plist>
+`;
+};
+var escapeXml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+var buildSystemdUnit = (binary, env) => {
+  const envLines = Object.entries(env).map(([k, v]) => `Environment=${k}=${v}`).join(`
+`);
+  return `[Unit]
+Description=Multi agent daemon
+After=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${binary} connect
+Restart=always
+RestartSec=3
+WorkingDirectory=${HOME5}
+${envLines}
+
+[Install]
+WantedBy=default.target
+`;
+};
+var collectServiceEnv = () => {
+  const env = {};
+  if (process.env.PATH)
+    env.PATH = process.env.PATH;
+  if (process.env.HOME)
+    env.HOME = process.env.HOME;
+  if (process.env.MULTI_HOME)
+    env.MULTI_HOME = process.env.MULTI_HOME;
+  if (process.env.MULTI_API)
+    env.MULTI_API = process.env.MULTI_API;
+  if (process.env.SHELL)
+    env.SHELL = process.env.SHELL;
+  if (process.env.LANG)
+    env.LANG = process.env.LANG;
+  return env;
+};
+var ensureSupported = exports_Effect.fn("service.ensureSupported")(function* () {
+  if (!isMac() && !isLinux()) {
+    return yield* exports_Effect.fail(new UsageError({
+      message: `service commands are not supported on ${platform()} yet (macOS + Linux only).`
+    }));
+  }
+});
+var installMac = exports_Effect.fn("service.installMac")(function* (binary) {
+  const fs3 = yield* FileSystem;
+  const env = collectServiceEnv();
+  const plist = buildPlist(binary, env);
+  yield* fs3.mkdirp(join18(MULTI_DIR, "logs"));
+  yield* fs3.writeText(PLIST_PATH, plist);
+  yield* run6("launchctl", ["unload", PLIST_PATH]).pipe(exports_Effect.ignore);
+  yield* run6("launchctl", ["load", "-w", PLIST_PATH]);
+  console.log(`✅ Installed launchd agent at ${PLIST_PATH}`);
+  console.log(`   The daemon will start now and on every login.`);
+});
+var installLinux = exports_Effect.fn("service.installLinux")(function* (binary) {
+  const fs3 = yield* FileSystem;
+  const env = collectServiceEnv();
+  const unit = buildSystemdUnit(binary, env);
+  yield* fs3.mkdirp(join18(MULTI_DIR, "logs"));
+  yield* fs3.writeText(SYSTEMD_UNIT_PATH, unit);
+  yield* run6("systemctl", ["--user", "daemon-reload"]);
+  yield* run6("systemctl", ["--user", "enable", "--now", "multi-daemon.service"]);
+  console.log(`✅ Installed systemd user unit at ${SYSTEMD_UNIT_PATH}`);
+  console.log(`   The daemon will start now and on every login.`);
+  console.log(`   To keep it running after logout: loginctl enable-linger ${process.env.USER || ""}`.trimEnd());
+});
+var uninstallMac = exports_Effect.fn("service.uninstallMac")(function* () {
+  const fs3 = yield* FileSystem;
+  if (existsSync18(PLIST_PATH)) {
+    yield* run6("launchctl", ["unload", PLIST_PATH]).pipe(exports_Effect.ignore);
+    yield* fs3.remove(PLIST_PATH);
+    console.log(`\uD83D\uDDD1  Removed ${PLIST_PATH}`);
+  } else {
+    console.log("Nothing to uninstall (no plist found).");
+  }
+});
+var uninstallLinux = exports_Effect.fn("service.uninstallLinux")(function* () {
+  const fs3 = yield* FileSystem;
+  if (existsSync18(SYSTEMD_UNIT_PATH)) {
+    yield* run6("systemctl", ["--user", "disable", "--now", "multi-daemon.service"]).pipe(exports_Effect.ignore);
+    yield* fs3.remove(SYSTEMD_UNIT_PATH);
+    yield* run6("systemctl", ["--user", "daemon-reload"]).pipe(exports_Effect.ignore);
+    console.log(`\uD83D\uDDD1  Removed ${SYSTEMD_UNIT_PATH}`);
+  } else {
+    console.log("Nothing to uninstall (no unit found).");
+  }
+});
+var serviceCmd = exports_Effect.fn("serviceCmd")(function* (sub) {
+  yield* ensureSupported();
+  switch (sub) {
+    case "install": {
+      const binary = yield* resolveBinary();
+      if (isMac())
+        yield* installMac(binary);
+      else
+        yield* installLinux(binary);
+      return;
+    }
+    case "uninstall": {
+      if (isMac())
+        yield* uninstallMac();
+      else
+        yield* uninstallLinux();
+      return;
+    }
+    case "start": {
+      if (isMac()) {
+        if (!existsSync18(PLIST_PATH)) {
+          return yield* exports_Effect.fail(new DaemonError({
+            message: "Not installed. Run: multi-agent service install"
+          }));
+        }
+        yield* run6("launchctl", ["kickstart", "-k", `gui/${process.getuid?.() ?? ""}/${LABEL}`]).pipe(exports_Effect.ignore);
+        yield* run6("launchctl", ["load", "-w", PLIST_PATH]).pipe(exports_Effect.ignore);
+        console.log("▶  Started.");
+      } else {
+        yield* run6("systemctl", ["--user", "start", "multi-daemon.service"]);
+        console.log("▶  Started.");
+      }
+      return;
+    }
+    case "stop": {
+      if (isMac()) {
+        yield* run6("launchctl", ["unload", PLIST_PATH]).pipe(exports_Effect.ignore);
+        console.log("⏹  Stopped.");
+      } else {
+        yield* run6("systemctl", ["--user", "stop", "multi-daemon.service"]);
+        console.log("⏹  Stopped.");
+      }
+      return;
+    }
+    case "status":
+    case undefined: {
+      const installed = isMac() ? existsSync18(PLIST_PATH) : existsSync18(SYSTEMD_UNIT_PATH);
+      const pid = readPid();
+      const running3 = pid !== null && isRunningPid(pid);
+      console.log(`Service:   ${isMac() ? "launchd" : "systemd --user"}`);
+      console.log(`Installed: ${installed ? "yes" : "no"}`);
+      console.log(`Unit path: ${isMac() ? PLIST_PATH : SYSTEMD_UNIT_PATH}`);
+      console.log(`Daemon:    ${running3 ? `running (pid ${pid})` : "stopped"}`);
+      if (!installed)
+        console.log(`
+Not installed. Run: multi-agent service install`);
+      return;
+    }
+    default:
+      return yield* exports_Effect.fail(new UsageError({
+        message: `Unknown service subcommand: ${sub}. Use: install | uninstall | start | stop | status`
+      }));
+  }
+});
+
 // src/index.ts
 var VERSION = package_default.version;
 var COMMANDS = {
@@ -39847,7 +41207,8 @@ var COMMANDS = {
   restart: "Stop and relaunch the daemon in background",
   logs: "View execution logs",
   reset: "Reset acpx session for an issue (--issue <id>)",
-  worktree: "Manage per-issue worktrees (subcommands: gc, list, ...)"
+  worktree: "Manage per-issue worktrees (subcommands: gc, list, ...)",
+  service: "Manage the always-on daemon (subcommands: install, uninstall, start, stop, status)"
 };
 function printUsage() {
   console.log(`multi-agent v${VERSION}
@@ -39902,7 +41263,7 @@ var program = exports_Effect.gen(function* () {
     force: !!values3.force,
     noPush: !!values3["no-push"],
     key: values3.key
-  })), exports_Match.exhaustive);
+  })), exports_Match.when("service", () => serviceCmd(positionals[1])), exports_Match.exhaustive);
 });
 var main = program.pipe(exports_Effect.provide(AppLayer), exports_Effect.tapErrorCause((cause3) => exports_Effect.sync(() => {
   console.error(exports_Cause.pretty(cause3));