@shipers-dev/multi 0.9.2 → 0.9.4

package/dist/index.js

@@ -5700,15 +5700,35 @@ async function ensureWorktree(workingDir, issueKey) {
 import { parseArgs } from "util";
 import { mkdirSync as mkdirSync3, existsSync as existsSync3, writeFileSync as writeFileSync3, readFileSync as readFileSync3, appendFileSync as appendFileSync2, unlinkSync, readdirSync, statSync } from "fs";
 import { join as join3, dirname as dirname2 } from "path";
+// package.json
+var package_default = {
+  name: "@shipers-dev/multi",
+  version: "0.9.4",
+  type: "module",
+  bin: {
+    "multi-agent": "./dist/index.js"
+  },
+  scripts: {
+    dev: "bun run src/index.ts",
+    build: "bun build src/index.ts --outdir=dist --target=bun"
+  },
+  dependencies: {
+    "@zed-industries/agent-client-protocol": "^0.4.5",
+    "@zed-industries/claude-code-acp": "^0.16.2"
+  }
+};
+
+// src/index.ts
 var HOME2 = process.env.HOME || process.env.USERPROFILE || ".";
 var MULTI_DIR = join3(HOME2, ".multi");
 var CONFIG_PATH = join3(MULTI_DIR, "config.json");
 var PID_PATH = join3(MULTI_DIR, "agent.pid");
+var PORT_PATH = join3(MULTI_DIR, "agent.port");
 var LOG_PATH2 = join3(MULTI_DIR, "logs", "agent.log");
 var SKILLS_DIR = join3(MULTI_DIR, "skills");
 var STOP_PATH = join3(MULTI_DIR, "stop.flag");
 var TASKS_DB_PATH = join3(MULTI_DIR, "tasks.db");
-var VERSION = "0.9.2";
+var VERSION = package_default.version;
 var COMMANDS = {
   setup: "Register this device with a workspace",
   connect: "Connect device to realtime hub and execute assigned tasks",
@@ -5716,7 +5736,8 @@ var COMMANDS = {
   status: "Show current status",
   stop: "Stop the running daemon",
   restart: "Stop and relaunch the daemon in background",
-  logs: "View execution logs"
+  logs: "View execution logs",
+  reset: "Reset acpx session for an issue (--issue <id>)"
 };
 function ensureDirs() {
   for (const d of [MULTI_DIR, join3(MULTI_DIR, "logs"), SKILLS_DIR]) {
@@ -5746,7 +5767,8 @@ async function main() {
       name: { type: "string" },
       workspace: { type: "string" },
       agent: { type: "string" },
-      api: { type: "string" }
+      api: { type: "string" },
+      issue: { type: "string" }
     },
     allowPositionals: true,
     strict: false
@@ -5787,6 +5809,9 @@ async function main() {
     case "logs":
       await cmdLogs();
       break;
+    case "reset":
+      await cmdReset(args.values.issue);
+      break;
     default:
       console.error(`Unknown command: ${command}`);
       printHelp();
@@ -5807,6 +5832,7 @@ Commands:
   stop      ${COMMANDS.stop}
   restart   ${COMMANDS.restart}
   logs      ${COMMANDS.logs}
+  reset     ${COMMANDS.reset}
 
 Options:
   --name <name>       Device name
@@ -5947,21 +5973,48 @@ async function cmdConnect(apiUrl, config) {
   db.run("UPDATE tasks SET status = 'queued' WHERE status = 'running'");
   const MAX_DEVICE = Math.max(1, parseInt(process.env.MULTI_MAX_CONCURRENT ?? "3", 10) || 3);
   const running = new Map;
+  function resolvePayloadIds(row) {
+    let agent_id = row.agent_id;
+    let issue_id = row.issue_id;
+    if (!agent_id || !issue_id) {
+      try {
+        const p = JSON.parse(row.payload);
+        agent_id ??= p?.agent_id ?? null;
+        issue_id ??= p?.issue_id ?? null;
+      } catch {}
+    }
+    return { agent_id, issue_id };
+  }
   function pickNext() {
-    const busyAgents = Array.from(running.values()).map((e) => e.agentId).filter(Boolean);
-    const notIn = busyAgents.length ? `AND (agent_id IS NULL OR agent_id NOT IN (${busyAgents.map(() => "?").join(",")}))` : "";
-    const sql = `SELECT id, payload, agent_id, issue_id FROM tasks WHERE status = 'queued' ${notIn} ORDER BY created_at ASC LIMIT 1`;
-    return db.query(sql).get(...busyAgents);
+    const busyAgents = Array.from(running.values()).map((e) => e.agentId).filter((v) => !!v);
+    const busyIssues = Array.from(running.values()).map((e) => e.issueId).filter((v) => !!v);
+    const clauses = [];
+    const binds = [];
+    if (busyAgents.length) {
+      clauses.push(`(agent_id IS NULL OR agent_id NOT IN (${busyAgents.map(() => "?").join(",")}))`);
+      binds.push(...busyAgents);
+    }
+    if (busyIssues.length) {
+      clauses.push(`(issue_id IS NULL OR issue_id NOT IN (${busyIssues.map(() => "?").join(",")}))`);
+      binds.push(...busyIssues);
+    }
+    const where = clauses.length ? `AND ${clauses.join(" AND ")}` : "";
+    const sql = `SELECT id, payload, agent_id, issue_id FROM tasks WHERE status = 'queued' ${where} ORDER BY created_at ASC LIMIT 1`;
+    return db.query(sql).get(...binds);
   }
   function schedule() {
     while (running.size < MAX_DEVICE) {
       const row = pickNext();
       if (!row)
         return;
+      const ids = resolvePayloadIds(row);
+      if (ids.agent_id && Array.from(running.values()).some((e) => e.agentId === ids.agent_id))
+        return;
+      if (ids.issue_id && Array.from(running.values()).some((e) => e.issueId === ids.issue_id))
+        return;
       db.run("UPDATE tasks SET status = 'running', started_at = unixepoch(), attempts = attempts + 1 WHERE id = ?", [row.id]);
-      const entry = { agentId: row.agent_id || "", startedAt: Date.now(), child: null, worktreePath: "" };
-      const issueKey = row.issue_id || row.id;
-      running.set(issueKey, entry);
+      const entry = { agentId: ids.agent_id || "", issueId: ids.issue_id, startedAt: Date.now(), child: null, worktreePath: "" };
+      running.set(row.id, entry);
       (async () => {
         try {
           const task = JSON.parse(row.payload);
@@ -5971,7 +6024,7 @@ async function cmdConnect(apiUrl, config) {
           log(`task ${row.id} error: ${String(e)}`);
           db.run("UPDATE tasks SET status = 'failed', finished_at = unixepoch(), error = ? WHERE id = ?", [String(e), row.id]);
         } finally {
-          running.delete(issueKey);
+          running.delete(row.id);
           queueMicrotask(() => schedule());
         }
       })();
@@ -6006,6 +6059,52 @@ async function cmdConnect(apiUrl, config) {
           }
         })();
       }
+      if (url.pathname === "/reset_session" && req.method === "POST") {
+        if (req.headers.get("authorization") !== expectedAuth)
+          return new Response("unauthorized", { status: 401 });
+        return (async () => {
+          try {
+            const { issue_id, agent_type } = await req.json();
+            if (!issue_id)
+              return Response.json({ error: "issue_id required" }, { status: 400 });
+            const entries = Array.from(running.values()).filter((e) => e.issueId === issue_id);
+            for (const entry of entries) {
+              entry.stopped = true;
+              entry.stopReason = "session reset";
+              try {
+                entry.child?.kill("SIGTERM");
+              } catch {}
+              setTimeout(() => {
+                try {
+                  entry.child?.kill("SIGKILL");
+                } catch {}
+              }, 3000);
+            }
+            const acpxTypes = agent_type ? [agent_type] : ["pi", "codex", "openclaw"];
+            const sessionName = `issue-${issue_id}`;
+            const cwd = process.env.HOME || process.cwd();
+            const results = [];
+            for (const t of acpxTypes) {
+              try {
+                const rm = Bun.spawn(["acpx", "--ttl", "0", "--cwd", cwd, t, "sessions", "close", sessionName], {
+                  stdout: "pipe",
+                  stderr: "pipe",
+                  stdin: "ignore"
+                });
+                const err = await new Response(rm.stderr).text();
+                const exit = await rm.exited;
+                results.push({ agent: t, exit, stderr: err.slice(0, 200) });
+              } catch (e) {
+                results.push({ agent: t, exit: -1, stderr: String(e).slice(0, 200) });
+              }
+            }
+            log(`\uD83D\uDD04 reset_session ${issue_id} (killed=${entries.length}) ${results.map((r) => `${r.agent}:${r.exit}`).join(" ")}`);
+            return Response.json({ ok: true, killed: entries.length, sessions: results });
+          } catch (e) {
+            return Response.json({ error: String(e) }, { status: 400 });
+          }
+        })();
+      }
       if (url.pathname === "/stop" && req.method === "POST") {
         if (req.headers.get("authorization") !== expectedAuth)
           return new Response("unauthorized", { status: 401 });
@@ -6014,22 +6113,24 @@ async function cmdConnect(apiUrl, config) {
             const { issue_id } = await req.json();
             if (!issue_id)
               return Response.json({ error: "issue_id required" }, { status: 400 });
-            const entry = running.get(issue_id);
-            if (!entry) {
+            const entries = Array.from(running.values()).filter((e) => e.issueId === issue_id);
+            if (!entries.length) {
               db.run("UPDATE tasks SET status = 'failed', error = 'stopped before start', finished_at = unixepoch() WHERE issue_id = ? AND status = 'queued'", [issue_id]);
               await markStopped(apiUrl, issue_id, "stopped before start");
               return Response.json({ ok: true, state: "queued-cancelled" });
             }
-            entry.stopped = true;
-            entry.stopReason = "user requested";
-            try {
-              entry.child?.kill("SIGTERM");
-            } catch {}
-            setTimeout(() => {
+            for (const entry of entries) {
+              entry.stopped = true;
+              entry.stopReason = "user requested";
               try {
-                entry.child?.kill("SIGKILL");
+                entry.child?.kill("SIGTERM");
               } catch {}
-            }, 5000);
+              setTimeout(() => {
+                try {
+                  entry.child?.kill("SIGKILL");
+                } catch {}
+              }, 5000);
+            }
             return Response.json({ ok: true, state: "running-signalled" });
           } catch (e) {
             return Response.json({ error: String(e) }, { status: 400 });
@@ -6040,6 +6141,9 @@ async function cmdConnect(apiUrl, config) {
     }
   });
   log(`\uD83C\uDF10 Local server: http://127.0.0.1:${port}`);
+  try {
+    writeFileSync3(PORT_PATH, String(port));
+  } catch {}
   const cf = Bun.spawn(["cloudflared", "tunnel", "--no-autoupdate", "--url", `http://127.0.0.1:${port}`], {
     stdout: "pipe",
     stderr: "pipe",
@@ -6077,6 +6181,8 @@ async function cmdConnect(apiUrl, config) {
       unlinkSync(PID_PATH);
     if (existsSync3(STOP_PATH))
       unlinkSync(STOP_PATH);
+    if (existsSync3(PORT_PATH))
+      unlinkSync(PORT_PATH);
     db.close();
     log("\uD83D\uDC4B Disconnected");
     process.exit(0);
@@ -7199,6 +7305,33 @@ async function cmdStop() {
     console.log(`Sent SIGTERM to ${pid}`);
   } catch {}
 }
+async function cmdReset(issueId) {
+  if (!issueId) {
+    console.error("Usage: multi-agent reset --issue <issue_id>");
+    process.exit(2);
+  }
+  if (!existsSync3(PORT_PATH)) {
+    console.error("Daemon not running (no port file).");
+    process.exit(1);
+  }
+  const port = Number(readFileSync3(PORT_PATH, "utf8").trim());
+  const config = loadConfig();
+  if (!config.dispatchSecret) {
+    console.error("No dispatchSecret in config \u2014 run `multi-agent setup` first.");
+    process.exit(1);
+  }
+  const res = await fetch(`http://127.0.0.1:${port}/reset_session`, {
+    method: "POST",
+    headers: { "content-type": "application/json", authorization: `Bearer ${config.dispatchSecret}` },
+    body: JSON.stringify({ issue_id: issueId })
+  });
+  const body = await res.text();
+  if (!res.ok) {
+    console.error(`Reset failed (${res.status}): ${body}`);
+    process.exit(1);
+  }
+  console.log(body);
+}
 async function cmdRestart(apiUrl) {
   if (existsSync3(PID_PATH)) {
     const pid = Number(readFileSync3(PID_PATH, "utf8").trim());
@@ -7288,6 +7421,8 @@ function openTasksDb() {
     CREATE INDEX IF NOT EXISTS idx_tasks_issue ON tasks(issue_id);
   `);
   db.run("UPDATE tasks SET status = 'queued' WHERE status = 'pending'");
+  db.run("UPDATE tasks SET agent_id = json_extract(payload, '$.agent_id') WHERE agent_id IS NULL AND payload IS NOT NULL AND json_valid(payload)");
+  db.run("UPDATE tasks SET issue_id = json_extract(payload, '$.issue_id') WHERE issue_id IS NULL AND payload IS NOT NULL AND json_valid(payload)");
   return db;
 }
 function loadConfig() {

package/package.json

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

package/src/index.ts

@@ -9,16 +9,18 @@ import { ensureWorktree } from './worktree';
 import { parseArgs } from 'util';
 import { mkdirSync, existsSync, writeFileSync, readFileSync, appendFileSync, unlinkSync, readdirSync, statSync } from 'fs';
 import { join, dirname } from 'path';
+import pkg from '../package.json' with { type: 'json' };
 
 const HOME = process.env.HOME || process.env.USERPROFILE || '.';
 const MULTI_DIR = join(HOME, '.multi');
 const CONFIG_PATH = join(MULTI_DIR, 'config.json');
 const PID_PATH = join(MULTI_DIR, 'agent.pid');
+const PORT_PATH = join(MULTI_DIR, 'agent.port');
 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.9.2';
+const VERSION = (pkg as { version: string }).version;
 
 const COMMANDS = {
   setup: 'Register this device with a workspace',
@@ -28,6 +30,7 @@ const COMMANDS = {
   stop: 'Stop the running daemon',
   restart: 'Stop and relaunch the daemon in background',
   logs: 'View execution logs',
+  reset: 'Reset acpx session for an issue (--issue <id>)',
 } as const;
 
 type Command = keyof typeof COMMANDS;
@@ -62,6 +65,7 @@ async function main() {
       workspace: { type: 'string' },
       agent: { type: 'string' },
       api: { type: 'string' },
+      issue: { type: 'string' },
     },
     allowPositionals: true,
     strict: false,
@@ -105,6 +109,9 @@ async function main() {
     case 'logs':
       await cmdLogs();
       break;
+    case 'reset':
+      await cmdReset(args.values.issue);
+      break;
     default:
       console.error(`Unknown command: ${command}`);
       printHelp();
@@ -126,6 +133,7 @@ Commands:
   stop      ${COMMANDS.stop}
   restart   ${COMMANDS.restart}
   logs      ${COMMANDS.logs}
+  reset     ${COMMANDS.reset}
 
 Options:
   --name <name>       Device name
@@ -261,26 +269,52 @@ async function cmdConnect(apiUrl: string, config: Config) {
   db.run("UPDATE tasks SET status = 'queued' WHERE status = 'running'");
 
   const MAX_DEVICE = Math.max(1, parseInt(process.env.MULTI_MAX_CONCURRENT ?? '3', 10) || 3);
+  // Keyed by task row id — unique per dispatch. Duplicate issue_id / agent_id still
+  // serialize via busyAgents/busyIssues filters.
   const running = new Map<string, RunEntry>();
 
+  function resolvePayloadIds(row: { payload: string; agent_id: string | null; issue_id: string | null }): { agent_id: string | null; issue_id: string | null } {
+    let agent_id = row.agent_id;
+    let issue_id = row.issue_id;
+    if (!agent_id || !issue_id) {
+      try {
+        const p = JSON.parse(row.payload) as any;
+        agent_id ??= p?.agent_id ?? null;
+        issue_id ??= p?.issue_id ?? null;
+      } catch {}
+    }
+    return { agent_id, issue_id };
+  }
+
   function pickNext(): { id: string; payload: string; agent_id: string | null; issue_id: string | null } | null {
-    const busyAgents = Array.from(running.values()).map((e) => e.agentId).filter(Boolean) as string[];
-    // Emulate NOT IN (:list) via string construction (safe: only ids from DB).
-    const notIn = busyAgents.length
-      ? `AND (agent_id IS NULL OR agent_id NOT IN (${busyAgents.map(() => '?').join(',')}))`
-      : '';
-    const sql = `SELECT id, payload, agent_id, issue_id FROM tasks WHERE status = 'queued' ${notIn} ORDER BY created_at ASC LIMIT 1`;
-    return db.query(sql).get(...busyAgents) as any;
+    const busyAgents = Array.from(running.values()).map((e) => e.agentId).filter((v): v is string => !!v);
+    const busyIssues = Array.from(running.values()).map((e) => e.issueId).filter((v): v is string => !!v);
+    const clauses: string[] = [];
+    const binds: string[] = [];
+    if (busyAgents.length) {
+      clauses.push(`(agent_id IS NULL OR agent_id NOT IN (${busyAgents.map(() => '?').join(',')}))`);
+      binds.push(...busyAgents);
+    }
+    if (busyIssues.length) {
+      clauses.push(`(issue_id IS NULL OR issue_id NOT IN (${busyIssues.map(() => '?').join(',')}))`);
+      binds.push(...busyIssues);
+    }
+    const where = clauses.length ? `AND ${clauses.join(' AND ')}` : '';
+    const sql = `SELECT id, payload, agent_id, issue_id FROM tasks WHERE status = 'queued' ${where} ORDER BY created_at ASC LIMIT 1`;
+    return db.query(sql).get(...binds) as any;
   }
 
   function schedule() {
     while (running.size < MAX_DEVICE) {
       const row = pickNext();
       if (!row) return;
+      const ids = resolvePayloadIds(row);
+      // Defensive: if DB saw NULL agent/issue but payload has them, skip if busy.
+      if (ids.agent_id && Array.from(running.values()).some((e) => e.agentId === ids.agent_id)) return;
+      if (ids.issue_id && Array.from(running.values()).some((e) => e.issueId === ids.issue_id)) return;
       db.run("UPDATE tasks SET status = 'running', started_at = unixepoch(), attempts = attempts + 1 WHERE id = ?", [row.id]);
-      const entry: RunEntry = { agentId: row.agent_id || '', startedAt: Date.now(), child: null, worktreePath: '' };
-      const issueKey = row.issue_id || row.id;
-      running.set(issueKey, entry);
+      const entry: RunEntry = { agentId: ids.agent_id || '', issueId: ids.issue_id, startedAt: Date.now(), child: null, worktreePath: '' };
+      running.set(row.id, entry);
       void (async () => {
         try {
           const task = JSON.parse(row.payload);
@@ -290,7 +324,7 @@ async function cmdConnect(apiUrl: string, config: Config) {
           log(`task ${row.id} error: ${String(e)}`);
           db.run("UPDATE tasks SET status = 'failed', finished_at = unixepoch(), error = ? WHERE id = ?", [String(e), row.id]);
         } finally {
-          running.delete(issueKey);
+          running.delete(row.id);
           queueMicrotask(() => schedule());
         }
       })();
@@ -328,22 +362,64 @@ async function cmdConnect(apiUrl: string, config: Config) {
           }
         })();
       }
+      if (url.pathname === '/reset_session' && req.method === 'POST') {
+        if (req.headers.get('authorization') !== expectedAuth) return new Response('unauthorized', { status: 401 });
+        return (async () => {
+          try {
+            const { issue_id, agent_type } = await req.json() as { issue_id: string; agent_type?: string };
+            if (!issue_id) return Response.json({ error: 'issue_id required' }, { status: 400 });
+
+            // Kill any running acpx child for this issue.
+            const entries = Array.from(running.values()).filter((e) => e.issueId === issue_id);
+            for (const entry of entries) {
+              entry.stopped = true;
+              entry.stopReason = 'session reset';
+              try { entry.child?.kill('SIGTERM'); } catch {}
+              setTimeout(() => { try { entry.child?.kill('SIGKILL'); } catch {} }, 3000);
+            }
+
+            // Close acpx session so next dispatch creates fresh. Only known acpx types.
+            const acpxTypes = agent_type ? [agent_type] : ['pi', 'codex', 'openclaw'];
+            const sessionName = `issue-${issue_id}`;
+            const cwd = process.env.HOME || process.cwd();
+            const results: { agent: string; exit: number; stderr: string }[] = [];
+            for (const t of acpxTypes) {
+              try {
+                const rm = Bun.spawn(['acpx', '--ttl', '0', '--cwd', cwd, t, 'sessions', 'close', sessionName], {
+                  stdout: 'pipe', stderr: 'pipe', stdin: 'ignore',
+                });
+                const err = await new Response(rm.stderr as any).text();
+                const exit = await rm.exited;
+                results.push({ agent: t, exit, stderr: err.slice(0, 200) });
+              } catch (e) {
+                results.push({ agent: t, exit: -1, stderr: String(e).slice(0, 200) });
+              }
+            }
+            log(`🔄 reset_session ${issue_id} (killed=${entries.length}) ${results.map(r => `${r.agent}:${r.exit}`).join(' ')}`);
+            return Response.json({ ok: true, killed: entries.length, sessions: results });
+          } catch (e) {
+            return Response.json({ error: String(e) }, { status: 400 });
+          }
+        })();
+      }
       if (url.pathname === '/stop' && req.method === 'POST') {
         if (req.headers.get('authorization') !== expectedAuth) return new Response('unauthorized', { status: 401 });
         return (async () => {
           try {
             const { issue_id } = await req.json() as { issue_id: string };
             if (!issue_id) return Response.json({ error: 'issue_id required' }, { status: 400 });
-            const entry = running.get(issue_id);
-            if (!entry) {
+            const entries = Array.from(running.values()).filter((e) => e.issueId === issue_id);
+            if (!entries.length) {
               db.run("UPDATE tasks SET status = 'failed', error = 'stopped before start', finished_at = unixepoch() WHERE issue_id = ? AND status = 'queued'", [issue_id]);
               await markStopped(apiUrl, issue_id, 'stopped before start');
               return Response.json({ ok: true, state: 'queued-cancelled' });
             }
-            entry.stopped = true;
-            entry.stopReason = 'user requested';
-            try { entry.child?.kill('SIGTERM'); } catch {}
-            setTimeout(() => { try { entry.child?.kill('SIGKILL'); } catch {} }, 5000);
+            for (const entry of entries) {
+              entry.stopped = true;
+              entry.stopReason = 'user requested';
+              try { entry.child?.kill('SIGTERM'); } catch {}
+              setTimeout(() => { try { entry.child?.kill('SIGKILL'); } catch {} }, 5000);
+            }
             return Response.json({ ok: true, state: 'running-signalled' });
           } catch (e) {
             return Response.json({ error: String(e) }, { status: 400 });
@@ -354,6 +430,7 @@ async function cmdConnect(apiUrl: string, config: Config) {
     },
   });
   log(`🌐 Local server: http://127.0.0.1:${port}`);
+  try { writeFileSync(PORT_PATH, String(port)); } catch {}
 
   // Spawn cloudflared quick tunnel
   const cf = Bun.spawn(['cloudflared', 'tunnel', '--no-autoupdate', '--url', `http://127.0.0.1:${port}`], {
@@ -381,6 +458,7 @@ async function cmdConnect(apiUrl: string, config: Config) {
     try { await apiClient.post(`${apiUrl}/api/devices/${config.deviceId}/heartbeat`, { status: 'offline', tunnel_url: null }); } catch {}
     if (existsSync(PID_PATH)) unlinkSync(PID_PATH);
     if (existsSync(STOP_PATH)) unlinkSync(STOP_PATH);
+    if (existsSync(PORT_PATH)) unlinkSync(PORT_PATH);
     db.close();
     log('👋 Disconnected');
     process.exit(0);
@@ -462,6 +540,7 @@ async function parseTunnelUrl(stream: ReadableStream<Uint8Array>): Promise<strin
 
 interface RunEntry {
   agentId: string;
+  issueId: string | null;
   startedAt: number;
   child: any | null;
   worktreePath: string;
@@ -1377,6 +1456,22 @@ async function cmdStop() {
   try { process.kill(pid, 'SIGTERM'); console.log(`Sent SIGTERM to ${pid}`); } catch {}
 }
 
+async function cmdReset(issueId?: string) {
+  if (!issueId) { console.error('Usage: multi-agent reset --issue <issue_id>'); process.exit(2); }
+  if (!existsSync(PORT_PATH)) { console.error('Daemon not running (no port file).'); process.exit(1); }
+  const port = Number(readFileSync(PORT_PATH, 'utf8').trim());
+  const config = loadConfig();
+  if (!config.dispatchSecret) { console.error('No dispatchSecret in config — run `multi-agent setup` first.'); process.exit(1); }
+  const res = await fetch(`http://127.0.0.1:${port}/reset_session`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json', 'authorization': `Bearer ${config.dispatchSecret}` },
+    body: JSON.stringify({ issue_id: issueId }),
+  });
+  const body = await res.text();
+  if (!res.ok) { console.error(`Reset failed (${res.status}): ${body}`); process.exit(1); }
+  console.log(body);
+}
+
 async function cmdRestart(apiUrl: string) {
   if (existsSync(PID_PATH)) {
     const pid = Number(readFileSync(PID_PATH, 'utf8').trim());
@@ -1458,6 +1553,11 @@ function openTasksDb(): Database {
   `);
   // Old rows used 'pending'; normalize to 'queued'.
   db.run("UPDATE tasks SET status = 'queued' WHERE status = 'pending'");
+  // Backfill agent_id/issue_id from payload JSON for rows predating the columns.
+  // Without this, the scheduler cannot serialize per-agent / per-issue and fires
+  // concurrent dispatches for the same agent on the same issue.
+  db.run("UPDATE tasks SET agent_id = json_extract(payload, '$.agent_id') WHERE agent_id IS NULL AND payload IS NOT NULL AND json_valid(payload)");
+  db.run("UPDATE tasks SET issue_id = json_extract(payload, '$.issue_id') WHERE issue_id IS NULL AND payload IS NOT NULL AND json_valid(payload)");
   return db;
 }