@shipers-dev/multi 0.5.0 → 0.6.0

package/dist/index.js

@@ -5198,6 +5198,7 @@ async function runAcp(opts) {
   const stream2 = ndJsonStream(output, input);
   let activeSessionId = opts.sessionId || null;
   let recording = false;
+  const alwaysAllow = new Set;
   const client = {
     async sessionUpdate(params) {
       if (!recording)
@@ -5205,7 +5206,7 @@ async function runAcp(opts) {
       await handleSessionUpdate(params, opts);
     },
     async requestPermission(params) {
-      return await handleRequestPermission(params, opts);
+      return await handleRequestPermission(params, opts, alwaysAllow);
     },
     async readTextFile(params) {
       try {
@@ -5325,8 +5326,14 @@ ${entries}` } });
         break;
     }
   }
-  async function handleRequestPermission(params, o) {
+  async function handleRequestPermission(params, o, allowCache) {
     const tc = params.toolCall || {};
+    const toolKey = `${tc.toolName || tc.title || ""}|${tc.kind || ""}`.toLowerCase();
+    if (toolKey && allowCache.has(toolKey)) {
+      const allowOpt = params.options.find((op) => /allow/i.test(op.kind || "") || /allow/i.test(op.name || ""));
+      if (allowOpt)
+        return { outcome: { outcome: "selected", optionId: allowOpt.optionId } };
+    }
     const created = await apiClient.post(`${o.apiUrl}/api/permissions`, {
       issue_id: o.issueId,
       device_id: o.deviceId,
@@ -5346,6 +5353,10 @@ ${entries}` } });
       if (!row)
         break;
       if (row.status === "resolved" && row.chosen) {
+        const chosenOpt = params.options.find((op) => op.optionId === row.chosen);
+        const isAlways = chosenOpt && (/always/i.test(chosenOpt.name || "") || /allow_always/i.test(chosenOpt.kind || ""));
+        if (isAlways && toolKey)
+          allowCache.add(toolKey);
         return { outcome: { outcome: "selected", optionId: row.chosen } };
       }
       if (row.status === "cancelled") {
@@ -5369,6 +5380,145 @@ function extractText(content) {
   return "";
 }
 
+// src/acpx-runner.ts
+async function runAcpx(opts) {
+  const args = ["acpx", "--format", "json", "--json-strict", "--approve-all"];
+  if (opts.cwd)
+    args.push("--cwd", opts.cwd);
+  args.push(opts.agentType);
+  if (opts.sessionName) {
+    const ensureArgs = ["acpx", ...opts.cwd ? ["--cwd", opts.cwd] : [], opts.agentType, "sessions", "ensure", "--name", opts.sessionName];
+    try {
+      const ensure = Bun.spawn(ensureArgs, { stdout: "pipe", stderr: "pipe", stdin: "ignore" });
+      await ensure.exited;
+    } catch {}
+    args.push("prompt", "-s", opts.sessionName);
+  } else {
+    args.push("prompt");
+  }
+  args.push(opts.prompt);
+  const proc = Bun.spawn(args, { stdout: "pipe", stderr: "pipe", stdin: "ignore" });
+  let stopReason = "end_turn";
+  const reader = proc.stdout.getReader();
+  const dec = new TextDecoder;
+  let buf = "";
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done)
+      break;
+    buf += dec.decode(value, { stream: true });
+    let nl;
+    while ((nl = buf.indexOf(`
+`)) !== -1) {
+      const line = buf.slice(0, nl).trim();
+      buf = buf.slice(nl + 1);
+      if (!line)
+        continue;
+      const events = parseAcpLine(line, (r) => {
+        stopReason = r;
+      });
+      for (const ev of events)
+        await opts.onEvent(ev);
+    }
+  }
+  if (buf.trim()) {
+    const events = parseAcpLine(buf.trim(), (r) => {
+      stopReason = r;
+    });
+    for (const ev of events)
+      await opts.onEvent(ev);
+  }
+  const code = await proc.exited;
+  if (code !== 0 && code !== 130) {
+    await opts.onEvent({ event_type: "error", payload: { message: `acpx exited with code ${code}` } });
+  }
+  return { stopReason };
+}
+function parseAcpLine(line, setStop) {
+  let msg;
+  try {
+    msg = JSON.parse(line);
+  } catch {
+    return [];
+  }
+  const out = [];
+  if (msg.method === "session/update" && msg.params?.sessionUpdate) {
+    return handleSessionUpdate(msg.params);
+  }
+  if (msg.id && msg.result && typeof msg.result === "object" && "stopReason" in msg.result) {
+    setStop(msg.result.stopReason);
+    out.push({ event_type: "result", payload: { stopReason: msg.result.stopReason } });
+    return out;
+  }
+  if (msg.error) {
+    out.push({ event_type: "error", payload: { message: msg.error.message || JSON.stringify(msg.error) } });
+    return out;
+  }
+  return out;
+}
+function handleSessionUpdate(params) {
+  const u = params.update || {};
+  const kind = u.sessionUpdate;
+  const out = [];
+  switch (kind) {
+    case "agent_message_chunk":
+    case "agent_thought_chunk": {
+      const text = extractText2(u.content);
+      if (text)
+        out.push({ event_type: "assistant_text", payload: { text } });
+      break;
+    }
+    case "tool_call":
+    case "tool_call_update": {
+      out.push({ event_type: "tool_call", payload: {
+        id: u.toolCallId || u.id,
+        tool: u.title || u.toolName || "tool",
+        kind: u.kind,
+        status: u.status,
+        input: u.rawInput,
+        locations: u.locations
+      } });
+      if (Array.isArray(u.content)) {
+        for (const c of u.content) {
+          if (c.type === "content" && c.content?.type === "text") {
+            out.push({ event_type: "tool_result", payload: { tool_use_id: u.toolCallId || u.id, content: String(c.content.text).slice(0, 4000) } });
+          } else if (c.type === "diff") {
+            const diff = `--- ${c.path}
+${c.oldText || ""}
++++ ${c.path}
+${c.newText || ""}`.slice(0, 4000);
+            out.push({ event_type: "tool_result", payload: { tool_use_id: u.toolCallId || u.id, content: diff } });
+          }
+        }
+      }
+      break;
+    }
+    case "plan": {
+      const entries = (u.entries || []).map((e, i) => `${i + 1}. [${e.status || "pending"}] ${e.content}`).join(`
+`);
+      if (entries)
+        out.push({ event_type: "assistant_text", payload: { text: `**Plan**
+
+${entries}` } });
+      break;
+    }
+  }
+  return out;
+}
+function extractText2(content) {
+  if (!content)
+    return "";
+  if (typeof content === "string")
+    return content;
+  if (Array.isArray(content))
+    return content.map(extractText2).join("");
+  if (content.type === "text" && typeof content.text === "string")
+    return content.text;
+  if (content.text)
+    return content.text;
+  return "";
+}
+
 // src/index.ts
 import { parseArgs } from "util";
 import { mkdirSync as mkdirSync2, existsSync as existsSync2, writeFileSync as writeFileSync2, readFileSync as readFileSync2, appendFileSync, unlinkSync, readdirSync, statSync } from "fs";
@@ -5381,7 +5531,7 @@ var LOG_PATH = join(MULTI_DIR, "logs", "agent.log");
 var SKILLS_DIR = join(MULTI_DIR, "skills");
 var STOP_PATH = join(MULTI_DIR, "stop.flag");
 var TASKS_DB_PATH = join(MULTI_DIR, "tasks.db");
-var VERSION = "0.5.0";
+var VERSION = "0.6.0";
 var COMMANDS = {
   setup: "Register this device with a workspace",
   connect: "Connect device to realtime hub and execute assigned tasks",
@@ -5833,29 +5983,71 @@ async function handleRunTask(apiUrl, deviceId, task, detected) {
     } catch {}
   };
   const turn = {
-    text: "",
-    toolOrder: [],
+    blocks: [],
     tools: new Map,
     plans: [],
     progress: [],
     result: null,
     error: null
   };
+  const appendText = (text) => {
+    const last = turn.blocks[turn.blocks.length - 1];
+    if (last && last.kind === "text")
+      last.text += text;
+    else
+      turn.blocks.push({ kind: "text", text });
+  };
+  const upsertTool = (id, patch) => {
+    const existing = turn.tools.get(id);
+    if (existing) {
+      if (patch.tool && patch.tool !== "tool")
+        existing.tool = patch.tool;
+      if (patch.kind)
+        existing.kind = patch.kind;
+      if (patch.status)
+        existing.status = patch.status;
+      if (patch.input !== undefined)
+        existing.input = patch.input;
+    } else {
+      turn.tools.set(id, { id, tool: patch.tool || "tool", kind: patch.kind, status: patch.status, input: patch.input, results: [] });
+      turn.blocks.push({ kind: "tool", id });
+    }
+  };
+  const toolLabel = (t) => {
+    const clean = stripMd(t.tool);
+    if (clean && clean !== "tool")
+      return clean;
+    if (t.input && typeof t.input === "object") {
+      if (t.input.command)
+        return `Bash: ${String(t.input.command).split(`
+`)[0].slice(0, 60)}`;
+      if (t.input.file_path)
+        return `${t.kind === "edit" ? "Edit" : "Read"}: ${t.input.file_path}`;
+      if (t.input.pattern)
+        return `Grep: ${t.input.pattern}`;
+      if (t.input.url)
+        return `Fetch: ${t.input.url}`;
+    }
+    return t.kind ? `${t.kind}` : "tool";
+  };
   const render = () => {
     const parts = [];
-    if (turn.text)
-      parts.push(turn.text);
-    for (const id of turn.toolOrder) {
-      const t = turn.tools.get(id);
+    for (const b of turn.blocks) {
+      if (b.kind === "text") {
+        if (b.text)
+          parts.push(b.text);
+        continue;
+      }
+      const t = turn.tools.get(b.id);
       if (!t)
         continue;
       const icon = statusIcon(t.status);
-      const cleanTool = stripMd(t.tool);
-      const head = `${icon} ${cleanTool}${t.kind ? ` \xB7 ${t.kind}` : ""}${t.status && t.status !== "completed" ? ` \xB7 ${t.status}` : ""}`;
+      const label = toolLabel(t);
+      const head = `${icon} ${label}${t.status && t.status !== "completed" ? ` \xB7 ${t.status}` : ""}`;
       const body = [];
       if (t.input !== undefined && t.input !== null) {
         const inputStr = typeof t.input === "object" ? JSON.stringify(t.input, null, 2) : String(t.input);
-        body.push("```json\n" + inputStr + "\n```");
+        body.push("```json\n" + inputStr.slice(0, 2000) + "\n```");
       }
       if (t.results.length) {
         const joined = t.results.join(`
@@ -5917,7 +6109,7 @@ _${bits.join(" \xB7 ")}_`);
       }
       case "assistant_text": {
         await ensureLiveComment();
-        turn.text += p.text;
+        appendText(p.text);
         hasAssistantText = true;
         schedulePatch();
         break;
@@ -5925,8 +6117,8 @@ _${bits.join(" \xB7 ")}_`);
       case "stdout": {
         if (p.line) {
           await ensureLiveComment();
-          turn.text += (turn.text ? `
-` : "") + p.line;
+          appendText((turn.blocks.length ? `
+` : "") + p.line);
           hasAssistantText = true;
           schedulePatch();
         }
@@ -5934,36 +6126,24 @@ _${bits.join(" \xB7 ")}_`);
       }
       case "tool_call": {
         await ensureLiveComment();
-        const id = p.id || `anon-${turn.toolOrder.length}`;
-        const existing = turn.tools.get(id);
-        if (existing) {
-          if (p.tool)
-            existing.tool = p.tool;
-          if (p.kind)
-            existing.kind = p.kind;
-          if (p.status)
-            existing.status = p.status;
-          if (p.input !== undefined)
-            existing.input = p.input;
-        } else {
-          turn.toolOrder.push(id);
-          turn.tools.set(id, { id, tool: p.tool || "tool", kind: p.kind, status: p.status, input: p.input, results: [] });
-        }
+        const id = p.id || `anon-${turn.tools.size}`;
+        upsertTool(id, { tool: p.tool, kind: p.kind, status: p.status, input: p.input });
         schedulePatch();
         break;
       }
       case "tool_result": {
         await ensureLiveComment();
-        const id = p.tool_use_id || turn.toolOrder[turn.toolOrder.length - 1];
+        const lastToolId = [...turn.blocks].reverse().find((b) => b.kind === "tool")?.id;
+        const id = p.tool_use_id || lastToolId;
         const entry = id ? turn.tools.get(id) : undefined;
         const content = String(p.content ?? "").trim();
         if (entry && content) {
           entry.results.push(content);
           schedulePatch();
         } else if (content) {
-          const pid = `result-${turn.toolOrder.length}`;
-          turn.toolOrder.push(pid);
-          turn.tools.set(pid, { id: pid, tool: "tool result", results: [content] });
+          const pid = `result-${turn.tools.size}`;
+          upsertTool(pid, { tool: "tool result" });
+          turn.tools.get(pid).results.push(content);
           schedulePatch();
         }
         break;
@@ -5973,7 +6153,7 @@ _${bits.join(" \xB7 ")}_`);
         if (p.is_error)
           hadError = true;
         if (!hasAssistantText && p.result) {
-          turn.text = p.result;
+          appendText(p.result);
           hasAssistantText = true;
         }
         turn.result = { duration_ms: p.duration_ms, total_cost_usd: p.total_cost_usd, stopReason: p.stopReason, is_error: p.is_error };
@@ -5996,6 +6176,7 @@ _${bits.join(" \xB7 ")}_`);
   } catch {}
   const acpCapable = detected.filter((d) => d.type === "claude-code");
   const useAcp = preferType !== "pi" && acpCapable.length > 0 && process.env.MULTI_LEGACY !== "1";
+  const useAcpx = !useAcp && preferType && ["pi", "codex", "openclaw"].includes(preferType) && process.env.MULTI_LEGACY !== "1";
   try {
     if (useAcp) {
       const base = `${task.title}
@@ -6083,14 +6264,72 @@ ${userPart}` : userPart;
         }
       });
       log(`  acp session ${sessionId.slice(0, 8)}`);
-    } else {
-      let preferType2;
+    } else if (useAcpx) {
+      let preamble = "";
       try {
-        const a = await apiClient.get(`${apiUrl}/api/agents/${task.agent_id}`);
-        if (a.data?.type)
-          preferType2 = a.data.type;
+        const agentRes = await apiClient.get(`${apiUrl}/api/agents/${task.agent_id}`);
+        const agent = agentRes.data;
+        if (agent?.prompt)
+          preamble += `# Agent instructions
+
+${agent.prompt}
+
+`;
+        const skillsRes = await apiClient.get(`${apiUrl}/api/agents/${task.agent_id}/skills`);
+        const skillList = Array.isArray(skillsRes.data) ? skillsRes.data : [];
+        if (skillList.length) {
+          preamble += `# Attached skills (${skillList.length})
+
+`;
+          for (const s of skillList) {
+            const body = String(s.body || s.description || "").trim();
+            if (body)
+              preamble += `## ${s.name}${s.version ? ` v${s.version}` : ""}
+
+${body}
+
+`;
+          }
+        }
       } catch {}
-      const runner = pickRunner(detected, preferType2);
+      const base = `${task.title}
+
+${task.description || ""}`.trim();
+      let userPart = task.followup ? `${task.followup}
+
+---
+Context (${task.key}): ${task.title}` : base || task.title;
+      userPart = stripSelfMention(userPart, preferType);
+      if (attachmentRefs.length) {
+        const lines = attachmentRefs.map((a) => `- ${a.filename}: ${a.path}`).join(`
+`);
+        userPart += `
+
+---
+Attached files:
+${lines}
+
+Write generated files to: ${outDir}`;
+      } else {
+        userPart += `
+
+---
+Write generated files to: ${outDir}`;
+      }
+      const full = preamble ? `${preamble}
+---
+
+${userPart}` : userPart;
+      log(`  acpx runner: ${preferType}`);
+      await runAcpx({
+        agentType: preferType,
+        prompt: full,
+        cwd: workingDir,
+        sessionName: `issue-${issueId}`,
+        onEvent: eventHandler
+      });
+    } else {
+      const runner = pickRunner(detected, preferType);
       for await (const event of runner(task))
         await eventHandler(event);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shipers-dev/multi",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "type": "module",
   "bin": {
     "multi-agent": "./dist/index.js"

package/src/acp-runner.ts

@@ -54,6 +54,7 @@ export async function runAcp(opts: AcpRunOpts): Promise<{ stopReason: string; se
 
   let activeSessionId: string | null = opts.sessionId || null;
   let recording = false; // only forward events after prompt() starts
+  const alwaysAllow = new Set<string>(); // keys: toolName|kind that user said "always allow"
 
   const client: Client = {
     async sessionUpdate(params: SessionNotification): Promise<void> {
@@ -61,7 +62,7 @@ export async function runAcp(opts: AcpRunOpts): Promise<{ stopReason: string; se
       await handleSessionUpdate(params, opts);
     },
     async requestPermission(params: RequestPermissionRequest): Promise<RequestPermissionResponse> {
-      return await handleRequestPermission(params, opts);
+      return await handleRequestPermission(params, opts, alwaysAllow);
     },
     async readTextFile(params: ReadTextFileRequest): Promise<ReadTextFileResponse> {
       try {
@@ -170,8 +171,16 @@ export async function runAcp(opts: AcpRunOpts): Promise<{ stopReason: string; se
     }
   }
 
-  async function handleRequestPermission(params: RequestPermissionRequest, o: AcpRunOpts): Promise<RequestPermissionResponse> {
+  async function handleRequestPermission(params: RequestPermissionRequest, o: AcpRunOpts, allowCache: Set<string>): Promise<RequestPermissionResponse> {
     const tc: any = params.toolCall || {};
+    const toolKey = `${tc.toolName || tc.title || ''}|${tc.kind || ''}`.toLowerCase();
+
+    // Auto-approve if user previously chose "always allow" for same tool/kind
+    if (toolKey && allowCache.has(toolKey)) {
+      const allowOpt = (params.options as any[]).find(op => /allow/i.test(op.kind || '') || /allow/i.test(op.name || ''));
+      if (allowOpt) return { outcome: { outcome: 'selected', optionId: allowOpt.optionId } as any };
+    }
+
     const created = await apiClient.post<any>(`${o.apiUrl}/api/permissions`, {
       issue_id: o.issueId,
       device_id: o.deviceId,
@@ -183,7 +192,6 @@ export async function runAcp(opts: AcpRunOpts): Promise<{ stopReason: string; se
     const permId = created.data?.id;
     if (!permId) return { outcome: { outcome: 'cancelled' } as any };
 
-    // Poll every 500ms up to 5 min
     const deadline = Date.now() + 5 * 60 * 1000;
     while (Date.now() < deadline) {
       await new Promise(r => setTimeout(r, 500));
@@ -191,6 +199,10 @@ export async function runAcp(opts: AcpRunOpts): Promise<{ stopReason: string; se
       const row = got.data;
       if (!row) break;
       if (row.status === 'resolved' && row.chosen) {
+        // If the chosen option is an "always" variant, cache it
+        const chosenOpt = (params.options as any[]).find(op => op.optionId === row.chosen);
+        const isAlways = chosenOpt && (/always/i.test(chosenOpt.name || '') || /allow_always/i.test(chosenOpt.kind || ''));
+        if (isAlways && toolKey) allowCache.add(toolKey);
         return { outcome: { outcome: 'selected', optionId: row.chosen } as any };
       }
       if (row.status === 'cancelled') {

package/src/acpx-runner.ts

@@ -0,0 +1,136 @@
+// acpx-runner — delegate to `acpx` CLI for pi/codex/openclaw agents.
+// acpx emits raw ACP JSON-RPC NDJSON on stdout with --format json; we reuse the
+// same parse semantics as our direct ACP runner to produce AcpEvent stream.
+//
+// Requires: `npm install -g acpx` on device host (or npx acpx@latest).
+// Runs with --approve-all for now (no permission UI forwarding).
+
+import type { AcpEvent } from './acp-runner';
+
+export interface AcpxRunOpts {
+  agentType: 'pi' | 'codex' | 'openclaw' | 'claude' | string;
+  prompt: string;
+  cwd?: string;
+  sessionName?: string; // reuse same session across follow-ups (e.g. "issue-<id>")
+  onEvent: (ev: AcpEvent) => void | Promise<void>;
+}
+
+export async function runAcpx(opts: AcpxRunOpts): Promise<{ stopReason: string }> {
+  const args = ['acpx', '--format', 'json', '--json-strict', '--approve-all'];
+  if (opts.cwd) args.push('--cwd', opts.cwd);
+  args.push(opts.agentType);
+  // Ensure a session exists for this name (idempotent). ensure = get-or-create.
+  // We run it as a separate invocation, then prompt.
+  if (opts.sessionName) {
+    const ensureArgs = ['acpx', ...(opts.cwd ? ['--cwd', opts.cwd] : []), opts.agentType, 'sessions', 'ensure', '--name', opts.sessionName];
+    try {
+      const ensure = Bun.spawn(ensureArgs, { stdout: 'pipe', stderr: 'pipe', stdin: 'ignore' });
+      await ensure.exited;
+    } catch {}
+    args.push('prompt', '-s', opts.sessionName);
+  } else {
+    args.push('prompt');
+  }
+  args.push(opts.prompt);
+
+  const proc = Bun.spawn(args, { stdout: 'pipe', stderr: 'pipe', stdin: 'ignore' });
+  let stopReason = 'end_turn';
+
+  const reader = (proc.stdout as ReadableStream<Uint8Array>).getReader();
+  const dec = new TextDecoder();
+  let buf = '';
+
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buf += dec.decode(value, { stream: true });
+    let nl: number;
+    while ((nl = buf.indexOf('\n')) !== -1) {
+      const line = buf.slice(0, nl).trim();
+      buf = buf.slice(nl + 1);
+      if (!line) continue;
+      const events = parseAcpLine(line, (r) => { stopReason = r; });
+      for (const ev of events) await opts.onEvent(ev);
+    }
+  }
+  if (buf.trim()) {
+    const events = parseAcpLine(buf.trim(), (r) => { stopReason = r; });
+    for (const ev of events) await opts.onEvent(ev);
+  }
+
+  const code = await proc.exited;
+  if (code !== 0 && code !== 130) {
+    await opts.onEvent({ event_type: 'error', payload: { message: `acpx exited with code ${code}` } });
+  }
+  return { stopReason };
+}
+
+function parseAcpLine(line: string, setStop: (r: string) => void): AcpEvent[] {
+  let msg: any;
+  try { msg = JSON.parse(line); } catch { return []; }
+  const out: AcpEvent[] = [];
+
+  // session/update notification
+  if (msg.method === 'session/update' && msg.params?.sessionUpdate) {
+    return handleSessionUpdate(msg.params);
+  }
+  // prompt result
+  if (msg.id && msg.result && typeof msg.result === 'object' && 'stopReason' in msg.result) {
+    setStop(msg.result.stopReason);
+    out.push({ event_type: 'result', payload: { stopReason: msg.result.stopReason } });
+    return out;
+  }
+  // errors
+  if (msg.error) {
+    out.push({ event_type: 'error', payload: { message: msg.error.message || JSON.stringify(msg.error) } });
+    return out;
+  }
+  return out;
+}
+
+function handleSessionUpdate(params: any): AcpEvent[] {
+  const u = params.update || {};
+  const kind = u.sessionUpdate;
+  const out: AcpEvent[] = [];
+  switch (kind) {
+    case 'agent_message_chunk':
+    case 'agent_thought_chunk': {
+      const text = extractText(u.content);
+      if (text) out.push({ event_type: 'assistant_text', payload: { text } });
+      break;
+    }
+    case 'tool_call':
+    case 'tool_call_update': {
+      out.push({ event_type: 'tool_call', payload: {
+        id: u.toolCallId || u.id, tool: u.title || u.toolName || 'tool',
+        kind: u.kind, status: u.status, input: u.rawInput, locations: u.locations,
+      }});
+      if (Array.isArray(u.content)) {
+        for (const c of u.content) {
+          if (c.type === 'content' && c.content?.type === 'text') {
+            out.push({ event_type: 'tool_result', payload: { tool_use_id: u.toolCallId || u.id, content: String(c.content.text).slice(0, 4000) } });
+          } else if (c.type === 'diff') {
+            const diff = `--- ${c.path}\n${c.oldText || ''}\n+++ ${c.path}\n${c.newText || ''}`.slice(0, 4000);
+            out.push({ event_type: 'tool_result', payload: { tool_use_id: u.toolCallId || u.id, content: diff } });
+          }
+        }
+      }
+      break;
+    }
+    case 'plan': {
+      const entries = (u.entries || []).map((e: any, i: number) => `${i + 1}. [${e.status || 'pending'}] ${e.content}`).join('\n');
+      if (entries) out.push({ event_type: 'assistant_text', payload: { text: `**Plan**\n\n${entries}` } });
+      break;
+    }
+  }
+  return out;
+}
+
+function extractText(content: any): string {
+  if (!content) return '';
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) return content.map(extractText).join('');
+  if (content.type === 'text' && typeof content.text === 'string') return content.text;
+  if (content.text) return content.text;
+  return '';
+}

package/src/index.ts

@@ -4,6 +4,7 @@ import { detectAgents } from './detect';
 import { apiClient, setAuthToken } from './client';
 import { Database } from 'bun:sqlite';
 import { runAcp } from './acp-runner';
+import { runAcpx } from './acpx-runner';
 import { parseArgs } from 'util';
 import { mkdirSync, existsSync, writeFileSync, readFileSync, appendFileSync, unlinkSync, readdirSync, statSync } from 'fs';
 import { join, dirname } from 'path';
@@ -16,7 +17,7 @@ const LOG_PATH = join(MULTI_DIR, 'logs', 'agent.log');
 const SKILLS_DIR = join(MULTI_DIR, 'skills');
 const STOP_PATH = join(MULTI_DIR, 'stop.flag');
 const TASKS_DB_PATH = join(MULTI_DIR, 'tasks.db');
-const VERSION = '0.5.0';
+const VERSION = '0.6.0';
 
 const COMMANDS = {
   setup: 'Register this device with a workspace',
@@ -448,9 +449,9 @@ async function handleRunTask(apiUrl: string, deviceId: string, task: any, detect
   };
 
   type ToolEntry = { id: string; tool: string; kind?: string; status?: string; input?: any; results: string[] };
+  type Block = { kind: 'text'; text: string } | { kind: 'tool'; id: string };
   const turn = {
-    text: '' as string,
-    toolOrder: [] as string[],
+    blocks: [] as Block[],
     tools: new Map<string, ToolEntry>(),
     plans: [] as string[],
     progress: [] as string[],
@@ -458,20 +459,54 @@ async function handleRunTask(apiUrl: string, deviceId: string, task: any, detect
     error: null as null | string,
   };
 
+  const appendText = (text: string) => {
+    const last = turn.blocks[turn.blocks.length - 1];
+    if (last && last.kind === 'text') last.text += text;
+    else turn.blocks.push({ kind: 'text', text });
+  };
+
+  const upsertTool = (id: string, patch: Partial<ToolEntry>) => {
+    const existing = turn.tools.get(id);
+    if (existing) {
+      if (patch.tool && patch.tool !== 'tool') existing.tool = patch.tool;
+      if (patch.kind) existing.kind = patch.kind;
+      if (patch.status) existing.status = patch.status;
+      if (patch.input !== undefined) existing.input = patch.input;
+    } else {
+      turn.tools.set(id, { id, tool: patch.tool || 'tool', kind: patch.kind, status: patch.status, input: patch.input, results: [] });
+      turn.blocks.push({ kind: 'tool', id });
+    }
+  };
+
+  const toolLabel = (t: ToolEntry): string => {
+    const clean = stripMd(t.tool);
+    if (clean && clean !== 'tool') return clean;
+    // Fallback from input shape
+    if (t.input && typeof t.input === 'object') {
+      if (t.input.command) return `Bash: ${String(t.input.command).split('\n')[0].slice(0, 60)}`;
+      if (t.input.file_path) return `${t.kind === 'edit' ? 'Edit' : 'Read'}: ${t.input.file_path}`;
+      if (t.input.pattern) return `Grep: ${t.input.pattern}`;
+      if (t.input.url) return `Fetch: ${t.input.url}`;
+    }
+    return (t.kind ? `${t.kind}` : 'tool');
+  };
+
   const render = (): string => {
     const parts: string[] = [];
-    if (turn.text) parts.push(turn.text);
-
-    for (const id of turn.toolOrder) {
-      const t = turn.tools.get(id);
+    for (const b of turn.blocks) {
+      if (b.kind === 'text') {
+        if (b.text) parts.push(b.text);
+        continue;
+      }
+      const t = turn.tools.get(b.id);
       if (!t) continue;
       const icon = statusIcon(t.status);
-      const cleanTool = stripMd(t.tool);
-      const head = `${icon} ${cleanTool}${t.kind ? ` · ${t.kind}` : ''}${t.status && t.status !== 'completed' ? ` · ${t.status}` : ''}`;
+      const label = toolLabel(t);
+      const head = `${icon} ${label}${t.status && t.status !== 'completed' ? ` · ${t.status}` : ''}`;
       const body: string[] = [];
       if (t.input !== undefined && t.input !== null) {
         const inputStr = typeof t.input === 'object' ? JSON.stringify(t.input, null, 2) : String(t.input);
-        body.push('```json\n' + inputStr + '\n```');
+        body.push('```json\n' + inputStr.slice(0, 2000) + '\n```');
       }
       if (t.results.length) {
         const joined = t.results.join('\n').slice(-2000);
@@ -481,7 +516,6 @@ async function handleRunTask(apiUrl: string, deviceId: string, task: any, detect
     }
 
     if (turn.plans.length) parts.push('**Plan**\n\n' + turn.plans[turn.plans.length - 1]);
-
     if (turn.error) parts.push(`> ❌ ${turn.error}`);
 
     if (turn.result) {
@@ -517,16 +551,15 @@ async function handleRunTask(apiUrl: string, deviceId: string, task: any, detect
       }
       case 'assistant_text': {
         await ensureLiveComment();
-        turn.text += p.text;
+        appendText(p.text);
         hasAssistantText = true;
         schedulePatch();
         break;
       }
       case 'stdout': {
-        // Legacy (non-ACP) runners emit stdout — route to live comment too.
         if (p.line) {
           await ensureLiveComment();
-          turn.text += (turn.text ? '\n' : '') + p.line;
+          appendText((turn.blocks.length ? '\n' : '') + p.line);
           hasAssistantText = true;
           schedulePatch();
         }
@@ -534,33 +567,24 @@ async function handleRunTask(apiUrl: string, deviceId: string, task: any, detect
       }
       case 'tool_call': {
         await ensureLiveComment();
-        const id = p.id || `anon-${turn.toolOrder.length}`;
-        const existing = turn.tools.get(id);
-        if (existing) {
-          if (p.tool) existing.tool = p.tool;
-          if (p.kind) existing.kind = p.kind;
-          if (p.status) existing.status = p.status;
-          if (p.input !== undefined) existing.input = p.input;
-        } else {
-          turn.toolOrder.push(id);
-          turn.tools.set(id, { id, tool: p.tool || 'tool', kind: p.kind, status: p.status, input: p.input, results: [] });
-        }
+        const id = p.id || `anon-${turn.tools.size}`;
+        upsertTool(id, { tool: p.tool, kind: p.kind, status: p.status, input: p.input });
         schedulePatch();
         break;
       }
       case 'tool_result': {
         await ensureLiveComment();
-        const id = p.tool_use_id || turn.toolOrder[turn.toolOrder.length - 1];
+        const lastToolId = [...turn.blocks].reverse().find(b => b.kind === 'tool')?.id;
+        const id = p.tool_use_id || lastToolId;
         const entry = id ? turn.tools.get(id) : undefined;
         const content = String(p.content ?? '').trim();
         if (entry && content) {
           entry.results.push(content);
           schedulePatch();
         } else if (content) {
-          // orphan result — create a pseudo tool
-          const pid = `result-${turn.toolOrder.length}`;
-          turn.toolOrder.push(pid);
-          turn.tools.set(pid, { id: pid, tool: 'tool result', results: [content] });
+          const pid = `result-${turn.tools.size}`;
+          upsertTool(pid, { tool: 'tool result' });
+          turn.tools.get(pid)!.results.push(content);
           schedulePatch();
         }
         break;
@@ -569,7 +593,7 @@ async function handleRunTask(apiUrl: string, deviceId: string, task: any, detect
         await ensureLiveComment();
         if (p.is_error) hadError = true;
         if (!hasAssistantText && p.result) {
-          turn.text = p.result;
+          appendText(p.result);
           hasAssistantText = true;
         }
         turn.result = { duration_ms: p.duration_ms, total_cost_usd: p.total_cost_usd, stopReason: p.stopReason, is_error: p.is_error };
@@ -593,6 +617,8 @@ async function handleRunTask(apiUrl: string, deviceId: string, task: any, detect
   } catch {}
   const acpCapable = detected.filter(d => d.type === 'claude-code');
   const useAcp = preferType !== 'pi' && acpCapable.length > 0 && process.env.MULTI_LEGACY !== '1';
+  // Route pi/codex/openclaw through acpx (handles these agent types natively)
+  const useAcpx = !useAcp && preferType && ['pi', 'codex', 'openclaw'].includes(preferType) && process.env.MULTI_LEGACY !== '1';
 
   try {
     if (useAcp) {
@@ -653,13 +679,42 @@ async function handleRunTask(apiUrl: string, deviceId: string, task: any, detect
         },
       });
       log(`  acp session ${sessionId.slice(0, 8)}`);
-    } else {
-      // Determine preferred type from agent (e.g. pi)
-      let preferType: string | undefined;
+    } else if (useAcpx) {
+      // Build prompt with preamble (same logic as ACP path, but as one string)
+      let preamble = '';
       try {
-        const a = await apiClient.get<any>(`${apiUrl}/api/agents/${task.agent_id}`);
-        if (a.data?.type) preferType = a.data.type;
+        const agentRes = await apiClient.get<any>(`${apiUrl}/api/agents/${task.agent_id}`);
+        const agent = agentRes.data;
+        if (agent?.prompt) preamble += `# Agent instructions\n\n${agent.prompt}\n\n`;
+        const skillsRes = await apiClient.get<any[]>(`${apiUrl}/api/agents/${task.agent_id}/skills`);
+        const skillList = Array.isArray(skillsRes.data) ? skillsRes.data : [];
+        if (skillList.length) {
+          preamble += `# Attached skills (${skillList.length})\n\n`;
+          for (const s of skillList) {
+            const body = String(s.body || s.description || '').trim();
+            if (body) preamble += `## ${s.name}${s.version ? ` v${s.version}` : ''}\n\n${body}\n\n`;
+          }
+        }
       } catch {}
+      const base = `${task.title}\n\n${task.description || ''}`.trim();
+      let userPart = task.followup ? `${task.followup}\n\n---\nContext (${task.key}): ${task.title}` : (base || task.title);
+      userPart = stripSelfMention(userPart, preferType);
+      if (attachmentRefs.length) {
+        const lines = attachmentRefs.map(a => `- ${a.filename}: ${a.path}`).join('\n');
+        userPart += `\n\n---\nAttached files:\n${lines}\n\nWrite generated files to: ${outDir}`;
+      } else {
+        userPart += `\n\n---\nWrite generated files to: ${outDir}`;
+      }
+      const full = preamble ? `${preamble}\n---\n\n${userPart}` : userPart;
+      log(`  acpx runner: ${preferType}`);
+      await runAcpx({
+        agentType: preferType!,
+        prompt: full,
+        cwd: workingDir,
+        sessionName: `issue-${issueId}`,
+        onEvent: eventHandler,
+      });
+    } else {
       const runner = pickRunner(detected, preferType);
       for await (const event of runner(task)) await eventHandler(event);
     }