@shipers-dev/multi 0.39.2 → 0.43.0

package/dist/index.js

@@ -17109,7 +17109,7 @@ function setWorktreeIndexEntry(workingDir, key, issueId) {
   idx[key] = issueId;
   writeIndex(workingDir, idx);
 }
-async function ensureWorktree(workingDir, issueKey, issueId) {
+async function ensureWorktree(workingDir, issueKey, issueId, opts) {
   if (!await isGitRepo(workingDir)) {
     return { path: workingDir, branch: "", created: false };
   }
@@ -17126,8 +17126,19 @@ async function ensureWorktree(workingDir, issueKey, issueId) {
   try {
     mkdirSync3(wtDir, { recursive: true });
   } catch {}
+  let baseRef = "HEAD";
+  if (opts?.parentBranch) {
+    const localOk = await branchExists(workingDir, opts.parentBranch);
+    if (localOk) {
+      baseRef = opts.parentBranch;
+    } else {
+      const fetched = await run3(workingDir, "git", ["fetch", "origin", `${opts.parentBranch}:${opts.parentBranch}`]);
+      if (fetched.code === 0)
+        baseRef = opts.parentBranch;
+    }
+  }
   const exists4 = await branchExists(workingDir, branch);
-  const args2 = exists4 ? ["worktree", "add", wtPath, branch] : ["worktree", "add", "-b", branch, wtPath, "HEAD"];
+  const args2 = exists4 ? ["worktree", "add", wtPath, branch] : ["worktree", "add", "-b", branch, wtPath, baseRef];
   const r = await run3(workingDir, "git", args2);
   if (r.code !== 0) {
     throw new Error(`git worktree add failed: ${r.stderr || r.stdout}`);
@@ -17219,6 +17230,48 @@ async function removeWorktree(workingDir, issueKey, opts = {}) {
   removeWorktreeIndexEntry(workingDir, key);
   return result;
 }
+async function squashMergeChild(wtPath, childBranch, childKey) {
+  const result = { childKey, branch: childBranch, ok: false, empty: false, conflicts: [], message: "" };
+  await run3(wtPath, "git", ["fetch", "origin", `${childBranch}:${childBranch}`]).catch(() => null);
+  const haveLocal = await branchExists(wtPath, childBranch);
+  if (!haveLocal) {
+    result.message = `branch ${childBranch} not resolvable locally or via origin`;
+    return result;
+  }
+  const ahead = await run3(wtPath, "git", ["rev-list", "--count", `HEAD..${childBranch}`]);
+  if (ahead.code === 0 && Number((ahead.stdout || "0").trim()) === 0) {
+    result.ok = true;
+    result.empty = true;
+    result.message = `${childKey} had no commits ahead of parent — nothing to merge`;
+    return result;
+  }
+  const merge9 = await run3(wtPath, "git", ["merge", "--squash", "--no-commit", childBranch]);
+  const conflicted = await run3(wtPath, "git", ["diff", "--name-only", "--diff-filter=U"]);
+  const conflictPaths = (conflicted.stdout || "").split(`
+`).map((l) => l.trim()).filter(Boolean);
+  if (merge9.code !== 0 || conflictPaths.length > 0) {
+    result.conflicts = conflictPaths;
+    result.message = `${childKey} had ${conflictPaths.length} conflicting path(s); worktree left dirty for parent to resolve`;
+    return result;
+  }
+  const staged = await run3(wtPath, "git", ["diff", "--cached", "--name-only"]);
+  const stagedFiles = (staged.stdout || "").split(`
+`).map((l) => l.trim()).filter(Boolean);
+  if (stagedFiles.length === 0) {
+    result.ok = true;
+    result.empty = true;
+    result.message = `${childKey} produced no staged changes — nothing to commit`;
+    return result;
+  }
+  const commit = await run3(wtPath, "git", ["commit", "-m", `squash: ${childKey} (${childBranch})`]);
+  if (commit.code !== 0) {
+    result.message = `${childKey} commit failed: ${commit.stderr || commit.stdout}`;
+    return result;
+  }
+  result.ok = true;
+  result.message = `${childKey} squash-merged (${stagedFiles.length} file${stagedFiles.length === 1 ? "" : "s"})`;
+  return result;
+}
 var init_worktree = () => {};
 
 // ../../node_modules/zod/v4/core/core.js
@@ -33802,7 +33855,7 @@ function parsePlanBlocks(text) {
   }
   return { actions, errors: errors3 };
 }
-var PLAN_SCHEMA_VERSION = 2, Priority, AssigneeType, IssueStatus, SessionRole, SkillFile, PlanActionSchema, PlanEnvelopeSchema, UiBlockSchema, UI_FENCE_RE, FENCE_RE;
+var PLAN_SCHEMA_VERSION = 5, 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"]);
@@ -33810,6 +33863,12 @@ var init_plans = __esm(() => {
   IssueStatus = exports_external.enum(["todo", "in_progress", "done", "failed", "stopped", "cancelled"]);
   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({
+    evaluator_agent_id: exports_external.string().min(1),
+    threshold: exports_external.number().min(0).max(1),
+    on_fail: exports_external.enum(["retry", "fail", "comment"]).optional(),
+    max_retries: exports_external.number().int().min(0).max(10).optional()
+  });
   PlanActionSchema = exports_external.discriminatedUnion("type", [
     exports_external.object({
       type: exports_external.literal("create"),
@@ -33820,7 +33879,9 @@ var init_plans = __esm(() => {
       assignee_type: AssigneeType.optional(),
       assignee_id: exports_external.string().optional(),
       parent_id: exports_external.string().optional(),
-      blocked_by: exports_external.array(exports_external.string().min(1)).optional()
+      blocked_by: exports_external.array(exports_external.string().min(1)).optional(),
+      await_children: exports_external.boolean().optional(),
+      eval_policy: EvalPolicy.optional()
     }),
     exports_external.object({
       type: exports_external.literal("update"),
@@ -33831,7 +33892,8 @@ var init_plans = __esm(() => {
       priority: Priority.optional(),
       assignee_type: AssigneeType.optional(),
       assignee_id: exports_external.string().optional(),
-      blocked_by: exports_external.array(exports_external.string().min(1)).optional()
+      blocked_by: exports_external.array(exports_external.string().min(1)).optional(),
+      eval_policy: EvalPolicy.nullable().optional()
     }),
     exports_external.object({
       type: exports_external.literal("delegate"),
@@ -33870,7 +33932,7 @@ var init_plans = __esm(() => {
     exports_external.object({
       type: exports_external.literal("agent.create"),
       name: exports_external.string().min(1).max(120),
-      agent_type: exports_external.string().min(1),
+      agent_type: exports_external.string().min(1).optional(),
       prompt: exports_external.string().optional(),
       skill_ids: exports_external.array(exports_external.string()).optional(),
       allowed_tools: exports_external.array(exports_external.string()).optional()
@@ -33906,6 +33968,13 @@ var init_plans = __esm(() => {
       agent_id: exports_external.string().min(1),
       role: SessionRole,
       device_id: exports_external.string().optional()
+    }),
+    exports_external.object({
+      type: exports_external.literal("eval.submit"),
+      id: exports_external.string().min(1).optional(),
+      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()
     })
   ]);
   PlanEnvelopeSchema = exports_external.object({
@@ -34341,7 +34410,7 @@ async function handleRunTask(apiUrl, deviceId, task, detected, ctx) {
   let worktreeBranch = "";
   if (baseWorkingDir) {
     try {
-      const wt = await ensureWorktree(baseWorkingDir, task.key || issueId, issueId);
+      const wt = await ensureWorktree(baseWorkingDir, task.key || issueId, issueId, { parentBranch: task.parent_branch ?? undefined });
       workingDir = wt.path;
       worktreeBranch = wt.branch;
       await postStream(apiUrl, issueId, "worktree_created", { path: wt.path, branch: wt.branch, reused: !wt.created });
@@ -34356,6 +34425,44 @@ async function handleRunTask(apiUrl, deviceId, task, detected, ctx) {
       await postStream(apiUrl, issueId, "worktree_error", { message: fmtError(e) });
     }
   }
+  let mergeReportLines = [];
+  let mergeHadConflicts = false;
+  const mergeTargets = Array.isArray(task.merge_targets) ? task.merge_targets : [];
+  if (workingDir && mergeTargets.length) {
+    for (const t of mergeTargets) {
+      if (!t?.branch || !t?.child_key)
+        continue;
+      try {
+        const r = await squashMergeChild(workingDir, String(t.branch), String(t.child_key));
+        if (r.ok && r.empty) {
+          mergeReportLines.push(`- _empty_ ${t.child_key} → no changes`);
+        } else if (r.ok) {
+          mergeReportLines.push(`- ✅ ${t.child_key} squashed into ${worktreeBranch || "(parent)"}`);
+        } else if (r.conflicts.length) {
+          mergeHadConflicts = true;
+          mergeReportLines.push(`- ⚠ ${t.child_key} CONFLICT in: ${r.conflicts.join(", ")}`);
+        } else {
+          mergeReportLines.push(`- ✗ ${t.child_key} ${r.message}`);
+        }
+        await postStream(apiUrl, issueId, "child_merge", {
+          child_key: t.child_key,
+          branch: t.branch,
+          ok: r.ok,
+          empty: r.empty,
+          conflicts: r.conflicts,
+          message: r.message
+        });
+      } catch (e) {
+        mergeReportLines.push(`- ✗ ${t.child_key} merge threw: ${fmtError(e)}`);
+      }
+    }
+    if (mergeReportLines.length) {
+      const header = mergeHadConflicts ? "## ⚠ Squash-merge results — conflicts to resolve in your worktree" : "## Squash-merge results";
+      const block = [header, ...mergeReportLines, "", "---", ""].join(`
+`);
+      task.followup = block + (task.followup || "");
+    }
+  }
   log3(`▶ run_task ${task.key}: ${isFollowup ? "(follow-up) " : ""}${task.title}${workingDir ? ` [cwd: ${workingDir}${worktreeBranch ? ` @${worktreeBranch}` : ""}]` : ""}`);
   if (tenantWsId)
     await patchIssueStatus(apiUrl, tenantWsId, issueId, "in_progress");
@@ -34925,7 +35032,7 @@ Agent + skill self-service (use sparingly — only when you genuinely need a new
 
 \`\`\`multi-plan
 {"actions":[
-  {"type":"agent.create","name":"refactor-bot","agent_type":"claude-code","prompt":"You refactor TS code...","skill_ids":["sk_xxx"],"allowed_tools":["Read","Edit","Bash"]},
+  {"type":"agent.create","name":"refactor-bot","prompt":"You refactor TS code...","skill_ids":["sk_xxx"],"allowed_tools":["Read","Edit","Bash"]},
   {"type":"agent.update","id":"ag_xxx","prompt":"new prompt..."},
   {"type":"skill.create","name":"run-tests","description":"Run the test suite","body":"---\\nname: run-tests\\n---\\n\\n# Run tests\\n..."},
   {"type":"skill.attach","agent_id":"ag_xxx","skill_id":"sk_yyy"},
@@ -34950,8 +35057,11 @@ ${agentsBlock}
 }
 async function executePlanActions(apiUrl, parentTask, actions, ctx, parseErrors = []) {
   const lines = [];
-  for (const e of parseErrors)
+  const results = [];
+  for (const e of parseErrors) {
     lines.push(`- [err] plan parse: ${e.message}`);
+    results.push({ type: "parse", status: "error", error: e.message });
+  }
   let truncated = false;
   if (actions.length > PLAN_ACTION_LIMIT) {
     truncated = true;
@@ -34961,8 +35071,10 @@ async function executePlanActions(apiUrl, parentTask, actions, ctx, parseErrors
   if (depth >= PLANNING_DEPTH_LIMIT) {
     const blocked3 = actions.filter((a) => a.type !== "update").length;
     actions = actions.filter((a) => a.type === "update");
-    if (blocked3)
+    if (blocked3) {
       lines.push(`- [warn] ${blocked3} non-update action(s) blocked (planning depth limit ${PLANNING_DEPTH_LIMIT})`);
+      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 counts = {};
@@ -34973,6 +35085,7 @@ async function executePlanActions(apiUrl, parentTask, actions, ctx, parseErrors
     counts[a.type] = (counts[a.type] || 0) + 1;
     if (counts[a.type] > cap) {
       lines.push(`- [warn] ${a.type} sub-cap ${cap} hit, dropping extra`);
+      results.push({ type: a.type, status: "note", message: `${a.type} sub-cap ${cap} hit, dropping extra` });
       return false;
     }
     return true;
@@ -35008,22 +35121,27 @@ async function executePlanActions(apiUrl, parentTask, actions, ctx, parseErrors
           priority: a.priority,
           assignee_type: a.assignee_type,
           assignee_id: a.assignee_id,
-          parent_id: a.parent_id || parentId
+          parent_id: a.parent_id || parentId,
+          await_children: a.await_children
         };
         const res = await apiClient.post(mutateUrl, body, { headers });
         if (!res.success) {
           lines.push(`- [err] create "${a.title}": ${res.error || res.status}`);
+          results.push({ type: "create", status: "error", error: String(res.error || res.status), label: a.title });
           continue;
         }
         const created = res.data;
         lines.push(`- [ok] created **${created.key}** - ${created.title}${created.assignee_id ? ` -> @${created.assignee_id}` : ""} (autonomy=${created.autonomy_level || "auto"})`);
+        results.push({ type: "create", status: "ok", issue_id: created.id, key: created.key, title: created.title, assignee_id: created.assignee_id ?? null, assignee_type: created.assignee_type ?? null, priority: created.priority ?? null, autonomy_level: created.autonomy_level || "auto" });
       } else if (a.type === "update") {
         const res = await apiClient.post(mutateUrl, { action: "update", ...a }, { headers });
         if (!res.success) {
           lines.push(`- [err] update ${a.id}: ${res.error || res.status}`);
+          results.push({ type: "update", status: "error", error: String(res.error || res.status), label: a.id });
           continue;
         }
         lines.push(`- [ok] updated ${res.data.key}`);
+        results.push({ type: "update", status: "ok", issue_id: res.data.id, key: res.data.key, status_to: a.status ?? null, title_to: a.title ?? null });
         if ((a.status === "done" || a.status === "cancelled") && parentTask.working_dir && existsSync11(parentTask.working_dir)) {
           const targetKey = res.data?.key;
           if (targetKey) {
@@ -35038,9 +35156,11 @@ async function executePlanActions(apiUrl, parentTask, actions, ctx, parseErrors
         const res = await apiClient.post(mutateUrl, { action: "update", id: a.id, assignee_type: "agent", assignee_id: a.assignee_id, status: "todo" }, { headers });
         if (!res.success) {
           lines.push(`- [err] delegate ${a.id}: ${res.error || res.status}`);
+          results.push({ type: "delegate", status: "error", error: String(res.error || res.status), label: a.id });
           continue;
         }
         lines.push(`- [ok] delegated ${res.data.key} -> ${a.assignee_id}`);
+        results.push({ type: "delegate", status: "ok", issue_id: res.data.id, key: res.data.key, assignee_id: a.assignee_id });
       } else if (a.type === "handoff") {
         const res = await apiClient.post(mutateUrl, {
           action: "handoff",
@@ -35052,17 +35172,21 @@ async function executePlanActions(apiUrl, parentTask, actions, ctx, parseErrors
         }, { headers });
         if (!res.success) {
           lines.push(`- [err] handoff -> ${a.target_agent_id}: ${res.error || res.status}`);
+          results.push({ type: "handoff", status: "error", error: String(res.error || res.status), label: a.target_agent_id });
           continue;
         }
         const blocked3 = res.data?.blocked ? " (blocked parent)" : "";
         lines.push(`- [ok] handoff -> ${a.target_agent_id} via **${res.data?.child_key}**${blocked3} expect=${a.expect ?? "summary"}`);
+        results.push({ type: "handoff", status: "ok", issue_id: res.data?.child_id, key: res.data?.child_key, assignee_id: a.target_agent_id, blocked: !!res.data?.blocked, expect: a.expect ?? "summary" });
       } else if (a.type === "issue.delete") {
         const res = await apiClient.post(mutateUrl, { action: "delete", id: a.id }, { headers });
         if (!res.success) {
           lines.push(`- [err] issue.delete ${a.id}: ${res.error || res.status}`);
+          results.push({ type: "issue.delete", status: "error", error: String(res.error || res.status), label: a.id });
           continue;
         }
         lines.push(`- [ok] deleted ${res.data?.key || a.id}`);
+        results.push({ type: "issue.delete", status: "ok", key: res.data?.key || a.id, issue_id: res.data?.id || a.id });
       } else if (a.type === "issue.delete_where") {
         const res = await apiClient.post(mutateUrl, {
           action: "delete_where",
@@ -35073,17 +35197,20 @@ async function executePlanActions(apiUrl, parentTask, actions, ctx, parseErrors
         }, { headers });
         if (!res.success) {
           lines.push(`- [err] issue.delete_where: ${res.error || res.status}`);
+          results.push({ type: "issue.delete_where", status: "error", error: String(res.error || res.status) });
           continue;
         }
         const rows = Array.isArray(res.data?.deleted) ? res.data.deleted : [];
         const count3 = res.data?.count ?? rows.length;
         if (!count3) {
           lines.push(`- [ok] issue.delete_where: 0 matches`);
+          results.push({ type: "issue.delete_where", status: "ok", count: 0, keys: [] });
           continue;
         }
         lines.push(`- [ok] issue.delete_where: deleted ${count3} issue(s)`);
         for (const r of rows)
           lines.push(`  - ${r.key}`);
+        results.push({ type: "issue.delete_where", status: "ok", count: count3, keys: rows.map((r) => r.key) });
       } else if (a.type === "issue.list") {
         const res = await apiClient.post(queryUrl, {
           kind: "list",
@@ -35094,17 +35221,20 @@ async function executePlanActions(apiUrl, parentTask, actions, ctx, parseErrors
         }, { headers });
         if (!res.success) {
           lines.push(`- [err] issue.list: ${res.error || res.status}`);
+          results.push({ type: "issue.list", status: "error", error: String(res.error || res.status) });
           continue;
         }
         const rows = Array.isArray(res.data) ? res.data : Array.isArray(res.data?.results) ? res.data.results : [];
         if (!rows.length) {
           lines.push(`- [ok] issue.list: 0 issues`);
+          results.push({ type: "issue.list", status: "ok", count: 0 });
           continue;
         }
         lines.push(`- [ok] issue.list: ${rows.length} issue(s)`);
         for (const r of rows) {
           lines.push(`  - **${r.key}** [${r.status}] ${r.title}${r.assignee_id ? ` (@${r.assignee_id})` : ""}`);
         }
+        results.push({ type: "issue.list", status: "ok", count: rows.length });
       } else if (a.type === "issue.search") {
         const res = await apiClient.post(queryUrl, {
           kind: "search",
@@ -35114,75 +35244,95 @@ async function executePlanActions(apiUrl, parentTask, actions, ctx, parseErrors
         }, { headers });
         if (!res.success) {
           lines.push(`- [err] issue.search "${a.query}": ${res.error || res.status}`);
+          results.push({ type: "issue.search", status: "error", error: String(res.error || res.status), label: a.query });
           continue;
         }
         const rows = Array.isArray(res.data) ? res.data : Array.isArray(res.data?.results) ? res.data.results : [];
         if (!rows.length) {
           lines.push(`- [ok] issue.search "${a.query}": 0 hits`);
+          results.push({ type: "issue.search", status: "ok", count: 0, query: a.query });
           continue;
         }
         lines.push(`- [ok] issue.search "${a.query}": ${rows.length} hit(s)`);
         for (const r of rows) {
           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 === "agent.create") {
         if (!parentWsId) {
           lines.push(`- [err] agent.create "${a.name}": no tenant workspace id`);
+          results.push({ type: "agent.create", status: "error", error: "no tenant workspace id", label: a.name });
           continue;
         }
-        const res = await apiClient.post(`${apiUrl}/api/workspaces/${parentWsId}/agent_ops/agents/mutate`, { action: "create", name: a.name, type: a.agent_type, prompt: a.prompt, skill_ids: a.skill_ids, allowed_tools: a.allowed_tools, capabilities: a.capabilities }, { headers });
+        const res = await apiClient.post(`${apiUrl}/api/workspaces/${parentWsId}/agent_ops/agents/mutate`, { action: "create", name: a.name, prompt: a.prompt, skill_ids: a.skill_ids, allowed_tools: a.allowed_tools, capabilities: a.capabilities }, { headers });
         if (!res.success) {
           lines.push(`- [err] agent.create "${a.name}": ${res.error || res.status}`);
+          results.push({ type: "agent.create", status: "error", error: String(res.error || res.status), label: a.name });
           continue;
         }
         lines.push(`- [ok] agent.create "${a.name}" -> ${res.data?.agent_id}`);
+        results.push({ type: "agent.create", status: "ok", agent_id: res.data?.agent_id, name: a.name, allowed_tools_count: Array.isArray(a.allowed_tools) ? a.allowed_tools.length : 0, approval_status: "approved" });
       } else if (a.type === "agent.update") {
         if (!parentWsId) {
           lines.push(`- [err] agent.update ${a.id}: no tenant workspace id`);
+          results.push({ type: "agent.update", status: "error", error: "no tenant workspace id", label: a.id });
           continue;
         }
         const res = await apiClient.post(`${apiUrl}/api/workspaces/${parentWsId}/agent_ops/agents/mutate`, { action: "update", ...a }, { headers });
         if (!res.success) {
           lines.push(`- [err] agent.update ${a.id}: ${res.error || res.status}`);
+          results.push({ type: "agent.update", status: "error", error: String(res.error || res.status), label: a.id });
           continue;
         }
-        if (res.data?.queued)
+        const changed = ["name", "prompt", "allowed_tools"].filter((k) => a[k] !== undefined);
+        if (res.data?.queued) {
           lines.push(`- [pending] agent.update ${a.id} queued`);
-        else
+          results.push({ type: "agent.update", status: "ok", agent_id: a.id, queued: true, pending_op_id: res.data?.pending_op_id, changed });
+        } else {
           lines.push(`- [ok] agent.update ${a.id}`);
+          results.push({ type: "agent.update", status: "ok", agent_id: a.id, queued: false, changed });
+        }
       } else if (a.type === "skill.create") {
         if (!parentWsId) {
           lines.push(`- [err] skill.create "${a.name}": no tenant workspace id`);
+          results.push({ type: "skill.create", status: "error", error: "no tenant workspace id", label: a.name });
           continue;
         }
         const res = await apiClient.post(`${apiUrl}/api/workspaces/${parentWsId}/agent_ops/skills/mutate`, { action: "create", name: a.name, version: a.version, description: a.description, body: a.body, files: a.files }, { headers });
         if (!res.success) {
           lines.push(`- [err] skill.create "${a.name}": ${res.error || res.status}`);
+          results.push({ type: "skill.create", status: "error", error: String(res.error || res.status), label: a.name });
           continue;
         }
         lines.push(`- [pending] skill.create "${a.name}" queued for human review (op ${res.data?.pending_op_id})`);
+        results.push({ type: "skill.create", status: "ok", pending_op_id: res.data?.pending_op_id, name: a.name, description: a.description });
       } else if (a.type === "session.create") {
         if (!parentWsId) {
           lines.push(`- [err] session.create role=${a.role}: no tenant workspace id`);
+          results.push({ type: "session.create", status: "error", error: "no tenant workspace id" });
           continue;
         }
         const res = await apiClient.post(`${apiUrl}/api/workspaces/${parentWsId}/sessions`, { workspace_id: a.workspace_id, agent_id: a.agent_id, role: a.role, device_id: a.device_id }, { headers });
         if (!res.success) {
           lines.push(`- [err] session.create role=${a.role}: ${res.error || res.status}`);
+          results.push({ type: "session.create", status: "error", error: String(res.error || res.status) });
           continue;
         }
         const sess = res.data?.session;
         const reused = res.data?.reused;
         lines.push(`- [${reused ? "reuse" : "ok"}] session.${reused ? "reuse" : "create"} ${sess?.id?.slice(0, 8) || "?"} (role=${a.role})`);
+        results.push({ type: "session.create", status: "ok", session_id: sess?.id, role: a.role, agent_id: a.agent_id, reused: !!reused });
       } else if (a.type === "eval.submit") {
         if (!parentWsId) {
           lines.push(`- [err] eval.submit: no tenant workspace id`);
+          results.push({ type: "eval.submit", status: "error", error: "no tenant workspace id" });
           continue;
         }
         const url2 = `${apiUrl}/api/workspaces/${parentWsId}/agent/issues/eval/submit`;
         const res = await apiClient.post(url2, { id: a.id, score: a.score, feedback: a.feedback, scores: a.scores }, { headers });
         if (!res.success) {
           lines.push(`- [err] eval.submit: ${res.error || res.status}`);
+          results.push({ type: "eval.submit", status: "error", error: String(res.error || res.status) });
           continue;
         }
         const verdict = res.data?.verdict;
@@ -35190,34 +35340,48 @@ async function executePlanActions(apiUrl, parentTask, actions, ctx, parseErrors
         const attempt = res.data?.attempt;
         const tag3 = verdict === "pass" ? "ok" : "warn";
         lines.push(`- [${tag3}] eval.submit verdict=${verdict} score=${a.score.toFixed(2)} attempt=${attempt}${action ? ` action=${action}` : ""}`);
+        results.push({ type: "eval.submit", status: "ok", verdict, score: a.score, attempt, action_taken: action });
       } else if (a.type === "skill.attach" || a.type === "skill.detach") {
         const action = a.type === "skill.attach" ? "attach_skill" : "detach_skill";
         if (!parentWsId) {
           lines.push(`- [err] ${a.type}: no tenant workspace id`);
+          results.push({ type: a.type, status: "error", error: "no tenant workspace id" });
           continue;
         }
         const res = await apiClient.post(`${apiUrl}/api/workspaces/${parentWsId}/agent_ops/agents/mutate`, { action, agent_id: a.agent_id, skill_id: a.skill_id }, { headers });
         if (!res.success) {
           lines.push(`- [err] ${a.type} ${a.skill_id}->${a.agent_id}: ${res.error || res.status}`);
+          results.push({ type: a.type, status: "error", error: String(res.error || res.status), label: `${a.skill_id}->${a.agent_id}` });
           continue;
         }
-        if (res.data?.queued)
+        if (res.data?.queued) {
           lines.push(`- [pending] ${a.type} queued`);
-        else
+          results.push({ type: a.type, status: "ok", agent_id: a.agent_id, skill_id: a.skill_id, queued: true, pending_op_id: res.data?.pending_op_id });
+        } else {
           lines.push(`- [ok] ${a.type} ${a.skill_id} <-> ${a.agent_id}`);
+          results.push({ type: a.type, status: "ok", agent_id: a.agent_id, skill_id: a.skill_id, queued: false });
+        }
       }
     } catch (e) {
       lines.push(`- [err] ${a.type} failed: ${String(e)}`);
+      results.push({ type: a.type, status: "error", error: String(e) });
     }
   }
-  if (truncated)
+  if (truncated) {
     lines.push(`- [warn] action list truncated at ${PLAN_ACTION_LIMIT}`);
+    results.push({ type: "note", status: "note", message: `Action list truncated at ${PLAN_ACTION_LIMIT}` });
+  }
   if (!lines.length)
     return "";
+  const json2 = JSON.stringify({ version: 1, actions: results });
   return `**Planning actions**
 
 ${lines.join(`
-`)}`;
+`)}
+
+\`\`\`multi-actions
+${json2}
+\`\`\``;
 }
 function stripMd(s) {
   return s.replace(/[`*_]/g, "").trim();
@@ -35822,6 +35986,22 @@ class ChatPeer {
   getDoc() {
     return this.doc;
   }
+  findMessage(id3) {
+    for (const m of listMessages(this.doc))
+      if (m.id === id3)
+        return m;
+    return null;
+  }
+  async awaitMessage(id3, timeoutMs = 5000) {
+    const start3 = Date.now();
+    while (Date.now() - start3 < timeoutMs) {
+      const found = this.findMessage(id3);
+      if (found)
+        return found;
+      await new Promise((r) => setTimeout(r, 50));
+    }
+    return null;
+  }
   start() {
     this.connect();
   }
@@ -35898,8 +36078,9 @@ class ChatPeer {
         if (before2.has(m.id))
           continue;
         this.seenIds.add(m.id);
-        if (m.author?.kind === "user" && !m.partial) {
-          Promise.resolve().then(() => this.opts.onUserMessage(m, this)).catch((e) => this.opts.log(`[chat ${this.chatId}] onUserMessage error: ${e.message}`));
+        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++;
@@ -36046,8 +36227,11 @@ var init_chat_turn = __esm(() => {
 // src/_impl/chat-plan-actions.ts
 async function executeChatPlanActions(actionsIn, parseErrors, ctx) {
   const lines = [];
-  for (const e of parseErrors)
+  const results = [];
+  for (const e of parseErrors) {
     lines.push(`- [err] plan parse: ${e.message}`);
+    results.push({ type: "parse", status: "error", error: e.message });
+  }
   let actions = actionsIn;
   let truncated = false;
   if (actions.length > PLAN_ACTION_LIMIT2) {
@@ -36062,6 +36246,7 @@ async function executeChatPlanActions(actionsIn, parseErrors, ctx) {
     counts[a.type] = (counts[a.type] || 0) + 1;
     if (counts[a.type] > cap) {
       lines.push(`- [warn] ${a.type} sub-cap ${cap} hit, dropping extra`);
+      results.push({ type: a.type, status: "note", message: `${a.type} sub-cap ${cap} hit, dropping extra` });
       return false;
     }
     return true;
@@ -36092,6 +36277,7 @@ async function executeChatPlanActions(actionsIn, parseErrors, ctx) {
         const project_id = a.project_id || ctx.projectId;
         if (!project_id) {
           lines.push(`- [err] create "${a.title}": project_id required (chat has no pinned project)`);
+          results.push({ type: "create", status: "error", error: "project_id required (chat has no pinned project)", label: a.title });
           tally(false);
           continue;
         }
@@ -36103,34 +36289,41 @@ async function executeChatPlanActions(actionsIn, parseErrors, ctx) {
           priority: a.priority,
           assignee_type: a.assignee_type,
           assignee_id: a.assignee_id,
-          parent_id: a.parent_id
+          parent_id: a.parent_id,
+          await_children: a.await_children
         };
         const res = await apiClient.post(mutateUrl, body, { headers });
         if (!res.success) {
           lines.push(`- [err] create "${a.title}": ${res.error || res.status}`);
+          results.push({ type: "create", status: "error", error: String(res.error || res.status), label: a.title });
           tally(false);
           continue;
         }
         const created = res.data;
         lines.push(`- [ok] created **${created.key}** - ${created.title}${created.assignee_id ? ` -> @${created.assignee_id}` : ""}`);
+        results.push({ type: "create", status: "ok", issue_id: created.id, key: created.key, title: created.title, assignee_id: created.assignee_id ?? null, assignee_type: created.assignee_type ?? null, priority: created.priority ?? null, autonomy_level: created.autonomy_level || "auto" });
         tally(true);
       } else if (a.type === "update") {
         const res = await apiClient.post(mutateUrl, { action: "update", ...a }, { headers });
         if (!res.success) {
           lines.push(`- [err] update ${a.id}: ${res.error || res.status}`);
+          results.push({ type: "update", status: "error", error: String(res.error || res.status), label: a.id });
           tally(false);
           continue;
         }
         lines.push(`- [ok] updated ${res.data.key}`);
+        results.push({ type: "update", status: "ok", issue_id: res.data.id, key: res.data.key, status_to: a.status ?? null, title_to: a.title ?? null });
         tally(true);
       } else if (a.type === "delegate") {
         const res = await apiClient.post(mutateUrl, { action: "update", id: a.id, assignee_type: "agent", assignee_id: a.assignee_id, status: "todo" }, { headers });
         if (!res.success) {
           lines.push(`- [err] delegate ${a.id}: ${res.error || res.status}`);
+          results.push({ type: "delegate", status: "error", error: String(res.error || res.status), label: a.id });
           tally(false);
           continue;
         }
         lines.push(`- [ok] delegated ${res.data.key} -> ${a.assignee_id}`);
+        results.push({ type: "delegate", status: "ok", issue_id: res.data.id, key: res.data.key, assignee_id: a.assignee_id });
         tally(true);
       } else if (a.type === "handoff") {
         const res = await apiClient.post(mutateUrl, {
@@ -36143,40 +36336,48 @@ async function executeChatPlanActions(actionsIn, parseErrors, ctx) {
         }, { headers });
         if (!res.success) {
           lines.push(`- [err] handoff -> ${a.target_agent_id}: ${res.error || res.status}`);
+          results.push({ type: "handoff", status: "error", error: String(res.error || res.status), label: a.target_agent_id });
           tally(false);
           continue;
         }
         lines.push(`- [ok] handoff -> ${a.target_agent_id} via **${res.data?.child_key}** expect=${a.expect ?? "summary"}`);
+        results.push({ type: "handoff", status: "ok", issue_id: res.data?.child_id, key: res.data?.child_key, assignee_id: a.target_agent_id, expect: a.expect ?? "summary" });
         tally(true);
       } else if (a.type === "issue.comment") {
         const res = await apiClient.post(mutateUrl, { action: "comment", id: a.id, body: a.body }, { headers });
         if (!res.success) {
           lines.push(`- [err] issue.comment ${a.id}: ${res.error || res.status}`);
+          results.push({ type: "issue.comment", status: "error", error: String(res.error || res.status), label: a.id });
           tally(false);
           continue;
         }
         const dispatched = res.data?.dispatched;
         lines.push(`- [ok] commented on ${a.id}${dispatched ? " -> dispatched agent" : ""}`);
+        results.push({ type: "issue.comment", status: "ok", issue_id: a.id, dispatched: !!dispatched });
         tally(true);
       } else if (a.type === "issue.delete") {
         const res = await apiClient.post(mutateUrl, { action: "delete", id: a.id }, { headers });
         if (!res.success) {
           lines.push(`- [err] issue.delete ${a.id}: ${res.error || res.status}`);
+          results.push({ type: "issue.delete", status: "error", error: String(res.error || res.status), label: a.id });
           tally(false);
           continue;
         }
         lines.push(`- [ok] deleted ${res.data?.key || a.id}`);
+        results.push({ type: "issue.delete", status: "ok", key: res.data?.key || a.id, issue_id: res.data?.id || a.id });
         tally(true);
       } else if (a.type === "issue.delete_where") {
         const project_id = a.project_id || ctx.projectId;
         if (!project_id) {
           lines.push(`- [err] issue.delete_where: project_id required`);
+          results.push({ type: "issue.delete_where", status: "error", error: "project_id required" });
           tally(false);
           continue;
         }
         const res = await apiClient.post(mutateUrl, { action: "delete_where", project_id, status: a.status, assignee_id: a.assignee_id, limit: a.limit ?? 50 }, { headers });
         if (!res.success) {
           lines.push(`- [err] issue.delete_where: ${res.error || res.status}`);
+          results.push({ type: "issue.delete_where", status: "error", error: String(res.error || res.status) });
           tally(false);
           continue;
         }
@@ -36185,18 +36386,21 @@ async function executeChatPlanActions(actionsIn, parseErrors, ctx) {
         lines.push(`- [ok] issue.delete_where: deleted ${count3} issue(s)`);
         for (const r of rows)
           lines.push(`  - ${r.key}`);
+        results.push({ type: "issue.delete_where", status: "ok", count: count3, keys: rows.map((r) => r.key) });
         tally(true);
       } else if (a.type === "issue.list") {
         const project_id = a.project_id || ctx.projectId;
         const res = await apiClient.post(queryUrl, { kind: "list", project_id, status: a.status, assignee_id: a.assignee_id, limit: a.limit ?? 20 }, { headers });
         if (!res.success) {
           lines.push(`- [err] issue.list: ${res.error || res.status}`);
+          results.push({ type: "issue.list", status: "error", error: String(res.error || res.status) });
           tally(false);
           continue;
         }
         const rows = Array.isArray(res.data) ? res.data : Array.isArray(res.data?.results) ? res.data.results : [];
         if (!rows.length) {
           lines.push(`- [ok] issue.list: 0 issues`);
+          results.push({ type: "issue.list", status: "ok", count: 0 });
           tally(true);
           continue;
         }
@@ -36204,12 +36408,14 @@ async function executeChatPlanActions(actionsIn, parseErrors, ctx) {
         for (const r of rows) {
           lines.push(`  - **${r.key}** [${r.status}] ${r.title}${r.assignee_id ? ` (@${r.assignee_id})` : ""}`);
         }
+        results.push({ type: "issue.list", status: "ok", count: rows.length });
         tally(true);
       } else if (a.type === "issue.search") {
         const project_id = a.project_id || ctx.projectId;
         const res = await apiClient.post(queryUrl, { kind: "search", project_id, query: a.query, limit: a.limit ?? 10 }, { headers });
         if (!res.success) {
           lines.push(`- [err] issue.search "${a.query}": ${res.error || res.status}`);
+          results.push({ type: "issue.search", status: "error", error: String(res.error || res.status), label: a.query });
           tally(false);
           continue;
         }
@@ -36217,12 +36423,12 @@ async function executeChatPlanActions(actionsIn, parseErrors, ctx) {
         lines.push(`- [ok] issue.search "${a.query}": ${rows.length} hit(s)`);
         for (const r of rows)
           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 === "agent.create") {
         const res = await apiClient.post(agentsMutateUrl, {
           action: "create",
           name: a.name,
-          type: a.agent_type,
           prompt: a.prompt,
           skill_ids: a.skill_ids,
           allowed_tools: a.allowed_tools,
@@ -36230,19 +36436,24 @@ async function executeChatPlanActions(actionsIn, parseErrors, ctx) {
         }, { headers });
         if (!res.success) {
           lines.push(`- [err] agent.create "${a.name}": ${res.error || res.status}`);
+          results.push({ type: "agent.create", status: "error", error: String(res.error || res.status), label: a.name });
           tally(false);
           continue;
         }
         lines.push(`- [ok] agent.create "${a.name}" -> ${res.data?.agent_id}`);
+        results.push({ type: "agent.create", status: "ok", agent_id: res.data?.agent_id, name: a.name, allowed_tools_count: Array.isArray(a.allowed_tools) ? a.allowed_tools.length : 0, approval_status: "approved" });
         tally(true);
       } else if (a.type === "agent.update") {
         const res = await apiClient.post(agentsMutateUrl, { action: "update", ...a }, { headers });
         if (!res.success) {
           lines.push(`- [err] agent.update ${a.id}: ${res.error || res.status}`);
+          results.push({ type: "agent.update", status: "error", error: String(res.error || res.status), label: a.id });
           tally(false);
           continue;
         }
+        const changed = ["name", "prompt", "allowed_tools"].filter((k) => a[k] !== undefined);
         lines.push(res.data?.queued ? `- [pending] agent.update ${a.id} queued` : `- [ok] agent.update ${a.id}`);
+        results.push({ type: "agent.update", status: "ok", agent_id: a.id, queued: !!res.data?.queued, pending_op_id: res.data?.pending_op_id, changed });
         tally(true);
       } else if (a.type === "skill.create") {
         const res = await apiClient.post(skillsMutateUrl, {
@@ -36255,53 +36466,68 @@ async function executeChatPlanActions(actionsIn, parseErrors, ctx) {
         }, { headers });
         if (!res.success) {
           lines.push(`- [err] skill.create "${a.name}": ${res.error || res.status}`);
+          results.push({ type: "skill.create", status: "error", error: String(res.error || res.status), label: a.name });
           tally(false);
           continue;
         }
         const queued = res.data?.pending_op_id;
         lines.push(queued ? `- [pending] skill.create "${a.name}" queued for human review (op ${queued})` : `- [ok] skill.create "${a.name}" -> ${res.data?.skill_id}`);
+        results.push({ type: "skill.create", status: "ok", pending_op_id: queued, name: a.name, description: a.description });
         tally(true);
       } else if (a.type === "skill.attach" || a.type === "skill.detach") {
         const action = a.type === "skill.attach" ? "attach_skill" : "detach_skill";
         const res = await apiClient.post(agentsMutateUrl, { action, agent_id: a.agent_id, skill_id: a.skill_id }, { headers });
         if (!res.success) {
           lines.push(`- [err] ${a.type} ${a.skill_id}->${a.agent_id}: ${res.error || res.status}`);
+          results.push({ type: a.type, status: "error", error: String(res.error || res.status), label: `${a.skill_id}->${a.agent_id}` });
           tally(false);
           continue;
         }
         lines.push(res.data?.queued ? `- [pending] ${a.type} queued` : `- [ok] ${a.type} ${a.skill_id} <-> ${a.agent_id}`);
+        results.push({ type: a.type, status: "ok", agent_id: a.agent_id, skill_id: a.skill_id, queued: !!res.data?.queued, pending_op_id: res.data?.pending_op_id });
         tally(true);
       } else if (a.type === "session.create") {
         const res = await apiClient.post(sessionsUrl, { workspace_id: a.workspace_id, agent_id: a.agent_id, role: a.role, device_id: a.device_id }, { headers });
         if (!res.success) {
           lines.push(`- [err] session.create role=${a.role}: ${res.error || res.status}`);
+          results.push({ type: "session.create", status: "error", error: String(res.error || res.status) });
           tally(false);
           continue;
         }
         const sess = res.data?.session;
         const reused = res.data?.reused;
         lines.push(`- [${reused ? "reuse" : "ok"}] session.${reused ? "reuse" : "create"} ${sess?.id?.slice(0, 8) || "?"} (role=${a.role})`);
+        results.push({ type: "session.create", status: "ok", session_id: sess?.id, role: a.role, agent_id: a.agent_id, reused: !!reused });
         tally(true);
       } else if (a.type === "eval.submit") {
         lines.push(`- [err] eval.submit not allowed in chat (only inside an eval dispatch)`);
+        results.push({ type: "eval.submit", status: "error", error: "eval.submit not allowed in chat" });
         tally(false);
       }
     } catch (e) {
       lines.push(`- [err] ${a.type} failed: ${String(e)}`);
+      results.push({ type: a.type, status: "error", error: String(e) });
       tally(false);
     }
   }
-  if (truncated)
+  if (truncated) {
     lines.push(`- [warn] action list truncated at ${PLAN_ACTION_LIMIT2}`);
-  return { ok, fail: fail12, lines };
+    results.push({ type: "note", status: "note", message: `Action list truncated at ${PLAN_ACTION_LIMIT2}` });
+  }
+  return { ok, fail: fail12, lines, results };
 }
 function renderChatPlanSummary(res) {
   if (!res.lines.length)
     return "";
+  const json2 = JSON.stringify({ version: 1, actions: res.results });
   return `**Planning actions**
 
 ${res.lines.join(`
-`)}`;
+`)}
+
+\`\`\`multi-actions
+${json2}
+\`\`\``;
 }
 var PLAN_ACTION_LIMIT2 = 10, SUBCAPS;
 var init_chat_plan_actions = __esm(() => {
@@ -36321,391 +36547,327 @@ var init_chat_plan_actions = __esm(() => {
 // src/_impl/chat-supervisor.ts
 var exports_chat_supervisor = {};
 __export(exports_chat_supervisor, {
-  ChatSupervisor: () => ChatSupervisor
-});
-
-class ChatSupervisor {
-  opts;
-  peers = new Map;
-  chats = new Map;
-  timer = null;
-  closed = false;
-  constructor(opts) {
-    this.opts = opts;
-  }
-  start() {
-    this.refresh().catch((e) => this.opts.log(`[chats] refresh err: ${e.message}`));
-    this.timer = setInterval(() => {
-      this.refresh().catch((e) => this.opts.log(`[chats] refresh err: ${e.message}`));
-    }, 30000);
-  }
-  close() {
-    this.closed = true;
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = null;
-    }
-    for (const p of this.peers.values())
-      p.close();
-    this.peers.clear();
+  runChatTurn: () => runChatTurn
+});
+async function runChatTurn(opts) {
+  const { apiUrl, authToken: authToken2, workspaceId, chatId, messageId, log: log4 } = opts;
+  const headers = { authorization: `Bearer ${authToken2}` };
+  const metaR = await fetch(`${apiUrl}/api/workspaces/${workspaceId}/chats/${chatId}`, { headers });
+  if (!metaR.ok) {
+    log4(`[chat ${chatId}] meta fetch failed: ${metaR.status}`);
+    return;
   }
-  async refresh() {
-    if (this.closed)
+  const chat2 = await metaR.json();
+  const peer = new ChatPeer({
+    apiUrl,
+    authToken: authToken2,
+    workspaceId,
+    chatId,
+    primaryAgentId: chat2.primary_agent_id,
+    log: log4
+  });
+  peer.start();
+  try {
+    const msg = await peer.awaitMessage(messageId, 7000);
+    if (!msg) {
+      log4(`[chat ${chatId}] message ${messageId} not visible after sync; aborting`);
       return;
-    const all8 = await this.listAllChats();
-    const mine = all8.filter((c) => c.device_id && c.device_id === this.opts.deviceId);
-    const want = new Set;
-    for (const c of mine) {
-      want.add(c.id);
-      this.chats.set(c.id, c);
-      if (!this.peers.has(c.id)) {
-        const peer = new ChatPeer({
-          apiUrl: this.opts.apiUrl,
-          authToken: this.opts.authToken,
-          workspaceId: this.opts.workspaceId,
-          chatId: c.id,
-          primaryAgentId: c.primary_agent_id,
-          log: this.opts.log,
-          onUserMessage: async (msg, p) => this.onUserMessage(c, msg, p)
-        });
-        peer.start();
-        this.peers.set(c.id, peer);
-        this.opts.log(`[chats] watching ${c.id} (${c.title})`);
-      }
-    }
-    for (const [id3, peer] of this.peers) {
-      if (!want.has(id3)) {
-        peer.close();
-        this.peers.delete(id3);
-        this.chats.delete(id3);
-        this.opts.log(`[chats] released ${id3}`);
-      }
     }
+    await processUserMessage(chat2, msg, peer, { apiUrl, authToken: authToken2, workspaceId, log: log4 });
+  } finally {
+    peer.close();
   }
-  async listAllChats() {
-    const headers = { authorization: `Bearer ${this.opts.authToken}` };
-    const out = [];
-    try {
-      const r = await fetch(`${this.opts.apiUrl}/api/workspaces/${this.opts.workspaceId}/chats`, { headers });
-      if (r.ok) {
-        const body = await r.json();
-        for (const x of body.results)
-          out.push(x);
-      }
-    } catch {}
-    try {
-      const pr = await fetch(`${this.opts.apiUrl}/api/workspaces/${this.opts.workspaceId}/devices/me/projects`, { headers });
-      if (pr.ok) {
-        const pbody = await pr.json();
-        for (const pid of pbody.project_ids) {
-          try {
-            const cr = await fetch(`${this.opts.apiUrl}/api/workspaces/${this.opts.workspaceId}/projects/${pid}/chats`, { headers });
-            if (cr.ok) {
-              const cbody = await cr.json();
-              for (const x of cbody.results)
-                out.push(x);
-            }
-          } catch {}
-        }
-      }
-    } catch {}
-    return out;
+}
+async function fetchAgents(apiUrl, workspaceId, authToken2) {
+  const headers = { authorization: `Bearer ${authToken2}` };
+  try {
+    const r = await fetch(`${apiUrl}/api/workspaces/${workspaceId}/agents`, { headers });
+    if (!r.ok)
+      return [];
+    const body = await r.json();
+    const arr = Array.isArray(body) ? body : Array.isArray(body.results) ? body.results : [];
+    return arr.map((a) => ({ id: a.id, name: a.name }));
+  } catch {
+    return [];
   }
-  async resolveCwd(chat2) {
-    if (!chat2.project_id || !chat2.device_id)
-      return;
-    const headers = { authorization: `Bearer ${this.opts.authToken}` };
-    try {
-      const r = await fetch(`${this.opts.apiUrl}/api/workspaces/${this.opts.workspaceId}/projects/${chat2.project_id}/devices`, { headers });
-      if (!r.ok)
-        return;
-      const body = await r.json();
-      const row = body.results.find((d) => d.id === chat2.device_id);
-      return row?.working_dir || undefined;
-    } catch {
+}
+function resolveAgentFromMention(agents, mentioned) {
+  if (!mentioned)
+    return null;
+  const m = mentioned.toLowerCase();
+  return agents.find((a) => a.name?.toLowerCase() === m || a.id === mentioned) ?? null;
+}
+async function resolveCwd(apiUrl, workspaceId, authToken2, chat2) {
+  if (!chat2.project_id || !chat2.device_id)
+    return;
+  const headers = { authorization: `Bearer ${authToken2}` };
+  try {
+    const r = await fetch(`${apiUrl}/api/workspaces/${workspaceId}/projects/${chat2.project_id}/devices`, { headers });
+    if (!r.ok)
       return;
-    }
+    const body = await r.json();
+    const row = body.results.find((d) => d.id === chat2.device_id);
+    return row?.working_dir || undefined;
+  } catch {
+    return;
   }
-  async resolveAgentRuntime(chat2, agentId) {
-    if (chat2.runtime)
-      return chat2.runtime;
-    if (!agentId || typeof agentId !== "string")
-      return null;
-    const headers = { authorization: `Bearer ${this.opts.authToken}` };
-    try {
-      const r = await fetch(`${this.opts.apiUrl}/api/workspaces/${this.opts.workspaceId}/agents/${agentId}`, { headers });
-      if (!r.ok)
-        return null;
-      const body = await r.json();
-      return body.runtime || body.type || null;
-    } catch {
+}
+async function resolveAgentRuntime(apiUrl, workspaceId, authToken2, chat2, agentId) {
+  if (chat2.runtime)
+    return chat2.runtime;
+  if (!agentId || typeof agentId !== "string")
+    return null;
+  const headers = { authorization: `Bearer ${authToken2}` };
+  try {
+    const r = await fetch(`${apiUrl}/api/workspaces/${workspaceId}/agents/${agentId}`, { headers });
+    if (!r.ok)
       return null;
-    }
+    const body = await r.json();
+    return body.runtime || body.type || null;
+  } catch {
+    return null;
   }
-  async fetchAgents() {
-    const headers = { authorization: `Bearer ${this.opts.authToken}` };
-    try {
-      const r = await fetch(`${this.opts.apiUrl}/api/workspaces/${this.opts.workspaceId}/agents`, { headers });
-      if (!r.ok)
-        return [];
-      const body = await r.json();
-      const arr = Array.isArray(body) ? body : Array.isArray(body.results) ? body.results : [];
-      return arr.map((a) => ({ id: a.id, name: a.name }));
-    } catch {
-      return [];
+}
+async function processUserMessage(chat2, userMsg, peer, ctx) {
+  const { apiUrl, authToken: authToken2, workspaceId, log: log4 } = ctx;
+  log4(`[chat ${chat2.id}] user: ${userMsg.text.slice(0, 80)}`);
+  const allAgents = await fetchAgents(apiUrl, workspaceId, authToken2);
+  const mentioned = userMsg.mentions?.[0];
+  const mentionAgent = resolveAgentFromMention(allAgents, mentioned);
+  const resolvedAgentId = mentionAgent?.id ?? chat2.primary_agent_id ?? null;
+  const agentAuthorId = resolvedAgentId || mentioned || "agent";
+  const runtime4 = await resolveAgentRuntime(apiUrl, workspaceId, authToken2, chat2, resolvedAgentId);
+  const cwd = await resolveCwd(apiUrl, workspaceId, authToken2, chat2);
+  if (cwd)
+    log4(`[chat ${chat2.id}] cwd=${cwd}`);
+  if (mentionAgent)
+    log4(`[chat ${chat2.id}] mention → ${mentionAgent.name}`);
+  let textContainerId = null;
+  let buffered = "";
+  let lastFlush = Date.now();
+  let agentReplyText = "";
+  const toolMsgByCallId = new Map;
+  const flushText = (force = false) => {
+    const now = Date.now();
+    if (!buffered || textContainerId == null)
+      return;
+    if (force || now - lastFlush > 200) {
+      peer.appendPartialText(textContainerId, buffered);
+      buffered = "";
+      lastFlush = now;
     }
-  }
-  resolveAgentFromMention(agents, mentioned) {
-    if (!mentioned)
-      return null;
-    const m = mentioned.toLowerCase();
-    return agents.find((a) => a.name?.toLowerCase() === m || a.id === mentioned) ?? null;
-  }
-  async onUserMessage(chat2, userMsg, peer) {
-    this.opts.log(`[chat ${chat2.id}] user: ${userMsg.text.slice(0, 80)}`);
-    const allAgents = await this.fetchAgents();
-    const mentioned = userMsg.mentions?.[0];
-    const mentionAgent = this.resolveAgentFromMention(allAgents, mentioned);
-    const resolvedAgentId = mentionAgent?.id ?? chat2.primary_agent_id ?? null;
-    const agentAuthorId = resolvedAgentId || mentioned || "agent";
-    const runtime4 = await this.resolveAgentRuntime(chat2, resolvedAgentId);
-    const cwd = await this.resolveCwd(chat2);
-    if (cwd)
-      this.opts.log(`[chat ${chat2.id}] cwd=${cwd}`);
-    if (mentionAgent)
-      this.opts.log(`[chat ${chat2.id}] mention → ${mentionAgent.name}`);
-    let textContainerId = null;
-    let buffered = "";
-    let lastFlush = Date.now();
-    let agentReplyText = "";
-    const toolMsgByCallId = new Map;
-    const flushText = (force = false) => {
-      const now = Date.now();
-      if (!buffered || textContainerId == null)
-        return;
-      if (force || now - lastFlush > 200) {
-        peer.appendPartialText(textContainerId, buffered);
-        buffered = "";
-        lastFlush = now;
-      }
-    };
-    const closeText = () => {
-      if (textContainerId == null)
-        return;
-      flushText(true);
-      peer.finalizePartialMessage(textContainerId);
-      textContainerId = null;
-    };
-    const agentDisplayName = mentionAgent?.name ?? allAgents.find((a) => a.id === resolvedAgentId)?.name ?? runtime4 ?? undefined;
-    const ensureTextOpen = () => {
-      if (textContainerId == null) {
-        textContainerId = peer.beginPartialAgentMessage(agentAuthorId, agentDisplayName).containerId;
-      }
-    };
-    const summarizeInput = (raw) => {
-      if (!raw || typeof raw !== "object")
-        return;
-      const r = raw;
-      const out = {};
-      if (typeof r.file_path === "string")
-        out.file_path = r.file_path;
-      if (typeof r.path === "string")
-        out.path = r.path;
-      if (typeof r.filename === "string")
-        out.filename = r.filename;
-      if (typeof r.command === "string")
-        out.command = String(r.command).slice(0, 400);
-      if (typeof r.pattern === "string")
-        out.pattern = String(r.pattern).slice(0, 200);
-      if (typeof r.query === "string")
-        out.query = String(r.query).slice(0, 200);
-      if (typeof r.url === "string")
-        out.url = r.url;
-      return Object.keys(out).length ? out : undefined;
-    };
-    const summarizeContent = (raw) => {
-      const bytes = raw?.length ?? 0;
-      const lines = raw ? raw.split(`
+  };
+  const closeText = () => {
+    if (textContainerId == null)
+      return;
+    flushText(true);
+    peer.finalizePartialMessage(textContainerId);
+    textContainerId = null;
+  };
+  const agentDisplayName = mentionAgent?.name ?? allAgents.find((a) => a.id === resolvedAgentId)?.name ?? runtime4 ?? undefined;
+  const ensureTextOpen = () => {
+    if (textContainerId == null) {
+      textContainerId = peer.beginPartialAgentMessage(agentAuthorId, agentDisplayName).containerId;
+    }
+  };
+  const summarizeInput = (raw) => {
+    if (!raw || typeof raw !== "object")
+      return;
+    const r = raw;
+    const out = {};
+    if (typeof r.file_path === "string")
+      out.file_path = r.file_path;
+    if (typeof r.path === "string")
+      out.path = r.path;
+    if (typeof r.filename === "string")
+      out.filename = r.filename;
+    if (typeof r.command === "string")
+      out.command = String(r.command).slice(0, 400);
+    if (typeof r.pattern === "string")
+      out.pattern = String(r.pattern).slice(0, 200);
+    if (typeof r.query === "string")
+      out.query = String(r.query).slice(0, 200);
+    if (typeof r.url === "string")
+      out.url = r.url;
+    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 };
-    };
-    const mapToolKind = (raw) => {
-      const s = (raw || "").toLowerCase();
-      if (s.includes("edit") || s.includes("modify"))
-        return "edit";
-      if (s.includes("read") || s.includes("view") || s.includes("fetch"))
-        return "read";
-      if (s.includes("write") || s.includes("create"))
-        return "write";
-      if (s.includes("execute") || s.includes("bash") || s.includes("shell") || s.includes("run"))
-        return "bash";
-      if (s.includes("search") || s.includes("grep") || s.includes("find"))
-        return "search";
-      return "other";
-    };
-    const preamble = buildChatPreamble({
-      projectId: chat2.project_id,
-      agents: allAgents
-    });
-    await new Promise((resolve2) => {
-      handleChatTurn({
-        chatId: chat2.id,
-        prompt: userMsg.text,
-        preferredRuntime: runtime4,
-        cwd,
-        systemPreamble: preamble,
-        log: this.opts.log,
-        onChunk: (text) => {
-          ensureTextOpen();
-          buffered += text;
-          agentReplyText += text;
-          flushText();
-        },
-        onToolCall: (ev) => {
-          closeText();
-          const partial2 = ev.status !== "completed" && ev.status !== "failed";
-          const status3 = ev.status || "in_progress";
-          if (ev.id) {
-            const existing = toolMsgByCallId.get(ev.id);
-            if (existing) {
-              peer.patchMessage(existing, {
-                partial: partial2,
-                status: status3,
-                tool: ev.tool,
-                tool_kind: mapToolKind(ev.kind),
-                input: summarizeInput(ev.input)
-              });
-              return;
-            }
-          }
-          const id3 = `tc_${ev.id || Math.random().toString(36).slice(2)}`;
-          const containerId = peer.appendStructured({
-            id: id3,
-            author: { kind: "agent", id: agentAuthorId, name: agentDisplayName },
-            kind: "tool_call",
-            text: "",
-            ts: Math.floor(Date.now() / 1000),
-            mentions: [],
-            attachments: [],
-            partial: partial2,
-            tool: ev.tool,
-            tool_kind: mapToolKind(ev.kind),
-            status: status3,
-            input: summarizeInput(ev.input),
-            tool_call_id: ev.id
-          });
-          if (ev.id)
-            toolMsgByCallId.set(ev.id, containerId);
-        },
-        onToolResult: (ev) => {
-          closeText();
-          const summary5 = summarizeContent(ev.content);
-          peer.appendStructured({
-            id: `tr_${ev.tool_call_id || Math.random().toString(36).slice(2)}_${Date.now()}`,
-            author: { kind: "agent", id: agentAuthorId, name: agentDisplayName },
-            kind: "tool_result",
-            text: `${summary5.lines} lines · ${summary5.bytes} bytes`,
-            ts: Math.floor(Date.now() / 1000),
-            mentions: [],
-            attachments: [],
-            partial: false,
-            tool_call_id: ev.tool_call_id,
-            content: summary5.content
-          });
-          const cid = ev.tool_call_id ? toolMsgByCallId.get(ev.tool_call_id) : undefined;
-          if (cid)
-            peer.patchMessage(cid, { partial: false, status: "completed" });
-        },
-        onDone: (stopReason) => {
-          closeText();
-          for (const cid of toolMsgByCallId.values()) {
-            peer.patchMessage(cid, { partial: false, status: "completed" });
+    const trimmed = raw && raw.length > 240 ? raw.slice(0, 240) + "…" : raw || "";
+    return { content: trimmed, bytes, lines };
+  };
+  const mapToolKind = (raw) => {
+    const s = (raw || "").toLowerCase();
+    if (s.includes("edit") || s.includes("modify"))
+      return "edit";
+    if (s.includes("read") || s.includes("view") || s.includes("fetch"))
+      return "read";
+    if (s.includes("write") || s.includes("create"))
+      return "write";
+    if (s.includes("execute") || s.includes("bash") || s.includes("shell") || s.includes("run"))
+      return "bash";
+    if (s.includes("search") || s.includes("grep") || s.includes("find"))
+      return "search";
+    return "other";
+  };
+  const preamble = buildChatPreamble({ projectId: chat2.project_id, agents: allAgents });
+  await new Promise((resolve2) => {
+    handleChatTurn({
+      chatId: chat2.id,
+      prompt: userMsg.text,
+      preferredRuntime: runtime4,
+      cwd,
+      systemPreamble: preamble,
+      log: log4,
+      onChunk: (text) => {
+        ensureTextOpen();
+        buffered += text;
+        agentReplyText += text;
+        flushText();
+      },
+      onToolCall: (ev) => {
+        closeText();
+        const partial2 = ev.status !== "completed" && ev.status !== "failed";
+        const status3 = ev.status || "in_progress";
+        if (ev.id) {
+          const existing = toolMsgByCallId.get(ev.id);
+          if (existing) {
+            peer.patchMessage(existing, {
+              partial: partial2,
+              status: status3,
+              tool: ev.tool,
+              tool_kind: mapToolKind(ev.kind),
+              input: summarizeInput(ev.input)
+            });
+            return;
           }
-          this.opts.log(`[chat ${chat2.id}] done: ${stopReason}`);
-          resolve2();
         }
-      });
-    });
-    try {
-      const { actions, errors: errors3 } = parsePlanBlocks(agentReplyText);
-      if (actions.length || errors3.length) {
-        const res = await executeChatPlanActions(actions, errors3, {
-          apiUrl: this.opts.apiUrl,
-          wsId: this.opts.workspaceId,
-          chatId: chat2.id,
-          projectId: chat2.project_id,
-          agentId: resolvedAgentId,
-          log: this.opts.log
+        const id3 = `tc_${ev.id || Math.random().toString(36).slice(2)}`;
+        const containerId = peer.appendStructured({
+          id: id3,
+          author: { kind: "agent", id: agentAuthorId, name: agentDisplayName },
+          kind: "tool_call",
+          text: "",
+          ts: Math.floor(Date.now() / 1000),
+          mentions: [],
+          attachments: [],
+          partial: partial2,
+          tool: ev.tool,
+          tool_kind: mapToolKind(ev.kind),
+          status: status3,
+          input: summarizeInput(ev.input),
+          tool_call_id: ev.id
         });
-        const summary5 = renderChatPlanSummary(res);
-        if (summary5) {
-          peer.appendStructured({
-            id: `sys_plan_${Date.now()}`,
-            author: { kind: "system", id: "multi-plan", name: "multi" },
-            kind: "text",
-            text: summary5,
-            ts: Math.floor(Date.now() / 1000),
-            mentions: [],
-            attachments: [],
-            partial: false
-          });
+        if (ev.id)
+          toolMsgByCallId.set(ev.id, containerId);
+      },
+      onToolResult: (ev) => {
+        closeText();
+        const summary5 = summarizeContent(ev.content);
+        peer.appendStructured({
+          id: `tr_${ev.tool_call_id || Math.random().toString(36).slice(2)}_${Date.now()}`,
+          author: { kind: "agent", id: agentAuthorId, name: agentDisplayName },
+          kind: "tool_result",
+          text: `${summary5.lines} lines · ${summary5.bytes} bytes`,
+          ts: Math.floor(Date.now() / 1000),
+          mentions: [],
+          attachments: [],
+          partial: false,
+          tool_call_id: ev.tool_call_id,
+          content: summary5.content
+        });
+        const cid = ev.tool_call_id ? toolMsgByCallId.get(ev.tool_call_id) : undefined;
+        if (cid)
+          peer.patchMessage(cid, { partial: false, status: "completed" });
+      },
+      onDone: (stopReason) => {
+        closeText();
+        for (const cid of toolMsgByCallId.values()) {
+          peer.patchMessage(cid, { partial: false, status: "completed" });
         }
-        this.opts.log(`[chat ${chat2.id}] plan exec: ${res.ok} ok, ${res.fail} fail, ${errors3.length} parse-err`);
+        log4(`[chat ${chat2.id}] done: ${stopReason}`);
+        resolve2();
       }
-      const ui = parseUiBlocks(agentReplyText);
-      if (ui.blocks.length)
-        this.opts.log(`[chat ${chat2.id}] ui blocks: ${ui.blocks.length}`);
-      if (ui.errors.length)
-        this.opts.log(`[chat ${chat2.id}] ui parse err: ${ui.errors.length}`);
-    } catch (e) {
-      this.opts.log(`[chat ${chat2.id}] post-turn err: ${e.message}`);
-    }
-    if (/^new chat$/i.test(chat2.title) && agentReplyText.trim()) {
-      this.autoTitle(chat2, userMsg.text, agentReplyText).catch((e) => this.opts.log(`[chat ${chat2.id}] auto-title failed: ${e.message}`));
+    });
+  });
+  try {
+    const { actions, errors: errors3 } = parsePlanBlocks(agentReplyText);
+    if (actions.length || errors3.length) {
+      const res = await executeChatPlanActions(actions, errors3, {
+        apiUrl,
+        wsId: workspaceId,
+        chatId: chat2.id,
+        projectId: chat2.project_id,
+        agentId: resolvedAgentId,
+        log: log4
+      });
+      const summary5 = renderChatPlanSummary(res);
+      if (summary5) {
+        peer.appendStructured({
+          id: `sys_plan_${Date.now()}`,
+          author: { kind: "system", id: "multi-plan", name: "multi" },
+          kind: "text",
+          text: summary5,
+          ts: Math.floor(Date.now() / 1000),
+          mentions: [],
+          attachments: [],
+          partial: false
+        });
+      }
+      log4(`[chat ${chat2.id}] plan exec: ${res.ok} ok, ${res.fail} fail, ${errors3.length} parse-err`);
     }
+    const ui = parseUiBlocks(agentReplyText);
+    if (ui.blocks.length)
+      log4(`[chat ${chat2.id}] ui blocks: ${ui.blocks.length}`);
+    if (ui.errors.length)
+      log4(`[chat ${chat2.id}] ui parse err: ${ui.errors.length}`);
+  } catch (e) {
+    log4(`[chat ${chat2.id}] post-turn err: ${e.message}`);
   }
-  async autoTitle(chat2, userMsg, agentReply) {
-    const runtime4 = await this.resolveAgentRuntime(chat2, chat2.primary_agent_id);
-    const trimUser = userMsg.slice(0, 800);
-    const trimAgent = agentReply.slice(0, 1200);
-    const prompt = `Reply with ONLY a 3-6 word title for this conversation. No quotes, no punctuation, no explanation. Capitalize each word.
+  if (/^new chat$/i.test(chat2.title) && agentReplyText.trim()) {
+    autoTitle(chat2, userMsg.text, agentReplyText, ctx).catch((e) => log4(`[chat ${chat2.id}] auto-title failed: ${e.message}`));
+  }
+}
+async function autoTitle(chat2, userMsg, agentReply, ctx) {
+  const { apiUrl, authToken: authToken2, workspaceId, log: log4 } = ctx;
+  const runtime4 = await resolveAgentRuntime(apiUrl, workspaceId, authToken2, chat2, chat2.primary_agent_id);
+  const trimUser = userMsg.slice(0, 800);
+  const trimAgent = agentReply.slice(0, 1200);
+  const prompt = `Reply with ONLY a 3-6 word title for this conversation. No quotes, no punctuation, no explanation. Capitalize each word.
 
 ` + `User: ${trimUser}
 
 Assistant: ${trimAgent}`;
-    let collected = "";
-    await new Promise((resolve2) => {
-      handleChatTurn({
-        chatId: `${chat2.id}__title`,
-        prompt,
-        preferredRuntime: runtime4,
-        log: this.opts.log,
-        onChunk: (t) => {
-          collected += t;
-        },
-        onDone: () => resolve2()
-      });
+  let collected = "";
+  await new Promise((resolve2) => {
+    handleChatTurn({
+      chatId: `${chat2.id}__title`,
+      prompt,
+      preferredRuntime: runtime4,
+      log: log4,
+      onChunk: (t) => {
+        collected += t;
+      },
+      onDone: () => resolve2()
     });
-    const cleaned = collected.split(`
+  });
+  const cleaned = collected.split(`
 `).map((s) => s.trim()).filter(Boolean)[0] ?? "";
-    const stripped = cleaned.replace(/^["'`*_#-]+|["'`*_#-]+$/g, "").trim();
-    const final = stripped.split(/\s+/).slice(0, 8).join(" ").slice(0, 60);
-    if (!final || /^new chat$/i.test(final))
-      return;
-    try {
-      const r = await fetch(`${this.opts.apiUrl}/api/workspaces/${this.opts.workspaceId}/chats/${chat2.id}`, {
-        method: "PATCH",
-        headers: {
-          authorization: `Bearer ${this.opts.authToken}`,
-          "content-type": "application/json"
-        },
-        body: JSON.stringify({ title: final })
-      });
-      if (r.ok)
-        this.opts.log(`[chat ${chat2.id}] auto-titled: ${final}`);
-    } catch {}
-  }
+  const stripped = cleaned.replace(/^["'`*_#-]+|["'`*_#-]+$/g, "").trim();
+  const final = stripped.split(/\s+/).slice(0, 8).join(" ").slice(0, 60);
+  if (!final || /^new chat$/i.test(final))
+    return;
+  try {
+    const r = await fetch(`${apiUrl}/api/workspaces/${workspaceId}/chats/${chat2.id}`, {
+      method: "PATCH",
+      headers: { authorization: `Bearer ${authToken2}`, "content-type": "application/json" },
+      body: JSON.stringify({ title: final })
+    });
+    if (r.ok)
+      log4(`[chat ${chat2.id}] auto-titled: ${final}`);
+  } catch {}
 }
 function buildChatPreamble(args2) {
   const projectLine = args2.projectId ? `Default project: ${args2.projectId} (issue.create / issue.list use it when project_id is omitted).` : `No default project pinned to this chat. issue.create requires explicit project_id; otherwise the host returns [err] and skips.`;
@@ -36733,7 +36895,7 @@ 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":"agent.create","name":"refactor-bot","agent_type":"claude-code","prompt":"...","allowed_tools":["Read","Edit","Bash"]},
+  {"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..."},
   {"type":"skill.attach","agent_id":"ag_xxx","skill_id":"sk_yyy"},
@@ -37334,7 +37496,7 @@ import { parseArgs } from "util";
 // package.json
 var package_default = {
   name: "@shipers-dev/multi",
-  version: "0.39.2",
+  version: "0.43.0",
   type: "module",
   bin: {
     "multi-agent": "./dist/index.js"
@@ -37619,8 +37781,8 @@ init_errors();
 
 class Worktree extends exports_Effect.Service()("cli/Worktree", {
   succeed: {
-    ensure: (workingDir, issueKey, issueId) => exports_Effect.tryPromise({
-      try: () => ensureWorktree(workingDir, issueKey, issueId),
+    ensure: (workingDir, issueKey, issueId, opts) => exports_Effect.tryPromise({
+      try: () => ensureWorktree(workingDir, issueKey, issueId, opts),
       catch: (cause3) => new WorktreeError({ message: `ensureWorktree failed`, cause: cause3 })
     }),
     isGitRepo: (dir) => exports_Effect.tryPromise({
@@ -38346,8 +38508,8 @@ init_errors();
 
 class Worktree2 extends exports_Effect.Service()("cli/Worktree", {
   succeed: {
-    ensure: (workingDir, issueKey, issueId) => exports_Effect.tryPromise({
-      try: () => ensureWorktree(workingDir, issueKey, issueId),
+    ensure: (workingDir, issueKey, issueId, opts) => exports_Effect.tryPromise({
+      try: () => ensureWorktree(workingDir, issueKey, issueId, opts),
       catch: (cause3) => new WorktreeError({ message: `ensureWorktree failed`, cause: cause3 })
     }),
     isGitRepo: (dir) => exports_Effect.tryPromise({
@@ -38765,6 +38927,34 @@ var daemonProgram = ({ cfg, apiUrl }) => exports_Effect.gen(function* () {
           }
         })();
       }
+      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 { runChatTurn: runChatTurn2 } = await Promise.resolve().then(() => (init_chat_supervisor(), exports_chat_supervisor));
+            runChatTurn2({
+              apiUrl,
+              authToken: cfg.authToken,
+              workspaceId: cfg.workspaceId,
+              deviceId: cfg.deviceId,
+              chatId: body.chat_id,
+              messageId: body.message_id,
+              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 === "/stop" && req.method === "POST") {
         if (req.headers.get("authorization") !== expectedAuth)
           return new Response("unauthorized", { status: 401 });
@@ -38826,19 +39016,6 @@ var daemonProgram = ({ cfg, apiUrl }) => exports_Effect.gen(function* () {
     catch: () => new DaemonError({ message: "materializeBundle skipped" })
   }).pipe(exports_Effect.catchAll(() => exports_Effect.void));
   const schedFiber = yield* exports_Effect.forkIn(daemonScope)(schedulerLoop(state, daemonScope));
-  let chatSup = null;
-  if (cfg.workspaceId && cfg.authToken && cfg.deviceId) {
-    const { ChatSupervisor: ChatSupervisor2 } = yield* exports_Effect.promise(() => Promise.resolve().then(() => (init_chat_supervisor(), exports_chat_supervisor)));
-    chatSup = new ChatSupervisor2({
-      apiUrl,
-      authToken: cfg.authToken,
-      workspaceId: cfg.workspaceId,
-      deviceId: cfg.deviceId,
-      log: log3
-    });
-    chatSup.start();
-    log3(`Chat supervisor started (device=${cfg.deviceId})`);
-  }
   if (cfg.workspaceId) {
     yield* exports_Effect.forkIn(daemonScope)(exports_Effect.tryPromise({
       try: () => drainOfflineDispatches(apiUrl, cfg.deviceId, cfg.workspaceId, cfg.dispatchSecret, db2, () => {
@@ -38928,9 +39105,6 @@ var daemonProgram = ({ cfg, apiUrl }) => exports_Effect.gen(function* () {
   try {
     server.stop();
   } catch {}
-  try {
-    chatSup?.close();
-  } catch {}
   try {
     tunnel?.child?.kill();
   } catch {}