chatroom-cli 1.0.85 → 1.2.0

package/dist/index.js

@@ -29,7 +29,7 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// ../../node_modules/.pnpm/commander@14.0.2/node_modules/commander/lib/error.js
+// ../../node_modules/.pnpm/commander@14.0.3/node_modules/commander/lib/error.js
 var require_error = __commonJS((exports) => {
   class CommanderError extends Error {
     constructor(exitCode, code, message) {
@@ -53,7 +53,7 @@ var require_error = __commonJS((exports) => {
   exports.InvalidArgumentError = InvalidArgumentError;
 });
 
-// ../../node_modules/.pnpm/commander@14.0.2/node_modules/commander/lib/argument.js
+// ../../node_modules/.pnpm/commander@14.0.3/node_modules/commander/lib/argument.js
 var require_argument = __commonJS((exports) => {
   var { InvalidArgumentError } = require_error();
 
@@ -133,7 +133,7 @@ var require_argument = __commonJS((exports) => {
   exports.humanReadableArgName = humanReadableArgName;
 });
 
-// ../../node_modules/.pnpm/commander@14.0.2/node_modules/commander/lib/help.js
+// ../../node_modules/.pnpm/commander@14.0.3/node_modules/commander/lib/help.js
 var require_help = __commonJS((exports) => {
   var { humanReadableArgName } = require_argument();
 
@@ -490,7 +490,7 @@ ${itemIndentStr}`);
   exports.stripColor = stripColor;
 });
 
-// ../../node_modules/.pnpm/commander@14.0.2/node_modules/commander/lib/option.js
+// ../../node_modules/.pnpm/commander@14.0.3/node_modules/commander/lib/option.js
 var require_option = __commonJS((exports) => {
   var { InvalidArgumentError } = require_error();
 
@@ -674,7 +674,7 @@ var require_option = __commonJS((exports) => {
   exports.DualOptions = DualOptions;
 });
 
-// ../../node_modules/.pnpm/commander@14.0.2/node_modules/commander/lib/suggestSimilar.js
+// ../../node_modules/.pnpm/commander@14.0.3/node_modules/commander/lib/suggestSimilar.js
 var require_suggestSimilar = __commonJS((exports) => {
   var maxDistance = 3;
   function editDistance(a, b) {
@@ -747,7 +747,7 @@ var require_suggestSimilar = __commonJS((exports) => {
   exports.suggestSimilar = suggestSimilar;
 });
 
-// ../../node_modules/.pnpm/commander@14.0.2/node_modules/commander/lib/command.js
+// ../../node_modules/.pnpm/commander@14.0.3/node_modules/commander/lib/command.js
 var require_command = __commonJS((exports) => {
   var EventEmitter = __require("node:events").EventEmitter;
   var childProcess = __require("node:child_process");
@@ -2102,7 +2102,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
   exports.useColor = useColor;
 });
 
-// ../../node_modules/.pnpm/commander@14.0.2/node_modules/commander/index.js
+// ../../node_modules/.pnpm/commander@14.0.3/node_modules/commander/index.js
 var require_commander = __commonJS((exports) => {
   var { Argument } = require_argument();
   var { Command } = require_command();
@@ -9343,6 +9343,15 @@ var init_index_node = __esm(() => {
 });
 
 // src/infrastructure/convex/client.ts
+var exports_client = {};
+__export(exports_client, {
+  resetConvexClient: () => resetConvexClient,
+  isClientLoggingEnabled: () => isClientLoggingEnabled,
+  getConvexWsClient: () => getConvexWsClient,
+  getConvexUrl: () => getConvexUrl,
+  getConvexClient: () => getConvexClient,
+  CONVEX_URL: () => CONVEX_URL
+});
 function getConvexUrl() {
   return process.env.CHATROOM_CONVEX_URL || DEFAULT_CONVEX_URL;
 }
@@ -9378,18 +9387,40 @@ async function getConvexWsClient() {
   }
   return wsClient;
 }
-var DEFAULT_CONVEX_URL = "https://chatroom-cloud.duskfare.com", client = null, wsClient = null, cachedUrl = null;
+function resetConvexClient() {
+  client = null;
+  if (wsClient) {
+    wsClient.close();
+    wsClient = null;
+  }
+  cachedUrl = null;
+}
+var DEFAULT_CONVEX_URL = "https://chatroom-cloud.duskfare.com", CONVEX_URL, client = null, wsClient = null, cachedUrl = null;
 var init_client2 = __esm(() => {
   init_index_node();
+  CONVEX_URL = DEFAULT_CONVEX_URL;
 });
 
 // src/infrastructure/auth/storage.ts
+var exports_storage = {};
+__export(exports_storage, {
+  saveAuthData: () => saveAuthData,
+  loadAuthData: () => loadAuthData,
+  isAuthenticated: () => isAuthenticated,
+  getSessionId: () => getSessionId,
+  getOtherSessionUrls: () => getOtherSessionUrls,
+  getDeviceName: () => getDeviceName,
+  getCliVersion: () => getVersion,
+  getAuthFilePath: () => getAuthFilePath,
+  getAllSessions: () => getAllSessions,
+  clearAuthData: () => clearAuthData
+});
 import { existsSync, mkdirSync, readFileSync as readFileSync2, writeFileSync, unlinkSync } from "node:fs";
 import { homedir, hostname } from "node:os";
 import { join as join2 } from "node:path";
 function ensureConfigDir() {
   if (!existsSync(CHATROOM_DIR)) {
-    mkdirSync(CHATROOM_DIR, { recursive: true });
+    mkdirSync(CHATROOM_DIR, { recursive: true, mode: 448 });
   }
 }
 function getAuthFilePath() {
@@ -9466,7 +9497,7 @@ function saveAuthData(data) {
 // To logout, run: chatroom auth logout
 ${JSON.stringify(multiEnvData, null, 2)}
 `;
-  writeFileSync(authPath, content, "utf-8");
+  writeFileSync(authPath, content, { encoding: "utf-8", mode: 384 });
 }
 function clearAuthData() {
   const authPath = getAuthFilePath();
@@ -9495,7 +9526,7 @@ function clearAuthData() {
 // To logout, run: chatroom auth logout
 ${JSON.stringify(rawData, null, 2)}
 `;
-    writeFileSync(authPath, content, "utf-8");
+    writeFileSync(authPath, content, { encoding: "utf-8", mode: 384 });
     return true;
   }
   try {
@@ -9617,6 +9648,17 @@ var init_api3 = __esm(() => {
   init_api2();
 });
 
+// src/utils/terminal-safety.ts
+function sanitizeForTerminal(input) {
+  return input.replace(/\u001B\][^\u0007]*(?:\u0007|\u001B\\)/g, "").replace(/\u001B\[[0-?]*[ -/]*[@-~]/g, "").replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]/g, "");
+}
+function sanitizeUnknownForTerminal(value) {
+  if (typeof value === "string") {
+    return sanitizeForTerminal(value);
+  }
+  return sanitizeForTerminal(String(value));
+}
+
 // src/utils/error-formatting.ts
 function formatError(message, suggestions) {
   console.error(`❌ ${message}`);
@@ -9659,24 +9701,26 @@ function formatChatroomIdError(chatroomId) {
 }
 function isNetworkError(error) {
   const msg = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
-  const code2 = error?.code;
+  const code2 = typeof error === "object" && error !== null && "code" in error ? error.code : undefined;
   return msg.includes("fetch failed") || msg.includes("failed to fetch") || msg.includes("econnrefused") || msg.includes("enotfound") || msg.includes("etimedout") || msg.includes("network") || msg.includes("connection refused") || msg.includes("socket hang up") || msg.includes("dns") || code2 === "ECONNREFUSED" || code2 === "ENOTFOUND" || code2 === "ETIMEDOUT" || code2 === "ECONNRESET";
 }
 function formatConnectivityError(error, backendUrl) {
   const err = error instanceof Error ? error : new Error(String(error));
+  const safeBackendUrl = backendUrl ? sanitizeForTerminal(backendUrl) : undefined;
   console.error(`
-❌ Could not reach the backend${backendUrl ? ` at ${backendUrl}` : ""}`);
-  console.error(`   ${err.message}`);
+❌ Could not reach the backend${safeBackendUrl ? ` at ${safeBackendUrl}` : ""}`);
+  console.error(`   ${sanitizeForTerminal(err.message)}`);
   console.error(`
    Your session may still be valid. Please check:`);
   console.error(`   • Network connectivity`);
   console.error(`   • Whether the backend service is running`);
-  if (backendUrl) {
-    console.error(`   • CHATROOM_CONVEX_URL is correct (currently: ${backendUrl})`);
+  if (safeBackendUrl) {
+    console.error(`   • CHATROOM_CONVEX_URL is correct (currently: ${safeBackendUrl})`);
   }
   console.error(`
    Try again once the backend is reachable.`);
 }
+var init_error_formatting = () => {};
 
 // src/infrastructure/auth/middleware.ts
 var exports_middleware = {};
@@ -9784,20 +9828,78 @@ async function checkAuth() {
 var init_middleware = __esm(() => {
   init_storage();
   init_api3();
+  init_error_formatting();
   init_client2();
 });
 
-// src/commands/auth-login.ts
+// src/commands/auth-login/index.ts
 var exports_auth_login = {};
 __export(exports_auth_login, {
+  getWebAppUrl: () => getWebAppUrl,
+  createDefaultDeps: () => createDefaultDeps,
   authLogin: () => authLogin
 });
-function getWebAppUrl() {
+async function openBrowser(url) {
+  const { spawn } = await import("node:child_process");
+  const platform = process.platform;
+  try {
+    if (platform === "darwin") {
+      const child = spawn("open", [url], { detached: true, stdio: "ignore" });
+      child.unref();
+    } else if (platform === "win32") {
+      const child = spawn("cmd", ["/c", "start", "", url], { detached: true, stdio: "ignore" });
+      child.unref();
+    } else {
+      const child = spawn("xdg-open", [url], { detached: true, stdio: "ignore" });
+      child.unref();
+    }
+  } catch {
+    console.log(`
+⚠️  Could not open browser automatically.`);
+    console.log(`   Please visit the URL manually.`);
+  }
+}
+function createDefaultDeps() {
+  return {
+    backend: {
+      mutation: async (endpoint, args) => {
+        const client2 = await getConvexClient();
+        return client2.mutation(endpoint, args);
+      },
+      query: async (endpoint, args) => {
+        const client2 = await getConvexClient();
+        return client2.query(endpoint, args);
+      }
+    },
+    auth: {
+      isAuthenticated,
+      getAuthFilePath,
+      saveAuthData,
+      getDeviceName,
+      getCliVersion: getVersion,
+      getSessionId
+    },
+    browser: {
+      open: openBrowser
+    },
+    clock: {
+      now: () => Date.now(),
+      delay: (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+    },
+    process: {
+      env: process.env,
+      platform: process.platform,
+      exit: (code2) => process.exit(code2),
+      stdoutWrite: (text) => process.stdout.write(text)
+    }
+  };
+}
+function getWebAppUrl(d) {
   const convexUrl = getConvexUrl();
   if (convexUrl === PRODUCTION_CONVEX_URL2) {
     return PRODUCTION_WEBAPP_URL;
   }
-  const webAppUrlOverride = process.env.CHATROOM_WEB_URL;
+  const webAppUrlOverride = d.process.env.CHATROOM_WEB_URL;
   if (webAppUrlOverride) {
     return webAppUrlOverride;
   }
@@ -9818,38 +9920,42 @@ To authenticate with a local/dev backend, you must also set`);
   console.error(`
 ${"═".repeat(50)}
 `);
-  process.exit(1);
-}
-async function openBrowser(url) {
-  const { exec } = await import("node:child_process");
-  const { promisify } = await import("node:util");
-  const execAsync = promisify(exec);
-  const platform = process.platform;
-  try {
-    if (platform === "darwin") {
-      await execAsync(`open "${url}"`);
-    } else if (platform === "win32") {
-      await execAsync(`start "" "${url}"`);
-    } else {
-      await execAsync(`xdg-open "${url}"`);
-    }
-  } catch {
-    console.log(`
-⚠️  Could not open browser automatically.`);
-    console.log(`   Please visit the URL manually.`);
-  }
-}
-async function authLogin(options) {
-  if (isAuthenticated() && !options.force) {
-    console.log(`✅ Already authenticated.`);
-    console.log(`   Auth file: ${getAuthFilePath()}`);
-    console.log(`
+  d.process.exit(1);
+  return "";
+}
+async function authLogin(options, deps) {
+  const d = deps ?? createDefaultDeps();
+  if (d.auth.isAuthenticated() && !options.force) {
+    const sessionId = d.auth.getSessionId();
+    if (sessionId) {
+      try {
+        const validation = await d.backend.query(api.cliAuth.validateSession, { sessionId });
+        if (validation.valid) {
+          console.log(`✅ Already authenticated.`);
+          console.log(`   Auth file: ${d.auth.getAuthFilePath()}`);
+          console.log(`
    Use --force to re-authenticate.`);
-    return;
+          return;
+        }
+        const reason = validation.reason;
+        if (reason === "Session expired") {
+          console.log(`
+⚠️  Your session has expired. Re-authenticating automatically...`);
+        } else {
+          console.log(`
+⚠️  Session is no longer valid (${reason}). Re-authenticating...`);
+        }
+      } catch {
+        console.log(`✅ Already authenticated (could not verify with backend).`);
+        console.log(`   Auth file: ${d.auth.getAuthFilePath()}`);
+        console.log(`
+   Use --force to re-authenticate.`);
+        return;
+      }
+    }
   }
-  const client2 = await getConvexClient();
-  const deviceName = getDeviceName();
-  const cliVersion = getVersion();
+  const deviceName = d.auth.getDeviceName();
+  const cliVersion = d.auth.getCliVersion();
   const convexUrl = getConvexUrl();
   console.log(`
 ${"═".repeat(50)}`);
@@ -9865,17 +9971,17 @@ Device: ${deviceName}`);
   }
   console.log(`
 ⏳ Creating authentication request...`);
-  const result = await client2.mutation(api.cliAuth.createAuthRequest, {
+  const result = await d.backend.mutation(api.cliAuth.createAuthRequest, {
     deviceName,
     cliVersion
   });
   const { requestId, expiresAt } = result;
-  const expiresInSeconds = Math.round((expiresAt - Date.now()) / 1000);
+  const expiresInSeconds = Math.round((expiresAt - d.clock.now()) / 1000);
   console.log(`
 ✅ Auth request created`);
   console.log(`   Request ID: ${requestId.substring(0, 8)}...`);
   console.log(`   Expires in: ${expiresInSeconds} seconds`);
-  const webAppUrl = getWebAppUrl();
+  const webAppUrl = getWebAppUrl(d);
   const authUrl = `${webAppUrl}/cli-auth?request=${requestId}`;
   console.log(`
 ${"─".repeat(50)}`);
@@ -9889,21 +9995,21 @@ If the browser doesn't open, visit this URL:`);
   ${authUrl}`);
   console.log(`
 ${"─".repeat(50)}`);
-  await openBrowser(authUrl);
+  await d.browser.open(authUrl);
   console.log(`
 ⏳ Waiting for authorization...`);
   console.log(`   (Press Ctrl+C to cancel)
 `);
   let pollCount = 0;
-  const maxPolls = Math.ceil((expiresAt - Date.now()) / AUTH_POLL_INTERVAL_MS);
+  const maxPolls = Math.ceil((expiresAt - d.clock.now()) / AUTH_POLL_INTERVAL_MS);
   const poll = async () => {
     pollCount++;
     try {
-      const status = await client2.query(api.cliAuth.getAuthRequestStatus, {
+      const status = await d.backend.query(api.cliAuth.getAuthRequestStatus, {
         requestId
       });
       if (status.status === "approved" && status.sessionId) {
-        saveAuthData({
+        d.auth.saveAuthData({
           sessionId: status.sessionId,
           createdAt: new Date().toISOString(),
           deviceName,
@@ -9914,45 +10020,48 @@ ${"═".repeat(50)}`);
         console.log(`✅ AUTHENTICATION SUCCESSFUL`);
         console.log(`${"═".repeat(50)}`);
         console.log(`
-Session stored at: ${getAuthFilePath()}`);
+Session stored at: ${d.auth.getAuthFilePath()}`);
         console.log(`
 You can now use chatroom commands.`);
-        return true;
+        return "done";
       }
       if (status.status === "denied") {
         console.log(`
 ❌ Authorization denied by user.`);
-        process.exit(1);
+        d.process.exit(1);
+        return "exit";
       }
       if (status.status === "expired" || status.status === "not_found") {
         console.log(`
 ❌ Authorization request expired.`);
         console.log(`   Please try again: chatroom auth login`);
-        process.exit(1);
+        d.process.exit(1);
+        return "exit";
       }
       if (pollCount % 5 === 0) {
-        const remainingSeconds = Math.round((expiresAt - Date.now()) / 1000);
-        process.stdout.write(`\r   Waiting... (${remainingSeconds}s remaining)   `);
+        const remainingSeconds = Math.round((expiresAt - d.clock.now()) / 1000);
+        d.process.stdoutWrite(`\r   Waiting... (${remainingSeconds}s remaining)   `);
       }
       if (pollCount >= maxPolls) {
         console.log(`
 ❌ Authorization request expired.`);
         console.log(`   Please try again: chatroom auth login`);
-        process.exit(1);
+        d.process.exit(1);
+        return "exit";
       }
-      return false;
+      return "continue";
     } catch (error) {
       const err = error;
       console.error(`
 ⚠️  Error polling for authorization: ${err.message}`);
-      return false;
+      return "continue";
     }
   };
   while (true) {
-    const success = await poll();
-    if (success)
+    const result2 = await poll();
+    if (result2 === "done" || result2 === "exit")
       break;
-    await new Promise((resolve) => setTimeout(resolve, AUTH_POLL_INTERVAL_MS));
+    await d.clock.delay(AUTH_POLL_INTERVAL_MS);
   }
 }
 var AUTH_POLL_INTERVAL_MS = 2000, PRODUCTION_CONVEX_URL2 = "https://chatroom-cloud.duskfare.com", PRODUCTION_WEBAPP_URL = "https://chatroom.duskfare.com";
@@ -9962,23 +10071,34 @@ var init_auth_login = __esm(() => {
   init_client2();
 });
 
-// src/commands/auth-logout.ts
+// src/commands/auth-logout/index.ts
 var exports_auth_logout = {};
 __export(exports_auth_logout, {
   authLogout: () => authLogout
 });
-async function authLogout() {
-  if (!isAuthenticated()) {
+function createDefaultDeps2() {
+  return {
+    session: {
+      isAuthenticated,
+      clearAuthData,
+      getAuthFilePath
+    }
+  };
+}
+async function authLogout(deps) {
+  const d = deps ?? createDefaultDeps2();
+  if (!d.session.isAuthenticated()) {
     console.log(`ℹ️  Not currently authenticated.`);
     return;
   }
-  const cleared = clearAuthData();
+  const cleared = d.session.clearAuthData();
   if (cleared) {
     console.log(`✅ Logged out successfully.`);
-    console.log(`   Removed: ${getAuthFilePath()}`);
+    console.log(`   Removed: ${d.session.getAuthFilePath()}`);
   } else {
     console.error(`❌ Failed to clear authentication data.`);
     process.exit(1);
+    return;
   }
 }
 var init_auth_logout = __esm(() => {
@@ -10117,8 +10237,7 @@ function createNewEndpointConfig() {
     registeredAt: now,
     lastSyncedAt: now,
     availableHarnesses,
-    harnessVersions: detectHarnessVersions(availableHarnesses),
-    chatroomAgents: {}
+    harnessVersions: detectHarnessVersions(availableHarnesses)
   };
 }
 function ensureMachineRegistered() {
@@ -10145,29 +10264,6 @@ function getMachineId() {
   const config = loadMachineConfig();
   return config?.machineId ?? null;
 }
-function updateAgentContext(chatroomId, role, agentType, workingDir) {
-  const config = loadMachineConfig();
-  if (!config) {
-    throw new Error("Machine not registered. Run ensureMachineRegistered() first.");
-  }
-  const now = new Date().toISOString();
-  if (!config.chatroomAgents[chatroomId]) {
-    config.chatroomAgents[chatroomId] = {};
-  }
-  config.chatroomAgents[chatroomId][role] = {
-    agentType,
-    workingDir,
-    lastStartedAt: now
-  };
-  saveMachineConfig(config);
-}
-function getAgentContext(chatroomId, role) {
-  const config = loadMachineConfig();
-  if (!config) {
-    return null;
-  }
-  return config.chatroomAgents[chatroomId]?.[role] ?? null;
-}
 var CHATROOM_DIR2, MACHINE_FILE = "machine.json";
 var init_storage2 = __esm(() => {
   init_detection();
@@ -10261,248 +10357,236 @@ var init_daemon_state = __esm(() => {
   STATE_DIR = join4(CHATROOM_DIR3, "machines", "state");
 });
 
+// src/infrastructure/machine/intentional-stops.ts
+function agentKey2(chatroomId, role) {
+  return `${chatroomId}:${role.toLowerCase()}`;
+}
+function markIntentionalStop(chatroomId, role) {
+  intentionalStops.add(agentKey2(chatroomId, role));
+}
+function consumeIntentionalStop(chatroomId, role) {
+  const key = agentKey2(chatroomId, role);
+  if (intentionalStops.has(key)) {
+    intentionalStops.delete(key);
+    return true;
+  }
+  return false;
+}
+function clearIntentionalStop(chatroomId, role) {
+  intentionalStops.delete(agentKey2(chatroomId, role));
+}
+var intentionalStops;
+var init_intentional_stops = __esm(() => {
+  intentionalStops = new Set;
+});
+
 // src/infrastructure/machine/index.ts
 var init_machine = __esm(() => {
   init_types();
   init_storage2();
   init_daemon_state();
+  init_intentional_stops();
 });
 
-// src/infrastructure/agent-drivers/process-driver.ts
-import { spawn } from "node:child_process";
-import { randomUUID as randomUUID2 } from "node:crypto";
-import { writeFileSync as writeFileSync4, unlinkSync as unlinkSync2 } from "node:fs";
-import { tmpdir } from "node:os";
-import { join as join5 } from "node:path";
-function writeTempPromptFile(prompt) {
-  const tempPath = join5(tmpdir(), `chatroom-prompt-${randomUUID2()}.txt`);
-  writeFileSync4(tempPath, prompt, { encoding: "utf-8", mode: 384 });
-  return tempPath;
-}
-function scheduleCleanup(filePath, delayMs = 5000) {
-  setTimeout(() => {
-    try {
-      unlinkSync2(filePath);
-    } catch {}
-  }, delayMs);
-}
-function buildCombinedPrompt(rolePrompt, initialMessage) {
-  return `${rolePrompt}
-
-${initialMessage}`;
+// src/infrastructure/services/remote-agents/opencode/opencode-agent-service.ts
+import { spawn, execSync as execSync2 } from "node:child_process";
+function defaultDeps() {
+  return {
+    execSync: execSync2,
+    spawn,
+    kill: (pid, signal) => process.kill(pid, signal)
+  };
 }
 
-class ProcessDriver {
-  async start(options) {
-    const config = this.buildSpawnConfig(options);
-    console.log(`   Spawning ${this.harness} agent...`);
-    console.log(`   Working dir: ${options.workingDir}`);
-    if (options.harnessVersion) {
-      console.log(`   Harness version: v${options.harnessVersion.version} (major: ${options.harnessVersion.major})`);
-    }
-    if (options.model) {
-      console.log(`   Model: ${options.model}`);
+class OpenCodeAgentService {
+  deps;
+  processes = new Map;
+  constructor(deps) {
+    this.deps = { ...defaultDeps(), ...deps };
+  }
+  isInstalled() {
+    try {
+      const checkCmd = process.platform === "win32" ? `where ${OPENCODE_COMMAND}` : `which ${OPENCODE_COMMAND}`;
+      this.deps.execSync(checkCmd, { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
     }
+  }
+  getVersion() {
     try {
-      const childProcess = spawn(config.command, config.args, {
-        cwd: options.workingDir,
-        stdio: config.stdio,
-        detached: true,
-        shell: false
-      });
-      if (config.writePromptToStdin && config.stdinPrompt) {
-        childProcess.stdin?.write(config.stdinPrompt);
-        childProcess.stdin?.end();
-      }
-      config.afterSpawn?.(childProcess);
-      childProcess.unref();
-      await new Promise((resolve) => setTimeout(resolve, 500));
-      if (childProcess.killed || childProcess.exitCode !== null) {
-        return {
-          success: false,
-          message: `Agent process exited immediately (exit code: ${childProcess.exitCode})`
-        };
-      }
-      const handle = {
-        harness: this.harness,
-        type: "process",
-        pid: childProcess.pid,
-        workingDir: options.workingDir
-      };
-      return {
-        success: true,
-        message: "Agent spawned successfully",
-        handle,
-        onExit: (callback) => {
-          childProcess.on("exit", (code2, signal) => {
-            callback(code2, signal);
-          });
-        }
-      };
-    } catch (error) {
+      const output = this.deps.execSync(`${OPENCODE_COMMAND} --version`, {
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 5000
+      }).toString().trim();
+      const match = output.match(/v?(\d+)\.(\d+)\.(\d+)/);
+      if (!match)
+        return null;
       return {
-        success: false,
-        message: `Failed to spawn agent: ${error.message}`
+        version: `${match[1]}.${match[2]}.${match[3]}`,
+        major: parseInt(match[1], 10)
       };
+    } catch {
+      return null;
+    }
+  }
+  async listModels() {
+    try {
+      const output = this.deps.execSync(`${OPENCODE_COMMAND} models`, {
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 1e4
+      }).toString().trim();
+      if (!output)
+        return [];
+      return output.split(`
+`).map((line) => line.trim()).filter((line) => line.length > 0);
+    } catch {
+      return [];
     }
   }
-  async stop(handle) {
-    if (handle.type !== "process" || !handle.pid) {
-      throw new Error(`Cannot stop: handle has no PID (type=${handle.type})`);
+  async spawn(options) {
+    const args = ["run"];
+    if (options.model) {
+      args.push("--model", options.model);
+    }
+    const childProcess = this.deps.spawn(OPENCODE_COMMAND, args, {
+      cwd: options.workingDir,
+      stdio: ["pipe", "pipe", "pipe"],
+      shell: false,
+      detached: true
+    });
+    childProcess.stdin?.write(options.prompt);
+    childProcess.stdin?.end();
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    if (childProcess.killed || childProcess.exitCode !== null) {
+      throw new Error(`Agent process exited immediately (exit code: ${childProcess.exitCode})`);
+    }
+    if (!childProcess.pid) {
+      throw new Error("Agent process started but has no PID");
+    }
+    const pid = childProcess.pid;
+    const context = options.context;
+    const entry = { context, lastOutputAt: Date.now() };
+    this.processes.set(pid, entry);
+    const outputCallbacks = [];
+    if (childProcess.stdout) {
+      childProcess.stdout.pipe(process.stdout, { end: false });
+      childProcess.stdout.on("data", () => {
+        entry.lastOutputAt = Date.now();
+        for (const cb of outputCallbacks)
+          cb();
+      });
+    }
+    if (childProcess.stderr) {
+      childProcess.stderr.pipe(process.stderr, { end: false });
+      childProcess.stderr.on("data", () => {
+        entry.lastOutputAt = Date.now();
+        for (const cb of outputCallbacks)
+          cb();
+      });
     }
-    const pid = handle.pid;
+    return {
+      pid,
+      onExit: (cb) => {
+        childProcess.on("exit", (code2, signal) => {
+          this.processes.delete(pid);
+          cb({ code: code2, signal, context });
+        });
+      },
+      onOutput: (cb) => {
+        outputCallbacks.push(cb);
+      }
+    };
+  }
+  async stop(pid) {
     try {
-      process.kill(pid, "SIGTERM");
+      this.deps.kill(-pid, "SIGTERM");
     } catch {
       return;
     }
-    const KILL_TIMEOUT_MS = 5000;
-    const POLL_INTERVAL_MS = 200;
     const deadline = Date.now() + KILL_TIMEOUT_MS;
     while (Date.now() < deadline) {
       try {
-        process.kill(pid, 0);
+        this.deps.kill(pid, 0);
       } catch {
         return;
       }
       await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
     }
     try {
-      process.kill(pid, "SIGKILL");
+      this.deps.kill(-pid, "SIGKILL");
     } catch {}
   }
-  async isAlive(handle) {
-    if (handle.type !== "process" || !handle.pid) {
-      return false;
-    }
+  isAlive(pid) {
     try {
-      process.kill(handle.pid, 0);
+      this.deps.kill(pid, 0);
       return true;
     } catch {
       return false;
     }
   }
-  async recover(_workingDir) {
-    return [];
-  }
-  async listModels() {
-    return [];
-  }
-}
-var init_process_driver = () => {};
-
-// src/infrastructure/agent-drivers/opencode-process-driver.ts
-import { execSync as execSync2 } from "node:child_process";
-var OpenCodeProcessDriver;
-var init_opencode_process_driver = __esm(() => {
-  init_process_driver();
-  init_types();
-  OpenCodeProcessDriver = class OpenCodeProcessDriver extends ProcessDriver {
-    harness = "opencode";
-    capabilities = {
-      sessionPersistence: false,
-      abort: false,
-      modelSelection: true,
-      compaction: false,
-      eventStreaming: false,
-      messageInjection: false,
-      dynamicModelDiscovery: true
-    };
-    buildSpawnConfig(options) {
-      const command = AGENT_HARNESS_COMMANDS[this.harness];
-      const combinedPrompt = buildCombinedPrompt(options.rolePrompt, options.initialMessage);
-      const args = ["run"];
-      if (options.model) {
-        args.push("--model", options.model);
-      }
-      return {
-        command,
-        args,
-        stdio: ["pipe", "inherit", "inherit"],
-        writePromptToStdin: true,
-        stdinPrompt: combinedPrompt
-      };
-    }
-    async listModels() {
-      try {
-        const output = execSync2("opencode models", {
-          stdio: ["pipe", "pipe", "pipe"],
-          timeout: 1e4
-        }).toString().trim();
-        if (!output)
-          return [];
-        return output.split(`
-`).map((line) => line.trim()).filter((line) => line.length > 0);
-      } catch {
-        return [];
-      }
-    }
-  };
-});
-
-// src/infrastructure/agent-drivers/registry.ts
-class DefaultDriverRegistry {
-  drivers;
-  constructor(drivers) {
-    this.drivers = new Map;
-    for (const driver of drivers) {
-      this.drivers.set(driver.harness, driver);
-    }
-  }
-  get(harness) {
-    const driver = this.drivers.get(harness);
-    if (!driver) {
-      throw new Error(`No driver registered for harness: ${harness}`);
-    }
-    return driver;
-  }
-  all() {
-    return Array.from(this.drivers.values());
-  }
-  capabilities(harness) {
-    return this.get(harness).capabilities;
+  getTrackedProcesses() {
+    return Array.from(this.processes.entries()).map(([pid, entry]) => ({
+      pid,
+      context: entry.context,
+      lastOutputAt: entry.lastOutputAt
+    }));
   }
-}
-function getDriverRegistry() {
-  if (!registryInstance) {
-    registryInstance = new DefaultDriverRegistry([new OpenCodeProcessDriver]);
+  untrack(pid) {
+    this.processes.delete(pid);
   }
-  return registryInstance;
 }
-var registryInstance = null;
-var init_registry = __esm(() => {
-  init_opencode_process_driver();
-});
+var OPENCODE_COMMAND = "opencode", KILL_TIMEOUT_MS = 5000, POLL_INTERVAL_MS = 200;
+var init_opencode_agent_service = () => {};
 
-// src/infrastructure/agent-drivers/index.ts
-var exports_agent_drivers = {};
-__export(exports_agent_drivers, {
-  writeTempPromptFile: () => writeTempPromptFile,
-  scheduleCleanup: () => scheduleCleanup,
-  getDriverRegistry: () => getDriverRegistry,
-  buildCombinedPrompt: () => buildCombinedPrompt,
-  ProcessDriver: () => ProcessDriver,
-  OpenCodeProcessDriver: () => OpenCodeProcessDriver
+// src/infrastructure/services/remote-agents/opencode/index.ts
+var exports_opencode = {};
+__export(exports_opencode, {
+  OpenCodeAgentService: () => OpenCodeAgentService
 });
-var init_agent_drivers = __esm(() => {
-  init_registry();
-  init_process_driver();
-  init_process_driver();
-  init_opencode_process_driver();
+var init_opencode = __esm(() => {
+  init_opencode_agent_service();
 });
 
-// src/commands/auth-status.ts
+// src/commands/auth-status/index.ts
 var exports_auth_status = {};
 __export(exports_auth_status, {
   authStatus: () => authStatus
 });
-async function authStatus() {
+async function listAvailableModelsDefault() {
+  try {
+    const { OpenCodeAgentService: OpenCodeAgentService2 } = await Promise.resolve().then(() => (init_opencode(), exports_opencode));
+    const agentService = new OpenCodeAgentService2;
+    return await agentService.listModels();
+  } catch {
+    return [];
+  }
+}
+async function createDefaultDeps3() {
+  const client2 = await getConvexClient();
+  return {
+    backend: {
+      mutation: (endpoint, args) => client2.mutation(endpoint, args),
+      query: (endpoint, args) => client2.query(endpoint, args)
+    },
+    session: {
+      loadAuthData,
+      getAuthFilePath,
+      isAuthenticated
+    },
+    getVersion,
+    ensureMachineRegistered,
+    listAvailableModels: listAvailableModelsDefault
+  };
+}
+async function authStatus(deps) {
+  const d = deps ?? await createDefaultDeps3();
   console.log(`
 ${"═".repeat(50)}`);
   console.log(`\uD83D\uDD10 AUTHENTICATION STATUS`);
   console.log(`${"═".repeat(50)}`);
-  const authData = loadAuthData();
-  if (!isAuthenticated() || !authData) {
+  const authData = d.session.loadAuthData();
+  if (!d.session.isAuthenticated() || !authData) {
     console.log(`
 ❌ Not authenticated`);
     console.log(`
@@ -10510,17 +10594,16 @@ ${"═".repeat(50)}`);
     return;
   }
   console.log(`
-\uD83D\uDCC1 Auth file: ${getAuthFilePath()}`);
+\uD83D\uDCC1 Auth file: ${d.session.getAuthFilePath()}`);
   console.log(`\uD83D\uDCC5 Created: ${authData.createdAt}`);
   if (authData.deviceName) {
     console.log(`\uD83D\uDCBB Device: ${authData.deviceName}`);
   }
-  console.log(`\uD83D\uDCE6 CLI Version: ${getVersion()}`);
+  console.log(`\uD83D\uDCE6 CLI Version: ${d.getVersion()}`);
   console.log(`
 ⏳ Validating session...`);
   try {
-    const client2 = await getConvexClient();
-    const validation = await client2.query(api.cliAuth.validateSession, {
+    const validation = await d.backend.query(api.cliAuth.validateSession, {
       sessionId: authData.sessionId
     });
     if (validation.valid) {
@@ -10530,19 +10613,9 @@ ${"═".repeat(50)}`);
         console.log(`\uD83D\uDC64 User: ${validation.userName}`);
       }
       try {
-        const machineInfo = ensureMachineRegistered();
-        let availableModels = [];
-        try {
-          const { getDriverRegistry: getDriverRegistry2 } = await Promise.resolve().then(() => (init_agent_drivers(), exports_agent_drivers));
-          const registry = getDriverRegistry2();
-          for (const driver of registry.all()) {
-            if (driver.capabilities.dynamicModelDiscovery) {
-              const models = await driver.listModels();
-              availableModels = availableModels.concat(models);
-            }
-          }
-        } catch {}
-        await client2.mutation(api.machines.register, {
+        const machineInfo = d.ensureMachineRegistered();
+        const availableModels = await d.listAvailableModels();
+        await d.backend.mutation(api.machines.register, {
           sessionId: authData.sessionId,
           machineId: machineInfo.machineId,
           hostname: machineInfo.hostname,
@@ -10586,47 +10659,46 @@ var init_auth_status = __esm(() => {
   init_version();
 });
 
-// src/commands/update.ts
+// src/commands/update/index.ts
 var exports_update = {};
 __export(exports_update, {
   update: () => update
 });
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
-function getCurrentVersion() {
-  return getVersion();
-}
-async function isNpmAvailable() {
-  try {
-    await execAsync("npm --version");
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function getLatestVersion() {
-  try {
-    const { stdout } = await execAsync("npm view chatroom-cli version");
-    return stdout.trim();
-  } catch {
-    return null;
-  }
+function createDefaultDeps4() {
+  return {
+    getVersion,
+    exec: (cmd) => execAsync(cmd).then((r) => ({ stdout: r.stdout ?? "", stderr: r.stderr }))
+  };
 }
-async function update() {
+async function update(deps) {
+  const d = deps ?? createDefaultDeps4();
+  const log = console.log.bind(console);
   log(`
 \uD83D\uDD04 Checking for updates...
 `);
-  if (!await isNpmAvailable()) {
+  try {
+    await d.exec("npm --version");
+  } catch {
     console.error("❌ npm is not available. Please install npm to update.");
     process.exit(1);
+    return;
   }
-  const currentVersion = getCurrentVersion();
+  const currentVersion = d.getVersion();
   log(`   Current version: ${currentVersion}`);
-  const latestVersion = await getLatestVersion();
+  let latestVersion = null;
+  try {
+    const { stdout } = await d.exec("npm view chatroom-cli version");
+    latestVersion = stdout.trim() || null;
+  } catch {
+    latestVersion = null;
+  }
   if (!latestVersion) {
     console.error("❌ Could not check for latest version.");
     console.error("   You can manually update with: npm install -g chatroom-cli@latest");
     process.exit(1);
+    return;
   }
   log(`   Latest version:  ${latestVersion}`);
   if (currentVersion === latestVersion) {
@@ -10638,7 +10710,7 @@ async function update() {
 \uD83D\uDCE6 Updating to latest version...
 `);
   try {
-    const { stdout } = await execAsync("npm install -g chatroom-cli@latest");
+    const { stdout } = await d.exec("npm install -g chatroom-cli@latest");
     if (stdout) {
       log(stdout);
     }
@@ -10653,52 +10725,231 @@ async function update() {
    Try running manually with sudo:`);
     console.error("   sudo npm install -g chatroom-cli@latest");
     process.exit(1);
+    return;
   }
 }
-var execAsync, log;
+var execAsync;
 var init_update = __esm(() => {
   init_version();
   execAsync = promisify(exec);
-  log = console.log.bind(console);
 });
 
-// src/commands/register-agent.ts
-var exports_register_agent = {};
-__export(exports_register_agent, {
-  registerAgent: () => registerAgent
+// src/commands/init/index.ts
+var exports_init = {};
+__export(exports_init, {
+  init: () => init
 });
-async function registerAgent(chatroomId, options) {
-  const client2 = await getConvexClient();
-  const { role, type } = options;
-  const sessionId = getSessionId();
-  if (!sessionId) {
-    const otherUrls = getOtherSessionUrls();
-    const currentUrl = getConvexUrl();
-    console.error(`❌ Not authenticated for: ${currentUrl}`);
-    if (otherUrls.length > 0) {
-      console.error(`
-\uD83D\uDCA1 You have sessions for other environments:`);
-      for (const url of otherUrls) {
-        console.error(`   • ${url}`);
+import path from "path";
+async function createDefaultDeps5() {
+  const fs = await import("fs/promises");
+  return {
+    fs: {
+      access: async (p) => {
+        await fs.access(p);
+      },
+      readFile: async (p, encoding) => {
+        return fs.readFile(p, encoding);
+      },
+      writeFile: async (p, content, encoding) => {
+        await fs.writeFile(p, content, encoding);
       }
-      console.error(`
-   To use a different environment, set CHATROOM_CONVEX_URL:`);
-      console.error(`   CHATROOM_CONVEX_URL=${otherUrls[0]} chatroom register-agent ...`);
-      console.error(`
-   Or to authenticate for the current environment:`);
     }
-    console.error(`   chatroom auth login`);
-    process.exit(1);
-  }
-  if (!chatroomId || typeof chatroomId !== "string" || chatroomId.length < 20 || chatroomId.length > 40) {
-    console.error(`❌ Invalid chatroom ID format: ID must be 20-40 characters (got ${chatroomId?.length || 0})`);
-    process.exit(1);
+  };
+}
+async function fileExists(fsOps, filePath) {
+  try {
+    await fsOps.access(filePath);
+    return true;
+  } catch {
+    return false;
   }
-  if (!/^[a-zA-Z0-9_]+$/.test(chatroomId)) {
+}
+function hasIntegrationSection(content) {
+  return content.includes("<chatroom>");
+}
+function replaceIntegrationSection(content, newSection) {
+  const start = content.indexOf("<chatroom>");
+  const end = content.indexOf("</chatroom>");
+  if (start === -1 || end === -1) {
+    return content + `
+
+` + newSection;
+  }
+  const before = content.slice(0, start).replace(/\s+$/, "");
+  return before + `
+
+` + newSection;
+}
+async function init(options = {}, deps) {
+  const d = deps ?? await createDefaultDeps5();
+  const targetDir = options.dir ?? process.cwd();
+  const result = {
+    filesModified: [],
+    filesSkipped: [],
+    filesCreated: []
+  };
+  const foundFiles = [];
+  for (const filename of SUPPORTED_FILES) {
+    const filePath = path.join(targetDir, filename);
+    if (await fileExists(d.fs, filePath)) {
+      foundFiles.push(filename);
+    }
+  }
+  if (foundFiles.length === 0) {
+    const agentsPath = path.join(targetDir, "AGENTS.md");
+    try {
+      await d.fs.writeFile(agentsPath, SECTION_6_TEXT, "utf-8");
+      result.filesCreated.push("AGENTS.md");
+      console.log("✅ Created AGENTS.md with CHATROOM INTEGRATION section");
+    } catch (err) {
+      console.error(`❌ Failed to create AGENTS.md: ${err}`);
+    }
+  } else {
+    for (const filename of foundFiles) {
+      const filePath = path.join(targetDir, filename);
+      let content;
+      try {
+        content = await d.fs.readFile(filePath, "utf-8");
+      } catch (err) {
+        console.error(`❌ Failed to read ${filename}: ${err}`);
+        continue;
+      }
+      if (hasIntegrationSection(content)) {
+        try {
+          const updatedContent = replaceIntegrationSection(content, SECTION_6_TEXT);
+          await d.fs.writeFile(filePath, updatedContent, "utf-8");
+          result.filesModified.push(filename);
+          console.log(`✅ Updated CHATROOM INTEGRATION section in ${filename}`);
+        } catch (err) {
+          console.error(`❌ Failed to update ${filename}: ${err}`);
+        }
+      } else {
+        try {
+          const appendText = `
+
+---
+
+` + SECTION_6_TEXT;
+          await d.fs.writeFile(filePath, content + appendText, "utf-8");
+          result.filesModified.push(filename);
+          console.log(`✅ Added CHATROOM INTEGRATION section to ${filename}`);
+        } catch (err) {
+          console.error(`❌ Failed to update ${filename}: ${err}`);
+        }
+      }
+    }
+  }
+  console.log("");
+  console.log("Summary:");
+  if (result.filesCreated.length > 0) {
+    console.log(`  Created : ${result.filesCreated.join(", ")}`);
+  }
+  if (result.filesModified.length > 0) {
+    console.log(`  Updated : ${result.filesModified.join(", ")}`);
+  }
+  if (result.filesSkipped.length > 0) {
+    console.log(`  Skipped : ${result.filesSkipped.join(", ")} (already has integration section)`);
+  }
+  const totalActions = result.filesCreated.length + result.filesModified.length + result.filesSkipped.length;
+  if (totalActions === 0) {
+    console.log("  Nothing to do.");
+  }
+  return result;
+}
+var SUPPORTED_FILES, SECTION_6_TEXT = `<chatroom>
+## CHATROOM INTEGRATION
+
+### Workflow Loop
+
+\`\`\`
+get-next-task → do work → handoff → get-next-task → repeat
+\`\`\`
+
+1. **Run \`get-next-task\`** immediately via \`bash\` — block until task arrives
+2. **Process** the task
+3. **Run \`handoff\`** to signal completion
+4. **Run \`get-next-task\`** again to wait for next task
+
+### Reliability
+
+Always add these as the **last two todo items** for every task:
+
+1. **Handoff item** — contains the full handoff command (see Command Reference)
+2. **Get-next-task item** — contains the full get-next-task command (see Command Reference)
+
+This ensures you never forget to pass control back — just copy the command from the todo item and run it via \`bash\`.
+
+### Command Reference
+
+| Action | Command |
+|--------|---------|
+| Fetch next task | \`CHATROOM_CONVEX_URL=<endpoint> chatroom get-next-task --chatroom-id=<id> --role=<role>\` |
+| Pass control | \`CHATROOM_CONVEX_URL=<endpoint> chatroom handoff --chatroom-id=<id> --role=<role> --next-role=<role>\` |
+| Refresh system prompt (after compaction) | \`CHATROOM_CONVEX_URL=<endpoint> chatroom get-system-prompt --chatroom-id=<id> --role=<role>\` |
+
+### Context Recovery
+
+If you suspect compaction (context starts with "Summary of:", or you're unsure of your role):
+
+1. Run \`get-system-prompt\` to reload full instructions
+2. Check todo list for last known step
+3. Resume with \`get-next-task\` or \`handoff\`
+</chatroom>`;
+var init_init = __esm(() => {
+  SUPPORTED_FILES = ["AGENTS.md", "CLAUDE.md"];
+});
+
+// src/commands/register-agent/index.ts
+var exports_register_agent = {};
+__export(exports_register_agent, {
+  registerAgent: () => registerAgent
+});
+async function createDefaultDeps6() {
+  const client2 = await getConvexClient();
+  return {
+    backend: {
+      mutation: (endpoint, args) => client2.mutation(endpoint, args),
+      query: (endpoint, args) => client2.query(endpoint, args)
+    },
+    session: {
+      getSessionId,
+      getConvexUrl,
+      getOtherSessionUrls
+    }
+  };
+}
+async function registerAgent(chatroomId, options, deps) {
+  const d = deps ?? await createDefaultDeps6();
+  const { role, type } = options;
+  const sessionId = d.session.getSessionId();
+  if (!sessionId) {
+    const otherUrls = d.session.getOtherSessionUrls();
+    const currentUrl = d.session.getConvexUrl();
+    console.error(`❌ Not authenticated for: ${currentUrl}`);
+    if (otherUrls.length > 0) {
+      console.error(`
+\uD83D\uDCA1 You have sessions for other environments:`);
+      for (const url of otherUrls) {
+        console.error(`   • ${url}`);
+      }
+      console.error(`
+   To use a different environment, set CHATROOM_CONVEX_URL:`);
+      console.error(`   CHATROOM_CONVEX_URL=${otherUrls[0]} chatroom register-agent ...`);
+      console.error(`
+   Or to authenticate for the current environment:`);
+    }
+    console.error(`   chatroom auth login`);
+    process.exit(1);
+  }
+  if (!chatroomId || typeof chatroomId !== "string" || chatroomId.length < 20 || chatroomId.length > 40) {
+    console.error(`❌ Invalid chatroom ID format: ID must be 20-40 characters (got ${chatroomId?.length || 0})`);
+    process.exit(1);
+  }
+  if (!/^[a-zA-Z0-9_]+$/.test(chatroomId)) {
     console.error(`❌ Invalid chatroom ID format: ID must contain only alphanumeric characters and underscores`);
     process.exit(1);
   }
-  const chatroom = await client2.query(api.chatrooms.get, {
+  const chatroom = await d.backend.query(api.chatrooms.get, {
     sessionId,
     chatroomId
   });
@@ -10711,15 +10962,10 @@ async function registerAgent(chatroomId, options) {
       const machineInfo = ensureMachineRegistered();
       let availableModels = [];
       try {
-        const registry = getDriverRegistry();
-        for (const driver of registry.all()) {
-          if (driver.capabilities.dynamicModelDiscovery) {
-            const models = await driver.listModels();
-            availableModels = availableModels.concat(models);
-          }
-        }
+        const agentService = new OpenCodeAgentService;
+        availableModels = await agentService.listModels();
       } catch {}
-      await client2.mutation(api.machines.register, {
+      await d.backend.mutation(api.machines.register, {
         sessionId,
         machineId: machineInfo.machineId,
         hostname: machineInfo.hostname,
@@ -10729,7 +10975,7 @@ async function registerAgent(chatroomId, options) {
         availableModels
       });
       const agentHarness = machineInfo.availableHarnesses.length > 0 ? machineInfo.availableHarnesses[0] : undefined;
-      await client2.mutation(api.machines.saveTeamAgentConfig, {
+      await d.backend.mutation(api.machines.saveTeamAgentConfig, {
         sessionId,
         chatroomId,
         role,
@@ -10750,7 +10996,7 @@ async function registerAgent(chatroomId, options) {
     }
   } else {
     try {
-      await client2.mutation(api.machines.saveTeamAgentConfig, {
+      await d.backend.mutation(api.machines.saveTeamAgentConfig, {
         sessionId,
         chatroomId,
         role,
@@ -10765,14 +11011,11 @@ async function registerAgent(chatroomId, options) {
 }
 var init_register_agent = __esm(() => {
   init_api3();
-  init_agent_drivers();
   init_storage();
   init_client2();
   init_machine();
+  init_opencode();
 });
-
-// ../../services/backend/config/reliability.ts
-var HEARTBEAT_INTERVAL_MS = 30000, HEARTBEAT_TTL_MS = 90000, DAEMON_HEARTBEAT_INTERVAL_MS = 30000;
 // ../../services/backend/prompts/base/cli/task-started/command.ts
 function taskStartedCommand(params) {
   const prefix = params.cliEnvPrefix || "";
@@ -10780,7 +11023,7 @@ function taskStartedCommand(params) {
   const role = params.role || "<role>";
   const taskId = params.taskId || "<task-id>";
   const classification = params.classification || "<question|new_feature|follow_up>";
-  const baseCmd = `${prefix}chatroom task-started --chatroom-id=${chatroomId} --role=${role} --task-id=${taskId} --origin-message-classification=${classification}`;
+  const baseCmd = `${prefix}chatroom task-started --chatroom-id="${chatroomId}" --role="${role}" --task-id="${taskId}" --origin-message-classification=${classification}`;
   if (params.classification === "new_feature" || classification === "new_feature") {
     const title = params.title || "[Feature title]";
     const description = params.description || "[Feature description]";
@@ -10812,13 +11055,13 @@ var init_task_started = __esm(() => {
   init_main_prompt();
 });
 
-// ../../services/backend/prompts/base/cli/wait-for-task/reminder.ts
-function getWaitForTaskGuidance() {
+// ../../services/backend/prompts/base/cli/get-next-task/reminder.ts
+function getNextTaskGuidance() {
   return `\uD83D\uDD17 STAYING CONNECTED TO YOUR TEAM
 
 Your primary directive: Stay available to respond to user and team requests.
 
-⚠️  CRITICAL: Run wait-for-task in the FOREGROUND
+⚠️  CRITICAL: Run get-next-task in the FOREGROUND
 
 Two requirements:
 
@@ -10831,16 +11074,27 @@ Two requirements:
    • Only proceed after the command exits (signal or task received)
 
 ⚠️  WHEN THE PROCESS IS TERMINATED OR TIMED OUT
-• Your harness may kill long-running commands after a set duration
-• When the command terminates unexpectedly:
-  1. Do you have urgent pending work?
-  2. Without wait-for-task, your team cannot reach you
-  3. If no urgent work, reconnect immediately
+
+\`\`\`
+@startuml
+start
+:Command terminated unexpectedly;
+if (Urgent pending work?) then (yes)
+  :Finish urgent work;
+  :Reconnect with get-next-task;
+else (no)
+  :Reconnect immediately;
+  note right: Team cannot reach you without it
+endif
+stop
+@enduml
+\`\`\`
 
 \uD83D\uDCCB BACKLOG TASKS
   chatroom backlog list --chatroom-id=<chatroomId> --role=<role> --status=backlog
   chatroom backlog --help`;
 }
+var init_reminder = () => {};
 // ../../services/backend/prompts/config/index.ts
 class PromptConfigImpl {
   getConvexURL() {
@@ -10893,30 +11147,262 @@ var init_getting_started_content = __esm(() => {
 // ../../services/backend/prompts/base/cli/index.ts
 var init_cli = __esm(() => {
   init_task_started();
+  init_reminder();
   init_getting_started_content();
 });
 
-// ../../services/backend/prompts/base/cli/wait-for-task/command.ts
-function waitForTaskCommand(params) {
+// ../../services/backend/config/errorCodes.ts
+var BACKEND_ERROR_CODES, FATAL_ERROR_CODES;
+var init_errorCodes = __esm(() => {
+  BACKEND_ERROR_CODES = {
+    PARTICIPANT_NOT_FOUND: "PARTICIPANT_NOT_FOUND",
+    CHATROOM_NOT_FOUND: "CHATROOM_NOT_FOUND",
+    SESSION_INVALID: "SESSION_INVALID"
+  };
+  FATAL_ERROR_CODES = [
+    BACKEND_ERROR_CODES.PARTICIPANT_NOT_FOUND,
+    BACKEND_ERROR_CODES.CHATROOM_NOT_FOUND,
+    BACKEND_ERROR_CODES.SESSION_INVALID
+  ];
+});
+
+// ../../services/backend/prompts/base/cli/get-next-task/command.ts
+function getNextTaskCommand(params) {
   const prefix = params.cliEnvPrefix || "";
   const chatroomId = params.chatroomId || "<chatroom-id>";
   const role = params.role || "<role>";
-  return `${prefix}chatroom wait-for-task --chatroom-id=${chatroomId} --role=${role}`;
-}
+  return `${prefix}chatroom get-next-task --chatroom-id="${chatroomId}" --role="${role}"`;
+}
+var init_command = () => {};
+
+// src/commands/get-next-task/session.ts
+class GetNextTaskSession {
+  unsubscribe = null;
+  cleanedUp = false;
+  taskProcessed = false;
+  fatalExitTriggered = false;
+  chatroomId;
+  role;
+  silent;
+  sessionId;
+  connectionId;
+  cliEnvPrefix;
+  client;
+  constructor(params) {
+    this.chatroomId = params.chatroomId;
+    this.role = params.role;
+    this.silent = params.silent;
+    this.sessionId = params.sessionId;
+    this.connectionId = params.connectionId;
+    this.cliEnvPrefix = params.cliEnvPrefix;
+    this.client = params.client;
+  }
+  async start() {
+    this.registerSignalHandlers();
+    await this.subscribe();
+  }
+  logAndExit(exitCode, event, message, guidance) {
+    const timestamp = new Date().toISOString().replace("T", " ").substring(0, 19);
+    const safeEvent = sanitizeForTerminal(event);
+    const safeMessage = sanitizeForTerminal(message);
+    const safeGuidance = sanitizeForTerminal(guidance);
+    console.log(`
+${"─".repeat(50)}`);
+    console.log(`[EVENT: ${safeEvent}]
+`);
+    console.log(`[${timestamp}] ${safeMessage}
+`);
+    if (safeGuidance) {
+      console.log(safeGuidance);
+    }
+    console.log(`
+To reconnect, run:`);
+    console.log(getNextTaskCommand({
+      chatroomId: this.chatroomId,
+      role: this.role,
+      cliEnvPrefix: this.cliEnvPrefix
+    }));
+    console.log(`${"─".repeat(50)}`);
+    this.cleanup();
+    process.exit(exitCode);
+  }
+  async cleanup() {
+    if (this.cleanedUp)
+      return;
+    this.cleanedUp = true;
+    if (this.unsubscribe) {
+      this.unsubscribe();
+    }
+    try {
+      await this.client.mutation(api.participants.join, {
+        sessionId: this.sessionId,
+        chatroomId: this.chatroomId,
+        role: this.role,
+        action: "get-next-task:stopped"
+      });
+    } catch {}
+    try {
+      await this.client.mutation(api.participants.leave, {
+        sessionId: this.sessionId,
+        chatroomId: this.chatroomId,
+        role: this.role
+      });
+    } catch {}
+  }
+  async subscribe() {
+    const wsClient2 = await getConvexWsClient();
+    this.unsubscribe = wsClient2.onUpdate(api.tasks.getPendingTasksForRole, {
+      sessionId: this.sessionId,
+      chatroomId: this.chatroomId,
+      role: this.role,
+      connectionId: this.connectionId
+    }, (response) => {
+      this.handleSubscriptionResponse(response).catch((error) => {
+        console.error(`❌ Error processing task: ${error.message}`);
+      });
+    }, (error) => {
+      this.handleSubscriptionError(error, "task subscription");
+    });
+  }
+  async handleSubscriptionResponse(response) {
+    if (this.taskProcessed)
+      return;
+    switch (response.type) {
+      case "no_tasks":
+        return;
+      case "superseded":
+        this.handleSuperseded();
+        return;
+      case "grace_period":
+        this.handleGracePeriod(response);
+        return;
+      case "error":
+        this.handleError(response);
+        return;
+      case "reconnect":
+        this.handleReconnect(response);
+        return;
+      case "tasks":
+        await this.handleTasks(response);
+        return;
+    }
+  }
+  handleSuperseded() {
+    this.logAndExit(0, "superseded", "Another get-next-task process started for this role.", `Impact: This process is being replaced by the newer connection.
+` + "Action: This is expected if you started a new get-next-task session.");
+  }
+  handleGracePeriod(response) {
+    const remainingSec = Math.ceil(response.remainingMs / 1000);
+    this.logAndExit(0, "grace_period", `Task ${response.taskId} was recently acknowledged (${remainingSec}s grace remaining).`, `Impact: Another agent may still be processing this task.
+` + "Action: Wait for the grace period to expire, then reconnect.");
+  }
+  handleReconnect(response) {
+    this.logAndExit(0, "reconnect", `Backend requested reconnect: ${response.reason}`, "Action: Reconnect to resume listening for tasks.");
+  }
+  handleError(response) {
+    if (response.fatal) {
+      if (this.fatalExitTriggered)
+        return;
+      this.fatalExitTriggered = true;
+      this.logAndExit(1, "error (fatal)", `❌ FATAL ERROR — [${response.code}] ${response.message}`, "This is an unrecoverable error. The process will now exit.");
+    }
+    this.logAndExit(0, "error (non-fatal)", `⚠️ Non-fatal error: [${response.code}] ${response.message}`, "Action: Reconnect to resume listening for tasks.");
+  }
+  handleSubscriptionError(error, source) {
+    if (error instanceof ConvexError) {
+      const data = error.data;
+      if (data?.code && FATAL_ERROR_CODES.includes(data.code)) {
+        if (this.fatalExitTriggered)
+          return;
+        this.fatalExitTriggered = true;
+        this.logAndExit(1, "subscription_error (fatal)", `❌ FATAL ERROR in ${source} — [${data.code}] ${data.message}`, "This is an unrecoverable error. The process will now exit.");
+        return;
+      }
+      this.logAndExit(0, "subscription_error (non-fatal)", `⚠️ Non-fatal error in ${source}: [${data?.code}] ${data?.message ?? error.message}`, "Action: Reconnect to resume listening for tasks.");
+      return;
+    }
+    this.logAndExit(0, "subscription_error (transient)", `⚠️ Transient error in ${source}: ${error.message}`, "Action: Reconnect to resume listening for tasks.");
+  }
+  async handleTasks(response) {
+    const pendingTasks = response.tasks;
+    const taskWithMessage = pendingTasks.length > 0 ? pendingTasks[0] : null;
+    if (!taskWithMessage) {
+      return;
+    }
+    const { task, message } = taskWithMessage;
+    if (task.status === "pending") {
+      try {
+        await this.client.mutation(api.tasks.claimTask, {
+          sessionId: this.sessionId,
+          chatroomId: this.chatroomId,
+          role: this.role,
+          taskId: task._id
+        });
+      } catch (_claimError) {
+        console.log(`\uD83D\uDD04 Task already claimed by another agent, continuing to wait...`);
+        return;
+      }
+    }
+    this.taskProcessed = true;
+    if (this.unsubscribe)
+      this.unsubscribe();
+    this.cleanedUp = true;
+    try {
+      if (message) {
+        await this.client.mutation(api.messages.claimMessage, {
+          sessionId: this.sessionId,
+          messageId: message._id,
+          role: this.role
+        });
+      }
+      const taskDeliveryPrompt = await this.client.query(api.messages.getTaskDeliveryPrompt, {
+        sessionId: this.sessionId,
+        chatroomId: this.chatroomId,
+        role: this.role,
+        taskId: task._id,
+        messageId: message?._id,
+        convexUrl: getConvexUrl()
+      });
+      const taskReceivedTime = new Date().toISOString().replace("T", " ").substring(0, 19);
+      console.log(`
+[${taskReceivedTime}] \uD83D\uDCE8 Task received!
+`);
+      console.log(sanitizeForTerminal(taskDeliveryPrompt.fullCliOutput));
+      process.exit(0);
+    } catch (deliveryError) {
+      this.logAndExit(1, "task_delivery_failed", `⚠️ TASK CLAIMED BUT DELIVERY FAILED — ${sanitizeUnknownForTerminal(deliveryError.message)}`, `Task ID: ${task._id}
+` + `The task has been claimed for your role.
+` + `Use context read to see your current task:
 
-// src/config.ts
-var DEFAULT_ACTIVE_TIMEOUT_MS, WEB_SERVER_PORT;
-var init_config2 = __esm(() => {
-  DEFAULT_ACTIVE_TIMEOUT_MS = 60 * 60 * 1000;
-  WEB_SERVER_PORT = parseInt(process.env.WEB_PORT || "3456", 10);
+` + `   ${this.cliEnvPrefix} chatroom context read --chatroom-id=${this.chatroomId} --role=${this.role}`);
+    }
+  }
+  registerSignalHandlers() {
+    const handleSignal = (_signal) => {
+      this.logAndExit(0, `signal (${_signal})`, `Process interrupted (${_signal}).`, `Impact: You are no longer listening for tasks.
+` + "Action: Run the reconnect command immediately to resume availability.");
+    };
+    process.on("SIGINT", () => handleSignal("SIGINT"));
+    process.on("SIGTERM", () => handleSignal("SIGTERM"));
+    process.on("SIGHUP", () => handleSignal("SIGHUP"));
+  }
+}
+var init_session = __esm(() => {
+  init_errorCodes();
+  init_command();
+  init_values();
+  init_api3();
+  init_client2();
 });
 
-// src/commands/wait-for-task.ts
-var exports_wait_for_task = {};
-__export(exports_wait_for_task, {
-  waitForTask: () => waitForTask
+// src/commands/get-next-task/index.ts
+var exports_get_next_task = {};
+__export(exports_get_next_task, {
+  getNextTask: () => getNextTask,
+  WaitForTaskSession: () => GetNextTaskSession,
+  GetNextTaskSession: () => GetNextTaskSession
 });
-async function waitForTask(chatroomId, options) {
+async function getNextTask(chatroomId, options) {
   const client2 = await getConvexClient();
   const { role, silent } = options;
   const convexUrl = getConvexUrl();
@@ -10933,7 +11419,7 @@ async function waitForTask(chatroomId, options) {
       }
       console.error(`
    To use a different environment, set CHATROOM_CONVEX_URL:`);
-      console.error(`   CHATROOM_CONVEX_URL=${otherUrls[0]} chatroom wait-for-task ...`);
+      console.error(`   CHATROOM_CONVEX_URL=${otherUrls[0]} chatroom get-next-task ...`);
       console.error(`
    Or to authenticate for the current environment:`);
     }
@@ -10969,13 +11455,8 @@ async function waitForTask(chatroomId, options) {
     const machineInfo = ensureMachineRegistered();
     let availableModels = [];
     try {
-      const registry = getDriverRegistry();
-      for (const driver of registry.all()) {
-        if (driver.capabilities.dynamicModelDiscovery) {
-          const models = await driver.listModels();
-          availableModels = availableModels.concat(models);
-        }
-      }
+      const agentService = new OpenCodeAgentService;
+      availableModels = await agentService.listModels();
     } catch {}
     await client2.mutation(api.machines.register, {
       sessionId,
@@ -10989,7 +11470,6 @@ async function waitForTask(chatroomId, options) {
     const agentType = options.agentType ?? (machineInfo.availableHarnesses.length > 0 ? machineInfo.availableHarnesses[0] : undefined);
     if (agentType) {
       const workingDir = process.cwd();
-      updateAgentContext(chatroomId, role, agentType, workingDir);
       await client2.mutation(api.machines.updateAgentConfig, {
         sessionId,
         machineId: machineInfo.machineId,
@@ -11001,16 +11481,26 @@ async function waitForTask(chatroomId, options) {
     }
   } catch (machineError) {
     if (!silent) {
-      console.warn(`⚠️  Machine registration failed: ${machineError.message}`);
+      console.warn(`⚠️  Machine registration failed: ${sanitizeUnknownForTerminal(machineError.message)}`);
     }
   }
   const connectionId = `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+  let participantAgentType;
+  try {
+    const teamConfigs = await client2.query(api.machines.getTeamAgentConfigs, {
+      sessionId,
+      chatroomId
+    });
+    const roleConfig = teamConfigs?.find((c) => c.role.toLowerCase() === role.toLowerCase());
+    participantAgentType = roleConfig?.type;
+  } catch {}
   await client2.mutation(api.participants.join, {
     sessionId,
     chatroomId,
     role,
-    readyUntil: Date.now() + HEARTBEAT_TTL_MS,
-    connectionId
+    action: "get-next-task:started",
+    connectionId,
+    agentType: participantAgentType
   });
   const connectionTime = new Date().toISOString().replace("T", " ").substring(0, 19);
   if (!silent) {
@@ -11034,7 +11524,7 @@ async function waitForTask(chatroomId, options) {
         console.log("\uD83D\uDCCB AGENT INITIALIZATION PROMPT");
         console.log("═".repeat(50));
         console.log("");
-        console.log(getWaitForTaskGuidance());
+        console.log(getNextTaskGuidance());
         console.log("");
         console.log("═".repeat(50));
         console.log("");
@@ -11046,192 +11536,58 @@ async function waitForTask(chatroomId, options) {
       }
     }
   } catch {}
-  const heartbeatTimer = setInterval(() => {
-    client2.mutation(api.participants.heartbeat, {
-      sessionId,
-      chatroomId,
-      role,
-      connectionId
-    }).then((result) => {
-      if (result?.status === "rejoin_required") {
-        if (!silent) {
-          console.warn(`⚠️  Participant record missing — re-joining chatroom`);
-        }
-        return client2.mutation(api.participants.join, {
-          sessionId,
-          chatroomId,
-          role,
-          readyUntil: Date.now() + HEARTBEAT_TTL_MS,
-          connectionId
-        });
-      }
-    }).catch((err) => {
-      if (!silent) {
-        console.warn(`⚠️  Heartbeat failed: ${err.message}`);
-      }
-    });
-  }, HEARTBEAT_INTERVAL_MS);
-  heartbeatTimer.unref();
-  let cleanedUp = false;
-  const cleanup = async () => {
-    if (cleanedUp)
-      return;
-    cleanedUp = true;
-    clearInterval(heartbeatTimer);
-    try {
-      await client2.mutation(api.participants.leave, {
-        sessionId,
-        chatroomId,
-        role
-      });
-    } catch {}
-  };
-  let taskProcessed = false;
-  let unsubscribe = null;
-  const handlePendingTasks = async (pendingTasks) => {
-    if (taskProcessed)
-      return;
-    const currentConnectionId = await client2.query(api.participants.getConnectionId, {
-      sessionId,
-      chatroomId,
-      role
-    });
-    if (currentConnectionId && currentConnectionId !== connectionId) {
-      if (unsubscribe)
-        unsubscribe();
-      clearInterval(heartbeatTimer);
-      cleanedUp = true;
-      const takeoverTime = new Date().toISOString().replace("T", " ").substring(0, 19);
-      console.log(`
-${"─".repeat(50)}`);
-      console.log(`⚠️  CONNECTION SUPERSEDED
-`);
-      console.log(`[${takeoverTime}] Why: Another wait-for-task process started for this role`);
-      console.log(`Impact: This process is being replaced by the newer connection`);
-      console.log(`Action: This is expected if you started a new wait-for-task session
-`);
-      console.log(`If you meant to use THIS terminal, run:`);
-      console.log(waitForTaskCommand({ chatroomId, role, cliEnvPrefix }));
-      console.log(`${"─".repeat(50)}`);
-      process.exit(0);
-    }
-    const taskWithMessage = pendingTasks.length > 0 ? pendingTasks[0] : null;
-    if (!taskWithMessage) {
-      return;
-    }
-    const { task, message } = taskWithMessage;
-    if (task.status === "acknowledged") {
-      const acknowledgedAt = task.acknowledgedAt || task.updatedAt;
-      const elapsedMs = Date.now() - acknowledgedAt;
-      const RECOVERY_GRACE_PERIOD_MS = 60 * 1000;
-      if (elapsedMs < RECOVERY_GRACE_PERIOD_MS) {
-        const remainingSec = Math.ceil((RECOVERY_GRACE_PERIOD_MS - elapsedMs) / 1000);
-        console.log(`\uD83D\uDD04 Task was recently acknowledged (${remainingSec}s remaining). ` + `Re-run wait-for-task in 1 minute to recover it if the other agent is unresponsive.`);
-        return;
-      }
-    } else {
-      try {
-        await client2.mutation(api.tasks.claimTask, {
-          sessionId,
-          chatroomId,
-          role
-        });
-      } catch (_claimError) {
-        console.log(`\uD83D\uDD04 Task already claimed by another agent, continuing to wait...`);
-        return;
-      }
-    }
-    taskProcessed = true;
-    if (message) {
-      await client2.mutation(api.messages.claimMessage, {
-        sessionId,
-        messageId: message._id,
-        role
-      });
-    }
-    if (unsubscribe)
-      unsubscribe();
-    clearInterval(heartbeatTimer);
-    cleanedUp = true;
-    const activeUntil = Date.now() + DEFAULT_ACTIVE_TIMEOUT_MS;
-    await client2.mutation(api.participants.updateStatus, {
-      sessionId,
-      chatroomId,
-      role,
-      status: "active",
-      expiresAt: activeUntil
-    });
-    const taskDeliveryPrompt = await client2.query(api.messages.getTaskDeliveryPrompt, {
-      sessionId,
-      chatroomId,
-      role,
-      taskId: task._id,
-      messageId: message?._id,
-      convexUrl
-    });
-    const taskReceivedTime = new Date().toISOString().replace("T", " ").substring(0, 19);
-    console.log(`
-[${taskReceivedTime}] \uD83D\uDCE8 Task received!
-`);
-    console.log(taskDeliveryPrompt.fullCliOutput);
-    process.exit(0);
-  };
-  const wsClient2 = await getConvexWsClient();
-  unsubscribe = wsClient2.onUpdate(api.tasks.getPendingTasksForRole, {
-    sessionId,
+  const session = new GetNextTaskSession({
     chatroomId,
-    role
-  }, (pendingTasks) => {
-    handlePendingTasks(pendingTasks).catch((error) => {
-      console.error(`❌ Error processing task: ${error.message}`);
-    });
+    role,
+    silent: !!silent,
+    sessionId,
+    connectionId,
+    cliEnvPrefix,
+    client: client2
   });
-  const handleSignal = (_signal) => {
-    if (unsubscribe)
-      unsubscribe();
-    cleanup().finally(() => {
-      const signalTime = new Date().toISOString().replace("T", " ").substring(0, 19);
-      console.log(`
-${"─".repeat(50)}`);
-      console.log(`⚠️  RECONNECTION REQUIRED
-`);
-      console.log(`[${signalTime}] Why: Process interrupted (unexpected termination)`);
-      console.log(`Impact: You are no longer listening for tasks`);
-      console.log(`Action: Run this command immediately to resume availability
-`);
-      console.log(waitForTaskCommand({ chatroomId, role, cliEnvPrefix }));
-      console.log(`${"─".repeat(50)}`);
-      process.exit(0);
-    });
-  };
-  process.on("SIGINT", () => handleSignal("SIGINT"));
-  process.on("SIGTERM", () => handleSignal("SIGTERM"));
-  process.on("SIGHUP", () => handleSignal("SIGHUP"));
+  await session.start();
 }
-var init_wait_for_task = __esm(() => {
+var init_get_next_task = __esm(() => {
   init_cli();
   init_env();
+  init_session();
   init_api3();
-  init_config2();
-  init_agent_drivers();
   init_storage();
   init_client2();
   init_machine();
+  init_opencode();
+  init_error_formatting();
+  init_session();
+  init_session();
 });
 
-// src/commands/task-started.ts
+// src/commands/task-started/index.ts
 var exports_task_started2 = {};
 __export(exports_task_started2, {
   taskStarted: () => taskStarted
 });
-async function taskStarted(chatroomId, options) {
+async function createDefaultDeps7() {
   const client2 = await getConvexClient();
-  const { role, originMessageClassification, rawStdin, taskId, noClassify } = options;
-  const convexUrl = getConvexUrl();
-  const cliEnvPrefix = getCliEnvPrefix(convexUrl);
-  const sessionId = getSessionId();
+  return {
+    backend: {
+      mutation: (endpoint, args) => client2.mutation(endpoint, args),
+      query: (endpoint, args) => client2.query(endpoint, args)
+    },
+    session: {
+      getSessionId,
+      getConvexUrl,
+      getOtherSessionUrls
+    }
+  };
+}
+async function taskStarted(chatroomId, options, deps) {
+  const d = deps ?? await createDefaultDeps7();
+  const { role, originMessageClassification, rawStdin, taskId, noClassify } = options;
+  const convexUrl = d.session.getConvexUrl();
+  const cliEnvPrefix = getCliEnvPrefix(convexUrl);
+  const sessionId = d.session.getSessionId();
   if (!sessionId) {
-    const otherUrls = getOtherSessionUrls();
+    const otherUrls = d.session.getOtherSessionUrls();
     console.error(`❌ Not authenticated for: ${convexUrl}`);
     if (otherUrls.length > 0) {
       console.error(`
@@ -11306,7 +11662,7 @@ How to implement it' | ${taskStartedCommand({
     })}`);
     process.exit(1);
   }
-  targetTask = await client2.query(api.tasks.getTask, {
+  targetTask = await d.backend.query(api.tasks.getTask, {
     sessionId,
     chatroomId,
     taskId
@@ -11317,7 +11673,7 @@ How to implement it' | ${taskStartedCommand({
     process.exit(1);
   }
   try {
-    await client2.mutation(api.tasks.startTask, {
+    await d.backend.mutation(api.tasks.startTask, {
       sessionId,
       chatroomId,
       role,
@@ -11337,13 +11693,13 @@ How to implement it' | ${taskStartedCommand({
     return;
   }
   try {
-    const result = await client2.mutation(api.messages.taskStarted, {
+    const result = await d.backend.mutation(api.messages.taskStarted, {
       sessionId,
       chatroomId,
       role,
       taskId,
       originMessageClassification,
-      convexUrl: getConvexUrl(),
+      convexUrl: d.session.getConvexUrl(),
       ...rawStdin && { rawStdin }
     });
     console.log(`✅ Task acknowledged and classified`);
@@ -11363,10 +11719,10 @@ How to implement it' | ${taskStartedCommand({
       console.error(`   Stack trace:`);
       stackLines.forEach((line) => console.error(`     ${line}`));
     }
-    if (typeof error === "object" && error !== null) {
-      const errObj = error;
-      if (errObj.data) {
-        console.error(`   Server details:`, JSON.stringify(errObj.data, null, 2));
+    if (typeof error === "object" && error !== null && "data" in error) {
+      const errData = error.data;
+      if (errData) {
+        console.error(`   Server details:`, JSON.stringify(errData, null, 2));
       }
     }
     process.exit(1);
@@ -11379,90 +11735,6 @@ var init_task_started2 = __esm(() => {
   init_client2();
 });
 
-// src/commands/task-complete.ts
-var exports_task_complete = {};
-__export(exports_task_complete, {
-  taskComplete: () => taskComplete
-});
-async function taskComplete(chatroomId, options) {
-  const client2 = await getConvexClient();
-  const { role } = options;
-  const sessionId = getSessionId();
-  if (!sessionId) {
-    const otherUrls = getOtherSessionUrls();
-    const currentUrl = getConvexUrl();
-    formatAuthError(currentUrl, otherUrls);
-    process.exit(1);
-  }
-  if (!chatroomId || typeof chatroomId !== "string" || chatroomId.length < 20 || chatroomId.length > 40) {
-    formatChatroomIdError(chatroomId);
-    process.exit(1);
-  }
-  let result;
-  try {
-    result = await client2.mutation(api.tasks.completeTask, {
-      sessionId,
-      chatroomId,
-      role
-    });
-  } catch (error) {
-    console.error(`
-❌ ERROR: Task completion failed`);
-    if (error instanceof ConvexError) {
-      const errorData = error.data;
-      console.error(`
-${errorData.message || "An unexpected error occurred"}`);
-      if (process.env.CHATROOM_DEBUG === "true") {
-        console.error(`
-\uD83D\uDD0D Debug Info:`);
-        console.error(JSON.stringify(errorData, null, 2));
-      }
-      const convexUrl2 = getConvexUrl();
-      if (errorData.code === "AUTH_FAILED") {
-        console.error(`
-\uD83D\uDCA1 Try authenticating again:`);
-        console.error(`   chatroom auth ${convexUrl2}`);
-      }
-    } else {
-      console.error(`
-${error instanceof Error ? error.message : String(error)}`);
-      if (process.env.CHATROOM_DEBUG === "true") {
-        console.error(`
-\uD83D\uDD0D Debug Info:`);
-        console.error(error);
-      }
-    }
-    console.error(`
-\uD83D\uDCDA Need help? Check the docs or run:`);
-    console.error(`   chatroom task-complete --help`);
-    process.exit(1);
-  }
-  if (!result.completed) {
-    formatError("No task to complete", [
-      "Make sure you have an in_progress task before completing.",
-      "Run `chatroom wait-for-task` to receive and start a task first."
-    ]);
-    process.exit(1);
-  }
-  console.log(`✅ Task completed successfully`);
-  console.log(`   Tasks completed: ${result.completedCount}`);
-  if (result.promoted) {
-    console.log(`   Promoted next task: ${result.promoted}`);
-  }
-  const convexUrl = getConvexUrl();
-  const cliEnvPrefix = getCliEnvPrefix(convexUrl);
-  console.log(`
-⏳ Now run wait-for-task to wait for your next assignment:`);
-  console.log(`   ${waitForTaskCommand({ chatroomId, role, cliEnvPrefix })}`);
-}
-var init_task_complete = __esm(() => {
-  init_env();
-  init_values();
-  init_api3();
-  init_storage();
-  init_client2();
-});
-
 // src/utils/serialization/decode/index.ts
 var exports_decode = {};
 __export(exports_decode, {
@@ -11473,7 +11745,10 @@ __export(exports_decode, {
 function decode(input, options = {}) {
   const { singleParam, expectedParams, requiredParams } = options;
   if (singleParam) {
-    return { [singleParam]: input.trim() };
+    const trimmed = input.trim();
+    const singleParamDelimiter = `---${singleParam.toUpperCase()}---`;
+    const stripped = trimmed.startsWith(singleParamDelimiter) ? trimmed.slice(singleParamDelimiter.length).trim() : trimmed;
+    return { [singleParam]: stripped };
   }
   return decodeMultiParam(input, expectedParams, requiredParams);
 }
@@ -11589,23 +11864,38 @@ function handoffCommand(params) {
   const chatroomId = params.chatroomId || "<chatroom-id>";
   const role = params.role || "<role>";
   const nextRole = params.nextRole || "<target>";
-  return `${prefix}chatroom handoff --chatroom-id=${chatroomId} --role=${role} --next-role=${nextRole} << 'EOF'
+  return `${prefix}chatroom handoff --chatroom-id="${chatroomId}" --role="${role}" --next-role="${nextRole}" << 'EOF'
+---MESSAGE---
 [Your message here]
 EOF`;
 }
 
-// src/commands/handoff.ts
+// src/commands/handoff/index.ts
 var exports_handoff = {};
 __export(exports_handoff, {
   handoff: () => handoff
 });
-async function handoff(chatroomId, options) {
+async function createDefaultDeps8() {
   const client2 = await getConvexClient();
+  return {
+    backend: {
+      mutation: (endpoint, args) => client2.mutation(endpoint, args),
+      query: (endpoint, args) => client2.query(endpoint, args)
+    },
+    session: {
+      getSessionId,
+      getConvexUrl,
+      getOtherSessionUrls
+    }
+  };
+}
+async function handoff(chatroomId, options, deps) {
+  const d = deps ?? await createDefaultDeps8();
   const { role, message, nextRole, attachedArtifactIds = [] } = options;
-  const sessionId = getSessionId();
+  const sessionId = d.session.getSessionId();
   if (!sessionId) {
-    const otherUrls = getOtherSessionUrls();
-    const currentUrl = getConvexUrl();
+    const otherUrls = d.session.getOtherSessionUrls();
+    const currentUrl = d.session.getConvexUrl();
     formatAuthError(currentUrl, otherUrls);
     process.exit(1);
   }
@@ -11615,7 +11905,7 @@ async function handoff(chatroomId, options) {
   }
   if (attachedArtifactIds.length > 0) {
     try {
-      const areValid = await client2.query(api.artifacts.validateArtifactIds, {
+      const areValid = await d.backend.query(api.artifacts.validateArtifactIds, {
         sessionId,
         artifactIds: attachedArtifactIds
       });
@@ -11633,12 +11923,15 @@ async function handoff(chatroomId, options) {
   }
   let result;
   try {
-    result = await client2.mutation(api.messages.sendHandoff, {
+    result = await d.backend.mutation(api.messages.sendHandoff, {
       sessionId,
       chatroomId,
       senderRole: role,
       content: message,
-      targetRole: nextRole
+      targetRole: nextRole,
+      ...attachedArtifactIds.length > 0 && {
+        attachedArtifactIds
+      }
     });
   } catch (error) {
     console.error(`
@@ -11652,7 +11945,7 @@ ${errorData.message || "An unexpected error occurred"}`);
 \uD83D\uDD0D Debug Info:`);
         console.error(JSON.stringify(errorData, null, 2));
       }
-      const convexUrl2 = getConvexUrl();
+      const convexUrl2 = d.session.getConvexUrl();
       if (errorData.code === "AUTH_FAILED") {
         console.error(`
 \uD83D\uDCA1 Try authenticating again:`);
@@ -11674,9 +11967,10 @@ ${error instanceof Error ? error.message : String(error)}`);
 \uD83D\uDCDA Need help? Check the docs or run:`);
     console.error(`   chatroom handoff --help`);
     process.exit(1);
+    return;
   }
   if (!result.success && result.error) {
-    const convexUrl2 = getConvexUrl();
+    const convexUrl2 = d.session.getConvexUrl();
     const cliEnvPrefix2 = getCliEnvPrefix(convexUrl2);
     console.error(`
 ❌ ERROR: ${result.error.message}`);
@@ -11702,36 +11996,47 @@ ${error instanceof Error ? error.message : String(error)}`);
       console.log(`   • ${id}`);
     });
   }
-  if (nextRole.toLowerCase() === "user") {
-    console.log(`
-\uD83C\uDF89 Workflow complete! Control returned to user.`);
-  }
-  const convexUrl = getConvexUrl();
+  const convexUrl = d.session.getConvexUrl();
   const cliEnvPrefix = getCliEnvPrefix(convexUrl);
   console.log(`
-⏳ Now run wait-for-task to wait for your next assignment:`);
-  console.log(`   ${waitForTaskCommand({ chatroomId, role, cliEnvPrefix })}`);
+⏳ Next → \`${getNextTaskCommand({ chatroomId, role, cliEnvPrefix })}\``);
 }
 var init_handoff = __esm(() => {
+  init_command();
   init_env();
   init_values();
   init_api3();
   init_storage();
   init_client2();
+  init_error_formatting();
 });
 
-// src/commands/report-progress.ts
+// src/commands/report-progress/index.ts
 var exports_report_progress = {};
 __export(exports_report_progress, {
   reportProgress: () => reportProgress
 });
-async function reportProgress(chatroomId, options) {
+async function createDefaultDeps9() {
   const client2 = await getConvexClient();
+  return {
+    backend: {
+      mutation: (endpoint, args) => client2.mutation(endpoint, args),
+      query: (endpoint, args) => client2.query(endpoint, args)
+    },
+    session: {
+      getSessionId,
+      getConvexUrl,
+      getOtherSessionUrls
+    }
+  };
+}
+async function reportProgress(chatroomId, options, deps) {
+  const d = deps ?? await createDefaultDeps9();
   const { role, message } = options;
-  const sessionId = getSessionId();
+  const sessionId = d.session.getSessionId();
   if (!sessionId) {
-    const otherUrls = getOtherSessionUrls();
-    const currentUrl = getConvexUrl();
+    const otherUrls = d.session.getOtherSessionUrls();
+    const currentUrl = d.session.getConvexUrl();
     formatAuthError(currentUrl, otherUrls);
     process.exit(1);
   }
@@ -11749,7 +12054,7 @@ async function reportProgress(chatroomId, options) {
     process.exit(1);
   }
   try {
-    const result = await client2.mutation(api.messages.reportProgress, {
+    const result = await d.backend.mutation(api.messages.reportProgress, {
       sessionId,
       chatroomId,
       senderRole: role,
@@ -11771,7 +12076,7 @@ ${errorData.message || "An unexpected error occurred"}`);
 \uD83D\uDD0D Debug Info:`);
         console.error(JSON.stringify(errorData, null, 2));
       }
-      const convexUrl = getConvexUrl();
+      const convexUrl = d.session.getConvexUrl();
       if (errorData.code === "AUTH_FAILED") {
         console.error(`
 \uD83D\uDCA1 Try authenticating again:`);
@@ -11796,6 +12101,7 @@ ${error instanceof Error ? error.message : String(error)}`);
 \uD83D\uDCDA Need help? Check the docs or run:`);
     console.error(`   chatroom report-progress --help`);
     process.exit(1);
+    return;
   }
 }
 var init_report_progress = __esm(() => {
@@ -11803,13 +12109,13 @@ var init_report_progress = __esm(() => {
   init_api3();
   init_storage();
   init_client2();
+  init_error_formatting();
 });
 
-// src/commands/backlog.ts
+// src/commands/backlog/index.ts
 var exports_backlog = {};
 __export(exports_backlog, {
   scoreBacklog: () => scoreBacklog,
-  resetBacklog: () => resetBacklog,
   reopenBacklog: () => reopenBacklog,
   patchBacklog: () => patchBacklog,
   markForReviewBacklog: () => markForReviewBacklog,
@@ -11817,24 +12123,47 @@ __export(exports_backlog, {
   completeBacklog: () => completeBacklog,
   addBacklog: () => addBacklog
 });
-async function listBacklog(chatroomId, options) {
+async function createDefaultDeps10() {
   const client2 = await getConvexClient();
-  const sessionId = getSessionId();
+  return {
+    backend: {
+      mutation: (endpoint, args) => client2.mutation(endpoint, args),
+      query: (endpoint, args) => client2.query(endpoint, args)
+    },
+    session: {
+      getSessionId,
+      getConvexUrl,
+      getOtherSessionUrls
+    }
+  };
+}
+function requireAuth2(d) {
+  const sessionId = d.session.getSessionId();
   if (!sessionId) {
     console.error(`❌ Not authenticated. Please run: chatroom auth login`);
     process.exit(1);
   }
+  return sessionId;
+}
+function validateChatroomId(chatroomId) {
   if (!chatroomId || typeof chatroomId !== "string" || chatroomId.length < 20 || chatroomId.length > 40) {
     console.error(`❌ Invalid chatroom ID format: ID must be 20-40 characters (got ${chatroomId?.length || 0})`);
     process.exit(1);
   }
+}
+async function listBacklog(chatroomId, options, deps) {
+  const d = deps ?? await createDefaultDeps10();
+  const sessionId = requireAuth2(d);
+  validateChatroomId(chatroomId);
   const validStatuses = [
     "pending",
+    "acknowledged",
     "in_progress",
     "queued",
     "backlog",
+    "backlog_acknowledged",
     "completed",
-    "cancelled",
+    "closed",
     "active",
     "pending_review",
     "archived",
@@ -11844,27 +12173,28 @@ async function listBacklog(chatroomId, options) {
   if (!statusFilter || !validStatuses.includes(statusFilter)) {
     console.error(`❌ Invalid or missing status: ${statusFilter || "(none)"}. Must be one of: ${validStatuses.join(", ")}`);
     process.exit(1);
+    return;
   }
   try {
-    const counts = await client2.query(api.tasks.getTaskCounts, {
+    const counts = await d.backend.query(api.tasks.getTaskCounts, {
       sessionId,
       chatroomId
     });
     let tasks;
     if (statusFilter === "active") {
-      tasks = await client2.query(api.tasks.listActiveTasks, {
+      tasks = await d.backend.query(api.tasks.listActiveTasks, {
         sessionId,
         chatroomId,
         limit: options.limit || 100
       });
     } else if (statusFilter === "archived") {
-      tasks = await client2.query(api.tasks.listArchivedTasks, {
+      tasks = await d.backend.query(api.tasks.listArchivedTasks, {
         sessionId,
         chatroomId,
         limit: options.limit || 100
       });
     } else {
-      tasks = await client2.query(api.tasks.listTasks, {
+      tasks = await d.backend.query(api.tasks.listTasks, {
         sessionId,
         chatroomId,
         statusFilter: statusFilter === "all" ? undefined : statusFilter,
@@ -11937,25 +12267,20 @@ async function listBacklog(chatroomId, options) {
   } catch (error) {
     console.error(`❌ Failed to list tasks: ${error.message}`);
     process.exit(1);
+    return;
   }
 }
-async function addBacklog(chatroomId, options) {
-  const client2 = await getConvexClient();
-  const sessionId = getSessionId();
-  if (!sessionId) {
-    console.error(`❌ Not authenticated. Please run: chatroom auth login`);
-    process.exit(1);
-  }
-  if (!chatroomId || typeof chatroomId !== "string" || chatroomId.length < 20 || chatroomId.length > 40) {
-    console.error(`❌ Invalid chatroom ID format: ID must be 20-40 characters (got ${chatroomId?.length || 0})`);
-    process.exit(1);
-  }
+async function addBacklog(chatroomId, options, deps) {
+  const d = deps ?? await createDefaultDeps10();
+  const sessionId = requireAuth2(d);
+  validateChatroomId(chatroomId);
   if (!options.content || options.content.trim().length === 0) {
     console.error(`❌ Task content cannot be empty`);
     process.exit(1);
+    return;
   }
   try {
-    const result = await client2.mutation(api.tasks.createTask, {
+    const result = await d.backend.mutation(api.tasks.createTask, {
       sessionId,
       chatroomId,
       content: options.content.trim(),
@@ -11971,25 +12296,20 @@ async function addBacklog(chatroomId, options) {
   } catch (error) {
     console.error(`❌ Failed to add task: ${error.message}`);
     process.exit(1);
+    return;
   }
 }
-async function completeBacklog(chatroomId, options) {
-  const client2 = await getConvexClient();
-  const sessionId = getSessionId();
-  if (!sessionId) {
-    console.error(`❌ Not authenticated. Please run: chatroom auth login`);
-    process.exit(1);
-  }
-  if (!chatroomId || typeof chatroomId !== "string" || chatroomId.length < 20 || chatroomId.length > 40) {
-    console.error(`❌ Invalid chatroom ID format: ID must be 20-40 characters (got ${chatroomId?.length || 0})`);
-    process.exit(1);
-  }
+async function completeBacklog(chatroomId, options, deps) {
+  const d = deps ?? await createDefaultDeps10();
+  const sessionId = requireAuth2(d);
+  validateChatroomId(chatroomId);
   if (!options.taskId || options.taskId.trim().length === 0) {
     console.error(`❌ Task ID is required`);
     process.exit(1);
+    return;
   }
   try {
-    const result = await client2.mutation(api.tasks.completeTaskById, {
+    const result = await d.backend.mutation(api.tasks.completeTaskById, {
       sessionId,
       taskId: options.taskId,
       force: options.force
@@ -12010,25 +12330,20 @@ async function completeBacklog(chatroomId, options) {
   } catch (error) {
     console.error(`❌ Failed to complete task: ${error.message}`);
     process.exit(1);
+    return;
   }
 }
-async function reopenBacklog(chatroomId, options) {
-  const client2 = await getConvexClient();
-  const sessionId = getSessionId();
-  if (!sessionId) {
-    console.error(`❌ Not authenticated. Please run: chatroom auth login`);
-    process.exit(1);
-  }
-  if (!chatroomId || typeof chatroomId !== "string" || chatroomId.length < 20 || chatroomId.length > 40) {
-    console.error(`❌ Invalid chatroom ID format: ID must be 20-40 characters (got ${chatroomId?.length || 0})`);
-    process.exit(1);
-  }
+async function reopenBacklog(chatroomId, options, deps) {
+  const d = deps ?? await createDefaultDeps10();
+  const sessionId = requireAuth2(d);
+  validateChatroomId(chatroomId);
   if (!options.taskId || options.taskId.trim().length === 0) {
     console.error(`❌ Task ID is required`);
     process.exit(1);
+    return;
   }
   try {
-    await client2.mutation(api.tasks.reopenBacklogTask, {
+    await d.backend.mutation(api.tasks.reopenBacklogTask, {
       sessionId,
       taskId: options.taskId
     });
@@ -12042,36 +12357,34 @@ async function reopenBacklog(chatroomId, options) {
   } catch (error) {
     console.error(`❌ Failed to reopen task: ${error.message}`);
     process.exit(1);
+    return;
   }
 }
-async function patchBacklog(chatroomId, options) {
-  const client2 = await getConvexClient();
-  const sessionId = getSessionId();
-  if (!sessionId) {
-    console.error(`❌ Not authenticated. Please run: chatroom auth login`);
-    process.exit(1);
-  }
-  if (!chatroomId || typeof chatroomId !== "string" || chatroomId.length < 20 || chatroomId.length > 40) {
-    console.error(`❌ Invalid chatroom ID format: ID must be 20-40 characters (got ${chatroomId?.length || 0})`);
-    process.exit(1);
-  }
+async function patchBacklog(chatroomId, options, deps) {
+  const d = deps ?? await createDefaultDeps10();
+  const sessionId = requireAuth2(d);
+  validateChatroomId(chatroomId);
   if (!options.taskId || options.taskId.trim().length === 0) {
     console.error(`❌ Task ID is required`);
     process.exit(1);
+    return;
   }
   if (options.complexity === undefined && options.value === undefined && options.priority === undefined) {
     console.error(`❌ At least one of --complexity, --value, or --priority is required`);
     process.exit(1);
+    return;
   }
   const validComplexity = ["low", "medium", "high"];
   if (options.complexity !== undefined && !validComplexity.includes(options.complexity)) {
     console.error(`❌ Invalid complexity: ${options.complexity}. Must be one of: ${validComplexity.join(", ")}`);
     process.exit(1);
+    return;
   }
   const validValue = ["low", "medium", "high"];
   if (options.value !== undefined && !validValue.includes(options.value)) {
     console.error(`❌ Invalid value: ${options.value}. Must be one of: ${validValue.join(", ")}`);
     process.exit(1);
+    return;
   }
   let priorityNum;
   if (options.priority !== undefined) {
@@ -12079,10 +12392,11 @@ async function patchBacklog(chatroomId, options) {
     if (isNaN(priorityNum)) {
       console.error(`❌ Invalid priority: ${options.priority}. Must be a number.`);
       process.exit(1);
+      return;
     }
   }
   try {
-    await client2.mutation(api.tasks.patchTask, {
+    await d.backend.mutation(api.tasks.patchTask, {
       sessionId,
       taskId: options.taskId,
       complexity: options.complexity,
@@ -12105,37 +12419,35 @@ async function patchBacklog(chatroomId, options) {
   } catch (error) {
     console.error(`❌ Failed to patch task: ${error.message}`);
     process.exit(1);
+    return;
   }
 }
-async function scoreBacklog(chatroomId, options) {
-  const client2 = await getConvexClient();
-  const sessionId = getSessionId();
-  if (!sessionId) {
-    console.error(`❌ Not authenticated. Please run: chatroom auth login`);
-    process.exit(1);
-  }
-  if (!chatroomId || typeof chatroomId !== "string" || chatroomId.length < 20 || chatroomId.length > 40) {
-    console.error(`❌ Invalid chatroom ID format: ID must be 20-40 characters (got ${chatroomId?.length || 0})`);
-    process.exit(1);
-  }
+async function scoreBacklog(chatroomId, options, deps) {
+  const d = deps ?? await createDefaultDeps10();
+  const sessionId = requireAuth2(d);
+  validateChatroomId(chatroomId);
   if (!options.taskId || options.taskId.trim().length === 0) {
     console.error(`❌ Task ID is required`);
     process.exit(1);
+    return;
   }
   if (options.complexity === undefined && options.value === undefined && options.priority === undefined) {
     console.error(`❌ At least one of --complexity, --value, or --priority is required`);
     console.error(`   Example: chatroom backlog score --task-id=... --complexity=medium --value=high`);
     process.exit(1);
+    return;
   }
   const validComplexity = ["low", "medium", "high"];
   if (options.complexity !== undefined && !validComplexity.includes(options.complexity)) {
     console.error(`❌ Invalid complexity: ${options.complexity}. Must be one of: ${validComplexity.join(", ")}`);
     process.exit(1);
+    return;
   }
   const validValue = ["low", "medium", "high"];
   if (options.value !== undefined && !validValue.includes(options.value)) {
     console.error(`❌ Invalid value: ${options.value}. Must be one of: ${validValue.join(", ")}`);
     process.exit(1);
+    return;
   }
   let priorityNum;
   if (options.priority !== undefined) {
@@ -12143,10 +12455,11 @@ async function scoreBacklog(chatroomId, options) {
     if (isNaN(priorityNum)) {
       console.error(`❌ Invalid priority: ${options.priority}. Must be a number.`);
       process.exit(1);
+      return;
     }
   }
   try {
-    await client2.mutation(api.tasks.patchTask, {
+    await d.backend.mutation(api.tasks.patchTask, {
       sessionId,
       taskId: options.taskId,
       complexity: options.complexity,
@@ -12169,25 +12482,20 @@ async function scoreBacklog(chatroomId, options) {
   } catch (error) {
     console.error(`❌ Failed to score task: ${error.message}`);
     process.exit(1);
+    return;
   }
 }
-async function markForReviewBacklog(chatroomId, options) {
-  const client2 = await getConvexClient();
-  const sessionId = getSessionId();
-  if (!sessionId) {
-    console.error(`❌ Not authenticated. Please run: chatroom auth login`);
-    process.exit(1);
-  }
-  if (!chatroomId || typeof chatroomId !== "string" || chatroomId.length < 20 || chatroomId.length > 40) {
-    console.error(`❌ Invalid chatroom ID format: ID must be 20-40 characters (got ${chatroomId?.length || 0})`);
-    process.exit(1);
-  }
+async function markForReviewBacklog(chatroomId, options, deps) {
+  const d = deps ?? await createDefaultDeps10();
+  const sessionId = requireAuth2(d);
+  validateChatroomId(chatroomId);
   if (!options.taskId || options.taskId.trim().length === 0) {
     console.error(`❌ Task ID is required`);
     process.exit(1);
+    return;
   }
   try {
-    await client2.mutation(api.tasks.markBacklogForReview, {
+    await d.backend.mutation(api.tasks.markBacklogForReview, {
       sessionId,
       taskId: options.taskId
     });
@@ -12201,46 +12509,25 @@ async function markForReviewBacklog(chatroomId, options) {
   } catch (error) {
     console.error(`❌ Failed to mark task for review: ${error.message}`);
     process.exit(1);
-  }
-}
-async function resetBacklog(chatroomId, options) {
-  const client2 = await getConvexClient();
-  const sessionId = getSessionId();
-  if (!sessionId) {
-    console.error(`❌ Not authenticated. Please run: chatroom auth login`);
-    process.exit(1);
-  }
-  try {
-    const result = await client2.mutation(api.tasks.resetStuckTask, {
-      sessionId,
-      taskId: options.taskId
-    });
-    console.log("");
-    console.log("✅ Task reset to pending");
-    console.log(`   ID: ${options.taskId}`);
-    if (result.previousAssignee) {
-      console.log(`   Previous assignee: ${result.previousAssignee}`);
-    }
-    console.log("");
-  } catch (error) {
-    console.error(`❌ Failed to reset task: ${error.message}`);
-    process.exit(1);
+    return;
   }
 }
 function getStatusEmoji(status) {
   switch (status) {
     case "pending":
       return "\uD83D\uDFE2";
+    case "acknowledged":
+      return "\uD83D\uDCEC";
     case "in_progress":
       return "\uD83D\uDD35";
     case "queued":
       return "\uD83D\uDFE1";
     case "backlog":
       return "⚪";
+    case "backlog_acknowledged":
+      return "\uD83D\uDCCB";
     case "completed":
       return "✅";
-    case "cancelled":
-      return "❌";
     case "pending_user_review":
       return "\uD83D\uDC40";
     case "closed":
@@ -12284,15 +12571,29 @@ function resolveContent(content, filePath, optionName) {
 }
 var init_file_content = () => {};
 
-// src/commands/messages.ts
+// src/commands/messages/index.ts
 var exports_messages = {};
 __export(exports_messages, {
   listSinceMessage: () => listSinceMessage,
   listBySenderRole: () => listBySenderRole
 });
-async function listBySenderRole(chatroomId, options) {
+async function createDefaultDeps11() {
   const client2 = await getConvexClient();
-  const sessionId = getSessionId();
+  return {
+    backend: {
+      mutation: (endpoint, args) => client2.mutation(endpoint, args),
+      query: (endpoint, args) => client2.query(endpoint, args)
+    },
+    session: {
+      getSessionId,
+      getConvexUrl,
+      getOtherSessionUrls
+    }
+  };
+}
+async function listBySenderRole(chatroomId, options, deps) {
+  const d = deps ?? await createDefaultDeps11();
+  const sessionId = d.session.getSessionId();
   if (!sessionId) {
     console.error(`❌ Not authenticated. Please run: chatroom auth login`);
     process.exit(1);
@@ -12302,7 +12603,7 @@ async function listBySenderRole(chatroomId, options) {
     process.exit(1);
   }
   try {
-    const messages = await client2.query(api.messages.listBySenderRole, {
+    const messages = await d.backend.query(api.messages.listBySenderRole, {
       sessionId,
       chatroomId,
       senderRole: options.senderRole,
@@ -12352,11 +12653,12 @@ ${content.split(`
     console.error(`
 ❌ Error fetching messages: ${errorMessage}`);
     process.exit(1);
+    return;
   }
 }
-async function listSinceMessage(chatroomId, options) {
-  const client2 = await getConvexClient();
-  const sessionId = getSessionId();
+async function listSinceMessage(chatroomId, options, deps) {
+  const d = deps ?? await createDefaultDeps11();
+  const sessionId = d.session.getSessionId();
   if (!sessionId) {
     console.error(`❌ Not authenticated. Please run: chatroom auth login`);
     process.exit(1);
@@ -12366,7 +12668,7 @@ async function listSinceMessage(chatroomId, options) {
     process.exit(1);
   }
   try {
-    const messages = await client2.query(api.messages.listSinceMessage, {
+    const messages = await d.backend.query(api.messages.listSinceMessage, {
       sessionId,
       chatroomId,
       sinceMessageId: options.sinceMessageId,
@@ -12414,6 +12716,7 @@ ${content.split(`
     console.error(`
 ❌ Error fetching messages: ${errorMessage}`);
     process.exit(1);
+    return;
   }
 }
 var init_messages = __esm(() => {
@@ -12422,7 +12725,7 @@ var init_messages = __esm(() => {
   init_client2();
 });
 
-// src/commands/context.ts
+// src/commands/context/index.ts
 var exports_context = {};
 __export(exports_context, {
   readContext: () => readContext,
@@ -12430,9 +12733,23 @@ __export(exports_context, {
   listContexts: () => listContexts,
   inspectContext: () => inspectContext
 });
-async function readContext(chatroomId, options) {
+async function createDefaultDeps12() {
   const client2 = await getConvexClient();
-  const sessionId = getSessionId();
+  return {
+    backend: {
+      mutation: (endpoint, args) => client2.mutation(endpoint, args),
+      query: (endpoint, args) => client2.query(endpoint, args)
+    },
+    session: {
+      getSessionId,
+      getConvexUrl,
+      getOtherSessionUrls
+    }
+  };
+}
+async function readContext(chatroomId, options, deps) {
+  const d = deps ?? await createDefaultDeps12();
+  const sessionId = d.session.getSessionId();
   if (!sessionId) {
     console.error(`❌ Not authenticated. Please run: chatroom auth login`);
     process.exit(1);
@@ -12442,12 +12759,12 @@ async function readContext(chatroomId, options) {
     process.exit(1);
   }
   try {
-    const context = await client2.query(api.messages.getContextForRole, {
+    const context = await d.backend.query(api.messages.getContextForRole, {
       sessionId,
       chatroomId,
       role: options.role
     });
-    if (context.messages.length === 0) {
+    if (context.messages.length === 0 && !context.currentContext) {
       console.log(`
 \uD83D\uDCED No context available`);
       return;
@@ -12455,6 +12772,18 @@ async function readContext(chatroomId, options) {
     console.log(`
 \uD83D\uDCDA CONTEXT FOR ${options.role.toUpperCase()}`);
     console.log("═".repeat(60));
+    if (context.currentContext) {
+      console.log(`
+\uD83D\uDCCC Current Context:`);
+      console.log(`   Created by: ${context.currentContext.createdBy}`);
+      console.log(`   Created at: ${new Date(context.currentContext.createdAt).toLocaleString()}`);
+      console.log(`   Content:`);
+      const safeContextContent = sanitizeForTerminal(context.currentContext.content);
+      console.log(safeContextContent.split(`
+`).map((l) => `      ${l}`).join(`
+`));
+      console.log("─".repeat(60));
+    }
     if (context.originMessage) {
       console.log(`
 \uD83C\uDFAF Origin Message:`);
@@ -12481,9 +12810,12 @@ async function readContext(chatroomId, options) {
 \uD83D\uDD39 Message ID: ${message._id}`);
       console.log(`   Time: ${timestamp}`);
       console.log(`   From: ${message.senderRole}`);
+      if (message.targetRole) {
+        console.log(`   To: ${message.targetRole}`);
+      }
       console.log(`   Type: ${message.type}${classificationBadge}`);
       if (message.featureTitle) {
-        console.log(`   Feature: ${message.featureTitle}`);
+        console.log(`   Feature: ${sanitizeForTerminal(message.featureTitle)}`);
       }
       if (message.taskId) {
         console.log(`   Task:`);
@@ -12492,7 +12824,8 @@ async function readContext(chatroomId, options) {
           console.log(`      Status: ${message.taskStatus}`);
         }
         if (message.taskContent) {
-          console.log(`      Content: ${message.taskContent.split(`
+          const safeTaskContent = sanitizeForTerminal(message.taskContent);
+          console.log(`      Content: ${safeTaskContent.split(`
 `).map((l, i2) => i2 === 0 ? l : `      ${l}`).join(`
 `)}`);
         }
@@ -12502,7 +12835,7 @@ async function readContext(chatroomId, options) {
         for (const task of message.attachedTasks) {
           console.log(`      \uD83D\uDD39 Task ID: ${task._id}`);
           console.log(`         Type: Task`);
-          const contentLines = task.content.split(`
+          const contentLines = sanitizeForTerminal(task.content).split(`
 `);
           console.log(`         Content: ${contentLines[0]}`);
           if (contentLines.length > 1) {
@@ -12513,20 +12846,22 @@ async function readContext(chatroomId, options) {
         }
       }
       console.log(`   Content:`);
-      console.log(message.content.split(`
+      const safeMessageContent = sanitizeForTerminal(message.content);
+      console.log(safeMessageContent.split(`
 `).map((l) => `      ${l}`).join(`
 `));
     }
     console.log(`
 ` + "═".repeat(60));
   } catch (err) {
-    console.error(`❌ Failed to read context: ${err.message}`);
+    console.error(`❌ Failed to read context: ${sanitizeUnknownForTerminal(err.message)}`);
     process.exit(1);
+    return;
   }
 }
-async function newContext(chatroomId, options) {
-  const client2 = await getConvexClient();
-  const sessionId = getSessionId();
+async function newContext(chatroomId, options, deps) {
+  const d = deps ?? await createDefaultDeps12();
+  const sessionId = d.session.getSessionId();
   if (!sessionId) {
     console.error(`❌ Not authenticated. Please run: chatroom auth login`);
     process.exit(1);
@@ -12540,11 +12875,12 @@ async function newContext(chatroomId, options) {
     process.exit(1);
   }
   try {
-    const contextId = await client2.mutation(api.contexts.createContext, {
+    const contextId = await d.backend.mutation(api.contexts.createContext, {
       sessionId,
       chatroomId,
       content: options.content,
-      role: options.role
+      role: options.role,
+      triggerMessageId: options.triggerMessageId
     });
     console.log(`✅ Context created successfully`);
     console.log(`   Context ID: ${contextId}`);
@@ -12554,11 +12890,12 @@ async function newContext(chatroomId, options) {
   } catch (err) {
     console.error(`❌ Failed to create context: ${err.message}`);
     process.exit(1);
+    return;
   }
 }
-async function listContexts(chatroomId, options) {
-  const client2 = await getConvexClient();
-  const sessionId = getSessionId();
+async function listContexts(chatroomId, options, deps) {
+  const d = deps ?? await createDefaultDeps12();
+  const sessionId = d.session.getSessionId();
   if (!sessionId) {
     console.error(`❌ Not authenticated. Please run: chatroom auth login`);
     process.exit(1);
@@ -12568,7 +12905,7 @@ async function listContexts(chatroomId, options) {
     process.exit(1);
   }
   try {
-    const contexts = await client2.query(api.contexts.listContexts, {
+    const contexts = await d.backend.query(api.contexts.listContexts, {
       sessionId,
       chatroomId,
       limit: options.limit ?? 10
@@ -12594,7 +12931,8 @@ async function listContexts(chatroomId, options) {
         console.log(`   Messages at creation: ${context.messageCountAtCreation}`);
       }
       console.log(`   Content:`);
-      const truncatedContent = context.content.length > 200 ? context.content.slice(0, 200) + "..." : context.content;
+      const safeContent = sanitizeForTerminal(context.content);
+      const truncatedContent = safeContent.length > 200 ? safeContent.slice(0, 200) + "..." : safeContent;
       console.log(truncatedContent.split(`
 `).map((l) => `      ${l}`).join(`
 `));
@@ -12602,19 +12940,20 @@ async function listContexts(chatroomId, options) {
     console.log(`
 ` + "═".repeat(60));
   } catch (err) {
-    console.error(`❌ Failed to list contexts: ${err.message}`);
+    console.error(`❌ Failed to list contexts: ${sanitizeUnknownForTerminal(err.message)}`);
     process.exit(1);
+    return;
   }
 }
-async function inspectContext(chatroomId, options) {
-  const client2 = await getConvexClient();
-  const sessionId = getSessionId();
+async function inspectContext(chatroomId, options, deps) {
+  const d = deps ?? await createDefaultDeps12();
+  const sessionId = d.session.getSessionId();
   if (!sessionId) {
     console.error(`❌ Not authenticated. Please run: chatroom auth login`);
     process.exit(1);
   }
   try {
-    const context = await client2.query(api.contexts.getContext, {
+    const context = await d.backend.query(api.contexts.getContext, {
       sessionId,
       contextId: options.contextId
     });
@@ -12642,7 +12981,7 @@ async function inspectContext(chatroomId, options) {
     console.log(`
 \uD83D\uDCDD Content:`);
     console.log("─".repeat(60));
-    console.log(context.content);
+    console.log(sanitizeForTerminal(context.content));
     console.log("─".repeat(60));
     console.log(`
 \uD83D\uDCA1 To create a new context:`);
@@ -12650,8 +12989,9 @@ async function inspectContext(chatroomId, options) {
     console.log(`
 ` + "═".repeat(60));
   } catch (err) {
-    console.error(`❌ Failed to inspect context: ${err.message}`);
+    console.error(`❌ Failed to inspect context: ${sanitizeUnknownForTerminal(err.message)}`);
     process.exit(1);
+    return;
   }
 }
 var init_context = __esm(() => {
@@ -12660,27 +13000,43 @@ var init_context = __esm(() => {
   init_client2();
 });
 
-// src/commands/guidelines.ts
+// src/commands/guidelines/index.ts
 var exports_guidelines = {};
 __export(exports_guidelines, {
   viewGuidelines: () => viewGuidelines,
   listGuidelineTypes: () => listGuidelineTypes
 });
-async function viewGuidelines(options) {
+async function createDefaultDeps13() {
+  const client2 = await getConvexClient();
+  return {
+    backend: {
+      mutation: (endpoint, args) => client2.mutation(endpoint, args),
+      query: (endpoint, args) => client2.query(endpoint, args)
+    },
+    session: {
+      getSessionId,
+      getConvexUrl,
+      getOtherSessionUrls
+    }
+  };
+}
+async function viewGuidelines(options, deps) {
+  const d = deps ?? await createDefaultDeps13();
   const { type } = options;
   if (!VALID_TYPES.includes(type)) {
     console.error(`❌ Invalid guideline type: "${type}"`);
     console.error(`   Valid types: ${VALID_TYPES.join(", ")}`);
     process.exit(1);
+    return;
   }
-  const sessionId = getSessionId();
+  const sessionId = d.session.getSessionId();
   if (!sessionId) {
     console.error(`❌ Not authenticated. Please run: chatroom auth login`);
     process.exit(1);
+    return;
   }
-  const client2 = await getConvexClient();
   try {
-    const result = await client2.query(api.guidelines.getGuidelines, {
+    const result = await d.backend.query(api.guidelines.getGuidelines, {
       type
     });
     console.log(`
@@ -12696,17 +13052,19 @@ ${"═".repeat(60)}
     const err = error;
     console.error(`❌ Error fetching guidelines: ${err.message}`);
     process.exit(1);
+    return;
   }
 }
-async function listGuidelineTypes() {
-  const sessionId = getSessionId();
+async function listGuidelineTypes(deps) {
+  const d = deps ?? await createDefaultDeps13();
+  const sessionId = d.session.getSessionId();
   if (!sessionId) {
     console.error(`❌ Not authenticated. Please run: chatroom auth login`);
     process.exit(1);
+    return;
   }
-  const client2 = await getConvexClient();
   try {
-    const types2 = await client2.query(api.guidelines.listGuidelineTypes, {});
+    const types2 = await d.backend.query(api.guidelines.listGuidelineTypes, {});
     console.log(`
 \uD83D\uDCCB Available Guideline Types
 `);
@@ -12722,6 +13080,7 @@ Usage: chatroom guidelines view --type=<type>
     const err = error;
     console.error(`❌ Error fetching guideline types: ${err.message}`);
     process.exit(1);
+    return;
   }
 }
 var VALID_TYPES;
@@ -12732,26 +13091,44 @@ var init_guidelines = __esm(() => {
   VALID_TYPES = ["coding", "security", "design", "performance", "all"];
 });
 
-// src/commands/artifact.ts
+// src/commands/artifact/index.ts
 var exports_artifact = {};
 __export(exports_artifact, {
   viewManyArtifacts: () => viewManyArtifacts,
   viewArtifact: () => viewArtifact,
   createArtifact: () => createArtifact
 });
-async function createArtifact(chatroomId, options) {
-  const sessionId = getSessionId();
-  if (!sessionId) {
-    formatAuthError();
-    process.exit(1);
-  }
+async function createDefaultDeps14() {
+  const client2 = await getConvexClient();
+  return {
+    backend: {
+      mutation: (endpoint, args) => client2.mutation(endpoint, args),
+      query: (endpoint, args) => client2.query(endpoint, args)
+    },
+    session: {
+      getSessionId,
+      getConvexUrl,
+      getOtherSessionUrls
+    }
+  };
+}
+async function createArtifact(chatroomId, options, deps) {
+  const d = deps ?? await createDefaultDeps14();
+  const sessionId = d.session.getSessionId();
+  if (!sessionId) {
+    formatAuthError(d.session.getConvexUrl(), d.session.getOtherSessionUrls());
+    process.exit(1);
+    return;
+  }
   if (!chatroomId || typeof chatroomId !== "string" || chatroomId.length < 20 || chatroomId.length > 40) {
     formatChatroomIdError(chatroomId);
     process.exit(1);
+    return;
   }
   if (!options.fromFile.endsWith(".md")) {
     formatValidationError("file extension", options.fromFile, "*.md");
     process.exit(1);
+    return;
   }
   let content;
   try {
@@ -12759,14 +13136,15 @@ async function createArtifact(chatroomId, options) {
   } catch (err) {
     formatFileError("read for --from-file", options.fromFile, err.message);
     process.exit(1);
+    return;
   }
   if (!content || content.trim().length === 0) {
     formatError("File is empty");
     process.exit(1);
+    return;
   }
-  const client2 = await getConvexClient();
   try {
-    const artifactId = await client2.mutation(api.artifacts.create, {
+    const artifactId = await d.backend.mutation(api.artifacts.create, {
       sessionId,
       chatroomId,
       filename: options.filename,
@@ -12785,21 +13163,24 @@ async function createArtifact(chatroomId, options) {
   } catch (error) {
     formatError("Failed to create artifact", [String(error)]);
     process.exit(1);
+    return;
   }
 }
-async function viewArtifact(chatroomId, options) {
-  const sessionId = getSessionId();
+async function viewArtifact(chatroomId, options, deps) {
+  const d = deps ?? await createDefaultDeps14();
+  const sessionId = d.session.getSessionId();
   if (!sessionId) {
-    formatAuthError();
+    formatAuthError(d.session.getConvexUrl(), d.session.getOtherSessionUrls());
     process.exit(1);
+    return;
   }
   if (!chatroomId || typeof chatroomId !== "string" || chatroomId.length < 20 || chatroomId.length > 40) {
     formatChatroomIdError(chatroomId);
     process.exit(1);
+    return;
   }
-  const client2 = await getConvexClient();
   try {
-    const artifact = await client2.query(api.artifacts.get, {
+    const artifact = await d.backend.query(api.artifacts.get, {
       sessionId,
       artifactId: options.artifactId
     });
@@ -12810,6 +13191,7 @@ async function viewArtifact(chatroomId, options) {
         `chatroom artifact create ${chatroomId} --from-file=... --filename=...`
       ]);
       process.exit(1);
+      return;
     }
     console.log(`\uD83D\uDCC4 Artifact: ${artifact.filename}`);
     console.log(`\uD83C\uDD94 ID: ${artifact._id}`);
@@ -12825,33 +13207,38 @@ async function viewArtifact(chatroomId, options) {
   } catch (error) {
     formatError("Failed to view artifact", [String(error)]);
     process.exit(1);
+    return;
   }
 }
-async function viewManyArtifacts(chatroomId, options) {
-  const sessionId = getSessionId();
+async function viewManyArtifacts(chatroomId, options, deps) {
+  const d = deps ?? await createDefaultDeps14();
+  const sessionId = d.session.getSessionId();
   if (!sessionId) {
-    formatAuthError();
+    formatAuthError(d.session.getConvexUrl(), d.session.getOtherSessionUrls());
     process.exit(1);
+    return;
   }
   if (!chatroomId || typeof chatroomId !== "string" || chatroomId.length < 20 || chatroomId.length > 40) {
     formatChatroomIdError(chatroomId);
     process.exit(1);
+    return;
   }
   if (options.artifactIds.length === 0) {
     formatError("No artifact IDs provided", [
       "Usage: chatroom artifact view-many <chatroomId> --artifact=id1 --artifact=id2"
     ]);
     process.exit(1);
+    return;
   }
-  const client2 = await getConvexClient();
   try {
-    const artifacts = await client2.query(api.artifacts.getMany, {
+    const artifacts = await d.backend.query(api.artifacts.getMany, {
       sessionId,
       artifactIds: options.artifactIds
     });
     if (artifacts.length === 0) {
       formatError("No artifacts found");
       process.exit(1);
+      return;
     }
     artifacts.forEach((artifact, index) => {
       if (index > 0) {
@@ -12874,20 +13261,248 @@ async function viewManyArtifacts(chatroomId, options) {
   } catch (error) {
     formatError("Failed to view artifacts", [String(error)]);
     process.exit(1);
+    return;
   }
 }
 var init_artifact = __esm(() => {
   init_api3();
   init_storage();
   init_client2();
+  init_error_formatting();
   init_file_content();
 });
 
+// src/commands/get-system-prompt/index.ts
+var exports_get_system_prompt = {};
+__export(exports_get_system_prompt, {
+  getSystemPrompt: () => getSystemPrompt
+});
+async function createDefaultDeps15() {
+  const client2 = await getConvexClient();
+  return {
+    backend: {
+      mutation: (endpoint, args) => client2.mutation(endpoint, args),
+      query: (endpoint, args) => client2.query(endpoint, args)
+    },
+    session: {
+      getSessionId,
+      getConvexUrl,
+      getOtherSessionUrls
+    }
+  };
+}
+async function getSystemPrompt(chatroomId, options, deps) {
+  const d = deps ?? await createDefaultDeps15();
+  const { role } = options;
+  const sessionId = d.session.getSessionId();
+  if (!sessionId) {
+    console.error(`❌ Not authenticated. Please run: chatroom auth login`);
+    process.exit(1);
+    return;
+  }
+  const convexUrl = d.session.getConvexUrl();
+  try {
+    const chatroom = await d.backend.query(api.chatrooms.get, {
+      sessionId,
+      chatroomId
+    });
+    if (!chatroom) {
+      console.error(`❌ Chatroom not found: ${chatroomId}`);
+      process.exit(1);
+      return;
+    }
+    const prompt = await d.backend.query(api.prompts.webapp.getAgentPrompt, {
+      chatroomId,
+      role,
+      teamName: chatroom.teamName,
+      teamRoles: chatroom.teamRoles,
+      teamEntryPoint: chatroom.teamEntryPoint,
+      convexUrl: convexUrl ?? undefined
+    });
+    console.log(prompt);
+  } catch (error) {
+    const err = error;
+    console.error(`❌ Error fetching system prompt: ${err.message}`);
+    process.exit(1);
+    return;
+  }
+}
+var init_get_system_prompt = __esm(() => {
+  init_api3();
+  init_storage();
+  init_client2();
+});
+
+// ../../services/backend/config/reliability.ts
+var DAEMON_HEARTBEAT_INTERVAL_MS = 30000;
+
+// src/commands/machine/daemon-start/utils.ts
+function formatTimestamp() {
+  return new Date().toISOString().replace("T", " ").substring(0, 19);
+}
+function parseMachineCommand(raw) {
+  switch (raw.type) {
+    case "ping":
+      return { _id: raw._id, type: "ping", payload: {}, createdAt: raw.createdAt };
+    case "status":
+      return { _id: raw._id, type: "status", payload: {}, createdAt: raw.createdAt };
+    case "start-agent": {
+      const { chatroomId, role, agentHarness } = raw.payload;
+      if (!chatroomId || !role || !agentHarness) {
+        console.error(`   ⚠️  Invalid start-agent command: missing chatroomId, role, or agentHarness`);
+        return null;
+      }
+      return {
+        _id: raw._id,
+        type: "start-agent",
+        payload: {
+          chatroomId,
+          role,
+          agentHarness,
+          model: raw.payload.model,
+          workingDir: raw.payload.workingDir
+        },
+        createdAt: raw.createdAt
+      };
+    }
+    case "stop-agent": {
+      const { chatroomId, role } = raw.payload;
+      if (!chatroomId || !role) {
+        console.error(`   ⚠️  Invalid stop-agent command: missing chatroomId or role`);
+        return null;
+      }
+      return {
+        _id: raw._id,
+        type: "stop-agent",
+        payload: { chatroomId, role },
+        createdAt: raw.createdAt
+      };
+    }
+    default:
+      return null;
+  }
+}
+
+// src/commands/machine/events/on-agent-shutdown/index.ts
+async function onAgentShutdown(ctx, options) {
+  const { chatroomId, role, pid, skipKill } = options;
+  let killed = false;
+  if (!skipKill) {
+    try {
+      ctx.deps.processes.kill(-pid, "SIGTERM");
+    } catch {
+      killed = true;
+    }
+    if (!killed) {
+      const SIGTERM_TIMEOUT_MS = 1e4;
+      const POLL_INTERVAL_MS2 = 500;
+      const deadline = Date.now() + SIGTERM_TIMEOUT_MS;
+      while (Date.now() < deadline) {
+        await ctx.deps.clock.delay(POLL_INTERVAL_MS2);
+        try {
+          ctx.deps.processes.kill(pid, 0);
+        } catch {
+          killed = true;
+          break;
+        }
+      }
+    }
+    if (!killed) {
+      try {
+        ctx.deps.processes.kill(-pid, "SIGKILL");
+      } catch {
+        killed = true;
+      }
+    }
+    if (!killed) {
+      await ctx.deps.clock.delay(5000);
+      try {
+        ctx.deps.processes.kill(pid, 0);
+        console.log(`   ⚠️  Process ${pid} (${role}) still alive after SIGKILL — possible zombie`);
+      } catch {
+        killed = true;
+      }
+    }
+  }
+  ctx.deps.stops.mark(chatroomId, role);
+  ctx.deps.machine.clearAgentPid(ctx.machineId, chatroomId, role);
+  let spawnedAgentCleared = false;
+  try {
+    await ctx.deps.backend.mutation(api.machines.updateSpawnedAgent, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId,
+      chatroomId,
+      role,
+      pid: undefined
+    });
+    spawnedAgentCleared = true;
+  } catch (e) {
+    console.log(`   ⚠️  Failed to clear spawnedAgent for ${role}: ${e.message}`);
+  }
+  let participantRemoved = false;
+  try {
+    await ctx.deps.backend.mutation(api.participants.leave, {
+      sessionId: ctx.sessionId,
+      chatroomId,
+      role
+    });
+    participantRemoved = true;
+  } catch (e) {
+    console.log(`   ⚠️  Failed to remove participant for ${role}: ${e.message}`);
+  }
+  return { killed, cleaned: spawnedAgentCleared && participantRemoved };
+}
+var init_on_agent_shutdown = __esm(() => {
+  init_api3();
+});
+
+// src/commands/machine/events/on-daemon-shutdown/index.ts
+async function onDaemonShutdown(ctx) {
+  const agents = ctx.deps.machine.listAgentEntries(ctx.machineId);
+  if (agents.length > 0) {
+    console.log(`[${formatTimestamp()}] Stopping ${agents.length} agent(s)...`);
+    await Promise.allSettled(agents.map(async ({ chatroomId, role, entry }) => {
+      const result = await onAgentShutdown(ctx, {
+        chatroomId,
+        role,
+        pid: entry.pid
+      });
+      if (result.killed) {
+        console.log(`   Sent SIGTERM to ${role} (PID ${entry.pid})`);
+      } else {
+        console.log(`   ${role} (PID ${entry.pid}) already exited`);
+      }
+      return result;
+    }));
+    await ctx.deps.clock.delay(AGENT_SHUTDOWN_TIMEOUT_MS);
+    for (const { role, entry } of agents) {
+      try {
+        ctx.deps.processes.kill(entry.pid, 0);
+        ctx.deps.processes.kill(entry.pid, "SIGKILL");
+        console.log(`   Force-killed ${role} (PID ${entry.pid})`);
+      } catch {}
+    }
+    console.log(`[${formatTimestamp()}] All agents stopped`);
+  }
+  try {
+    await ctx.deps.backend.mutation(api.machines.updateDaemonStatus, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId,
+      connected: false
+    });
+  } catch {}
+}
+var AGENT_SHUTDOWN_TIMEOUT_MS = 5000;
+var init_on_daemon_shutdown = __esm(() => {
+  init_api3();
+  init_on_agent_shutdown();
+});
+
 // src/commands/machine/pid.ts
 import { createHash } from "node:crypto";
-import { existsSync as existsSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync5, unlinkSync as unlinkSync3, mkdirSync as mkdirSync4 } from "node:fs";
+import { existsSync as existsSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync4, unlinkSync as unlinkSync2, mkdirSync as mkdirSync4 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { join as join6 } from "node:path";
+import { join as join5 } from "node:path";
 function getUrlHash() {
   const url = getConvexUrl();
   return createHash("sha256").update(url).digest("hex").substring(0, 8);
@@ -12901,7 +13516,7 @@ function ensureChatroomDir() {
   }
 }
 function getPidFilePath() {
-  return join6(CHATROOM_DIR4, getPidFileName());
+  return join5(CHATROOM_DIR4, getPidFileName());
 }
 function isProcessRunning(pid) {
   try {
@@ -12930,13 +13545,13 @@ function readPid() {
 function writePid() {
   ensureChatroomDir();
   const pidPath = getPidFilePath();
-  writeFileSync5(pidPath, process.pid.toString(), "utf-8");
+  writeFileSync4(pidPath, process.pid.toString(), "utf-8");
 }
 function removePid() {
   const pidPath = getPidFilePath();
   try {
     if (existsSync4(pidPath)) {
-      unlinkSync3(pidPath);
+      unlinkSync2(pidPath);
     }
   } catch {}
 }
@@ -12966,171 +13581,16 @@ function releaseLock() {
 var CHATROOM_DIR4;
 var init_pid = __esm(() => {
   init_client2();
-  CHATROOM_DIR4 = join6(homedir4(), ".chatroom");
+  CHATROOM_DIR4 = join5(homedir4(), ".chatroom");
 });
 
-// src/commands/machine/daemon-start.ts
-import { execSync as execSync3 } from "node:child_process";
-import { stat } from "node:fs/promises";
-function parseMachineCommand(raw) {
-  switch (raw.type) {
-    case "ping":
-      return { _id: raw._id, type: "ping", payload: {}, createdAt: raw.createdAt };
-    case "status":
-      return { _id: raw._id, type: "status", payload: {}, createdAt: raw.createdAt };
-    case "start-agent": {
-      const { chatroomId, role, agentHarness } = raw.payload;
-      if (!chatroomId || !role || !agentHarness) {
-        console.error(`   ⚠️  Invalid start-agent command: missing chatroomId, role, or agentHarness`);
-        return null;
-      }
-      return {
-        _id: raw._id,
-        type: "start-agent",
-        payload: {
-          chatroomId,
-          role,
-          agentHarness,
-          model: raw.payload.model,
-          workingDir: raw.payload.workingDir
-        },
-        createdAt: raw.createdAt
-      };
-    }
-    case "stop-agent": {
-      const { chatroomId, role } = raw.payload;
-      if (!chatroomId || !role) {
-        console.error(`   ⚠️  Invalid stop-agent command: missing chatroomId or role`);
-        return null;
-      }
-      return {
-        _id: raw._id,
-        type: "stop-agent",
-        payload: { chatroomId, role },
-        createdAt: raw.createdAt
-      };
-    }
-    default:
-      return null;
-  }
-}
-function formatTimestamp() {
-  return new Date().toISOString().replace("T", " ").substring(0, 19);
-}
-function verifyPidOwnership(pid, expectedHarness) {
-  try {
-    process.kill(pid, 0);
-  } catch {
-    return false;
-  }
-  if (!expectedHarness) {
-    return true;
-  }
-  try {
-    const platform = process.platform;
-    let processName = "";
-    if (platform === "darwin" || platform === "linux") {
-      processName = execSync3(`ps -p ${pid} -o comm= 2>/dev/null`, {
-        encoding: "utf-8",
-        timeout: 3000
-      }).trim();
-    }
-    if (!processName) {
-      return true;
-    }
-    const harnessLower = expectedHarness.toLowerCase();
-    const procLower = processName.toLowerCase();
-    return procLower.includes(harnessLower) || procLower.includes("node") || procLower.includes("bun");
-  } catch {
-    return true;
-  }
-}
-async function clearAgentPidEverywhere(ctx, chatroomId, role) {
-  try {
-    await ctx.client.mutation(api.machines.updateSpawnedAgent, {
-      sessionId: ctx.sessionId,
-      machineId: ctx.machineId,
-      chatroomId,
-      role,
-      pid: undefined
-    });
-  } catch (e) {
-    console.log(`   ⚠️  Failed to clear PID in backend: ${e.message}`);
-  }
-  clearAgentPid(ctx.machineId, chatroomId, role);
-}
-async function handleAgentCrashRecovery(ctx, originalCommand, _crashedPid) {
-  const { chatroomId, role } = originalCommand.payload;
-  const ts = formatTimestamp();
-  await clearAgentPidEverywhere(ctx, chatroomId, role).catch((err) => {
-    console.log(`   ⚠️  Failed to clear PID after exit: ${err.message}`);
-  });
-  try {
-    await ctx.client.mutation(api.participants.leave, {
-      sessionId: ctx.sessionId,
-      chatroomId,
-      role
-    });
-    console.log(`[${ts}]    Marked ${role} as offline (participant removed)`);
-  } catch (leaveErr) {
-    console.log(`[${ts}]    ⚠️  Could not remove participant: ${leaveErr.message}`);
-  }
-  console.log(`[${ts}] \uD83D\uDD04 Attempting to restart ${role} (max ${MAX_CRASH_RESTART_ATTEMPTS} attempts)...`);
-  for (let attempt = 1;attempt <= MAX_CRASH_RESTART_ATTEMPTS; attempt++) {
-    const attemptTs = formatTimestamp();
-    console.log(`[${attemptTs}]    Restart attempt ${attempt}/${MAX_CRASH_RESTART_ATTEMPTS}...`);
-    await new Promise((resolve2) => setTimeout(resolve2, CRASH_RESTART_DELAY_MS));
-    try {
-      const result = await handleStartAgent(ctx, originalCommand);
-      if (!result.failed) {
-        const successTs = formatTimestamp();
-        console.log(`[${successTs}] ✅ ${role} restarted successfully on attempt ${attempt}`);
-        return;
-      }
-      console.log(`[${attemptTs}]    ⚠️  Restart attempt ${attempt} failed: ${result.result}`);
-    } catch (restartErr) {
-      console.log(`[${attemptTs}]    ⚠️  Restart attempt ${attempt} error: ${restartErr.message}`);
-    }
-  }
-  const failTs = formatTimestamp();
-  console.log(`[${failTs}] ❌ Failed to restart ${role} after ${MAX_CRASH_RESTART_ATTEMPTS} attempts. ` + `The agent will need to be restarted manually or via the webapp.`);
-}
-async function recoverAgentState(ctx) {
-  const entries = listAgentEntries(ctx.machineId);
-  if (entries.length === 0) {
-    console.log(`   No agent entries found — nothing to recover`);
-    return;
-  }
-  let recovered = 0;
-  let cleared = 0;
-  for (const { chatroomId, role, entry } of entries) {
-    const { pid, harness } = entry;
-    const alive = verifyPidOwnership(pid, harness);
-    if (alive) {
-      console.log(`   ✅ Recovered: ${role} (PID ${pid}, harness: ${harness})`);
-      recovered++;
-    } else {
-      console.log(`   \uD83E\uDDF9 Stale PID ${pid} for ${role} — clearing`);
-      await clearAgentPidEverywhere(ctx, chatroomId, role);
-      cleared++;
-    }
-  }
-  console.log(`   Recovery complete: ${recovered} alive, ${cleared} stale cleared`);
-}
+// src/commands/machine/daemon-start/handlers/ping.ts
 function handlePing() {
   console.log(`   ↪ Responding: pong`);
   return { result: "pong", failed: false };
 }
-function handleStatus(ctx) {
-  const result = JSON.stringify({
-    hostname: ctx.config?.hostname,
-    os: ctx.config?.os,
-    availableHarnesses: ctx.config?.availableHarnesses,
-    chatroomAgents: Object.keys(ctx.config?.chatroomAgents ?? {})
-  });
-  console.log(`   ↪ Responding with status`);
-  return { result, failed: false };
-}
+
+// src/commands/machine/daemon-start/handlers/start-agent.ts
 async function handleStartAgent(ctx, command) {
   const { chatroomId, role, agentHarness, model, workingDir } = command.payload;
   console.log(`   ↪ start-agent command received`);
@@ -13140,100 +13600,163 @@ async function handleStartAgent(ctx, command) {
   if (model) {
     console.log(`      Model: ${model}`);
   }
-  let agentContext = getAgentContext(chatroomId, role);
-  if (!agentContext && workingDir) {
-    console.log(`   No local agent context, using workingDir from command payload`);
-    updateAgentContext(chatroomId, role, agentHarness, workingDir);
-    agentContext = getAgentContext(chatroomId, role);
-  }
-  if (!agentContext) {
-    const msg = `No agent context found for ${chatroomId}/${role}`;
-    console.log(`   ⚠️  ${msg}`);
-    return { result: msg, failed: true };
+  if (!workingDir) {
+    const msg2 = `No workingDir provided in command payload for ${chatroomId}/${role}`;
+    console.log(`   ⚠️  ${msg2}`);
+    return { result: msg2, failed: true };
   }
-  console.log(`      Working dir: ${agentContext.workingDir}`);
+  console.log(`      Working dir: ${workingDir}`);
   try {
-    const dirStat = await stat(agentContext.workingDir);
+    const dirStat = await ctx.deps.fs.stat(workingDir);
     if (!dirStat.isDirectory()) {
-      const msg = `Working directory is not a directory: ${agentContext.workingDir}`;
-      console.log(`   ⚠️  ${msg}`);
-      return { result: msg, failed: true };
+      const msg2 = `Working directory is not a directory: ${workingDir}`;
+      console.log(`   ⚠️  ${msg2}`);
+      return { result: msg2, failed: true };
     }
   } catch {
-    const msg = `Working directory does not exist: ${agentContext.workingDir}`;
-    console.log(`   ⚠️  ${msg}`);
-    return { result: msg, failed: true };
+    const msg2 = `Working directory does not exist: ${workingDir}`;
+    console.log(`   ⚠️  ${msg2}`);
+    return { result: msg2, failed: true };
+  }
+  try {
+    const existingConfigs = await ctx.deps.backend.query(api.machines.getAgentConfigs, {
+      sessionId: ctx.sessionId,
+      chatroomId
+    });
+    const existingConfig = existingConfigs.configs.find((c) => c.machineId === ctx.machineId && c.role.toLowerCase() === role.toLowerCase());
+    if (existingConfig?.spawnedAgentPid) {
+      const existingPid = existingConfig.spawnedAgentPid;
+      const isAlive = ctx.remoteAgentService.isAlive(existingPid);
+      if (isAlive) {
+        console.log(`   ⚠️  Existing agent detected (PID: ${existingPid}) — stopping before respawn`);
+        await onAgentShutdown(ctx, { chatroomId, role, pid: existingPid });
+        console.log(`   ✅ Existing agent stopped`);
+      }
+    }
+  } catch (e) {
+    console.log(`   ⚠️  Could not check for existing agent (proceeding): ${e.message}`);
   }
   const convexUrl = getConvexUrl();
-  const initPromptResult = await ctx.client.query(api.messages.getInitPrompt, {
+  const initPromptResult = await ctx.deps.backend.query(api.messages.getInitPrompt, {
     sessionId: ctx.sessionId,
     chatroomId,
     role,
     convexUrl
   });
   if (!initPromptResult?.prompt) {
-    const msg = "Failed to fetch init prompt from backend";
-    console.log(`   ⚠️  ${msg}`);
-    return { result: msg, failed: true };
+    const msg2 = "Failed to fetch init prompt from backend";
+    console.log(`   ⚠️  ${msg2}`);
+    return { result: msg2, failed: true };
   }
   console.log(`   Fetched split init prompt from backend`);
-  const harnessVersion = ctx.config?.harnessVersions?.[agentHarness];
-  const registry = getDriverRegistry();
-  let driver;
+  const combinedPrompt = `${initPromptResult.rolePrompt}
+
+${initPromptResult.initialMessage}`;
+  let spawnResult;
   try {
-    driver = registry.get(agentHarness);
-  } catch {
-    const msg = `No driver registered for harness: ${agentHarness}`;
-    console.log(`   ⚠️  ${msg}`);
-    return { result: msg, failed: true };
+    spawnResult = await ctx.remoteAgentService.spawn({
+      workingDir,
+      prompt: combinedPrompt,
+      model,
+      context: { machineId: ctx.machineId, chatroomId, role }
+    });
+  } catch (e) {
+    const msg2 = `Failed to spawn agent: ${e.message}`;
+    console.log(`   ⚠️  ${msg2}`);
+    return { result: msg2, failed: true };
+  }
+  const { pid } = spawnResult;
+  const msg = `Agent spawned (PID: ${pid})`;
+  console.log(`   ✅ ${msg}`);
+  try {
+    await ctx.deps.backend.mutation(api.machines.updateSpawnedAgent, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId,
+      chatroomId,
+      role,
+      pid,
+      model
+    });
+    console.log(`   Updated backend with PID: ${pid}`);
+    ctx.deps.machine.persistAgentPid(ctx.machineId, chatroomId, role, pid, agentHarness);
+  } catch (e) {
+    console.log(`   ⚠️  Failed to update PID in backend: ${e.message}`);
   }
-  const startResult = await driver.start({
-    workingDir: agentContext.workingDir,
-    rolePrompt: initPromptResult.rolePrompt,
-    initialMessage: initPromptResult.initialMessage,
-    harnessVersion: harnessVersion ?? undefined,
+  ctx.events.emit("agent:started", {
+    chatroomId,
+    role,
+    pid,
+    harness: agentHarness,
     model
   });
-  if (startResult.success && startResult.handle) {
-    const msg = `Agent spawned (PID: ${startResult.handle.pid})`;
-    console.log(`   ✅ ${msg}`);
-    if (startResult.handle.pid) {
-      try {
-        await ctx.client.mutation(api.machines.updateSpawnedAgent, {
-          sessionId: ctx.sessionId,
-          machineId: ctx.machineId,
-          chatroomId,
-          role,
-          pid: startResult.handle.pid,
-          model
-        });
-        console.log(`   Updated backend with PID: ${startResult.handle.pid}`);
-        persistAgentPid(ctx.machineId, chatroomId, role, startResult.handle.pid, agentHarness);
-      } catch (e) {
-        console.log(`   ⚠️  Failed to update PID in backend: ${e.message}`);
-      }
-      if (startResult.onExit) {
-        const spawnedPid = startResult.handle.pid;
-        startResult.onExit((code2, signal) => {
-          const ts = formatTimestamp();
-          console.log(`[${ts}] ⚠️  Agent process exited unexpectedly ` + `(PID: ${spawnedPid}, role: ${role}, code: ${code2}, signal: ${signal})`);
-          handleAgentCrashRecovery(ctx, command, spawnedPid).catch((err) => {
-            console.log(`   ⚠️  Crash recovery failed for ${role}: ${err.message}`);
-          });
-        });
-      }
+  spawnResult.onExit(({ code: code2, signal }) => {
+    const wasIntentional = ctx.deps.stops.consume(chatroomId, role);
+    ctx.events.emit("agent:exited", {
+      chatroomId,
+      role,
+      pid,
+      code: code2,
+      signal,
+      intentional: wasIntentional
+    });
+  });
+  let lastReportedTokenAt = 0;
+  spawnResult.onOutput(() => {
+    const now = Date.now();
+    if (now - lastReportedTokenAt >= 30000) {
+      lastReportedTokenAt = now;
+      ctx.deps.backend.mutation(api.participants.updateTokenActivity, {
+        sessionId: ctx.sessionId,
+        chatroomId,
+        role
+      }).catch(() => {});
     }
-    return { result: msg, failed: false };
+  });
+  return { result: msg, failed: false };
+}
+var init_start_agent = __esm(() => {
+  init_api3();
+  init_client2();
+  init_on_agent_shutdown();
+});
+
+// src/commands/machine/daemon-start/handlers/status.ts
+function handleStatus(ctx) {
+  const result = JSON.stringify({
+    hostname: ctx.config?.hostname,
+    os: ctx.config?.os,
+    availableHarnesses: ctx.config?.availableHarnesses
+  });
+  console.log(`   ↪ Responding with status`);
+  return { result, failed: false };
+}
+
+// src/commands/machine/daemon-start/handlers/shared.ts
+async function clearAgentPidEverywhere(ctx, chatroomId, role) {
+  try {
+    await ctx.deps.backend.mutation(api.machines.updateSpawnedAgent, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId,
+      chatroomId,
+      role,
+      pid: undefined
+    });
+  } catch (e) {
+    console.log(`   ⚠️  Failed to clear PID in backend: ${e.message}`);
   }
-  console.log(`   ⚠️  ${startResult.message}`);
-  return { result: startResult.message, failed: true };
+  ctx.deps.machine.clearAgentPid(ctx.machineId, chatroomId, role);
 }
+var init_shared = __esm(() => {
+  init_api3();
+});
+
+// src/commands/machine/daemon-start/handlers/stop-agent.ts
 async function handleStopAgent(ctx, command) {
   const { chatroomId, role } = command.payload;
   console.log(`   ↪ stop-agent command received`);
   console.log(`      Chatroom: ${chatroomId}`);
   console.log(`      Role: ${role}`);
-  const configsResult = await ctx.client.query(api.machines.getAgentConfigs, {
+  const configsResult = await ctx.deps.backend.query(api.machines.getAgentConfigs, {
     sessionId: ctx.sessionId,
     chatroomId
   });
@@ -13244,28 +13767,14 @@ async function handleStopAgent(ctx, command) {
     return { result: msg, failed: true };
   }
   const pidToKill = targetConfig.spawnedAgentPid;
-  const agentHarness = targetConfig.agentType || undefined;
   console.log(`   Stopping agent with PID: ${pidToKill}`);
-  const stopHandle = {
-    harness: agentHarness || "opencode",
-    type: "process",
-    pid: pidToKill,
-    workingDir: ""
-  };
-  const registry = getDriverRegistry();
-  let stopDriver;
-  try {
-    stopDriver = agentHarness ? registry.get(agentHarness) : null;
-  } catch {
-    stopDriver = null;
-  }
-  const isAlive = stopDriver ? await stopDriver.isAlive(stopHandle) : verifyPidOwnership(pidToKill, agentHarness);
+  const isAlive = ctx.remoteAgentService.isAlive(pidToKill);
   if (!isAlive) {
     console.log(`   ⚠️  PID ${pidToKill} does not appear to belong to the expected agent`);
     await clearAgentPidEverywhere(ctx, chatroomId, role);
     console.log(`   Cleared stale PID`);
     try {
-      await ctx.client.mutation(api.participants.leave, {
+      await ctx.deps.backend.mutation(api.participants.leave, {
         sessionId: ctx.sessionId,
         chatroomId,
         role
@@ -13278,54 +13787,58 @@ async function handleStopAgent(ctx, command) {
     };
   }
   try {
-    if (stopDriver) {
-      await stopDriver.stop(stopHandle);
-    } else {
-      process.kill(pidToKill, "SIGTERM");
-    }
-    const msg = `Agent stopped (PID: ${pidToKill})`;
-    console.log(`   ✅ ${msg}`);
-    await clearAgentPidEverywhere(ctx, chatroomId, role);
-    console.log(`   Cleared PID`);
-    try {
-      await ctx.client.mutation(api.participants.leave, {
-        sessionId: ctx.sessionId,
-        chatroomId,
-        role
-      });
-      console.log(`   Removed participant record`);
-    } catch (leaveErr) {
-      console.log(`   ⚠️  Could not remove participant: ${leaveErr.message}`);
-    }
-    return { result: msg, failed: false };
+    const shutdownResult = await onAgentShutdown(ctx, {
+      chatroomId,
+      role,
+      pid: pidToKill
+    });
+    const msg = shutdownResult.killed ? `Agent stopped (PID: ${pidToKill})` : `Agent stop attempted (PID: ${pidToKill}) — process may still be running`;
+    console.log(`   ${shutdownResult.killed ? "✅" : "⚠️ "} ${msg}`);
+    return { result: msg, failed: !shutdownResult.killed };
   } catch (e) {
-    const err = e;
-    if (err.code === "ESRCH") {
-      await clearAgentPidEverywhere(ctx, chatroomId, role);
-      try {
-        await ctx.client.mutation(api.participants.leave, {
-          sessionId: ctx.sessionId,
-          chatroomId,
-          role
-        });
-      } catch {}
-      const msg2 = "Process not found (may have already exited)";
-      console.log(`   ⚠️  ${msg2}`);
-      return { result: msg2, failed: true };
-    }
-    const msg = `Failed to stop agent: ${err.message}`;
+    const msg = `Failed to stop agent: ${e.message}`;
     console.log(`   ⚠️  ${msg}`);
     return { result: msg, failed: true };
   }
 }
+var init_stop_agent = __esm(() => {
+  init_api3();
+  init_on_agent_shutdown();
+  init_shared();
+});
+
+// src/commands/machine/daemon-start/command-loop.ts
+async function refreshModels(ctx) {
+  const models = await ctx.remoteAgentService.listModels();
+  if (!ctx.config)
+    return;
+  try {
+    await ctx.deps.backend.mutation(api.machines.register, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId,
+      hostname: ctx.config.hostname,
+      os: ctx.config.os,
+      availableHarnesses: ctx.config.availableHarnesses,
+      harnessVersions: ctx.config.harnessVersions,
+      availableModels: models
+    });
+    console.log(`[${formatTimestamp()}] \uD83D\uDD04 Model refresh: ${models.length > 0 ? `${models.length} models` : "none discovered"}`);
+  } catch (error) {
+    console.warn(`[${formatTimestamp()}] ⚠️  Model refresh failed: ${error.message}`);
+  }
+}
 async function processCommand(ctx, command) {
   console.log(`[${formatTimestamp()}] \uD83D\uDCE8 Command received: ${command.type}`);
   try {
-    await ctx.client.mutation(api.machines.ackCommand, {
+    await ctx.deps.backend.mutation(api.machines.ackCommand, {
       sessionId: ctx.sessionId,
       commandId: command._id,
       status: "processing"
     });
+    ctx.events.emit("command:processing", {
+      commandId: command._id.toString(),
+      type: command.type
+    });
     let commandResult;
     switch (command.type) {
       case "ping":
@@ -13349,147 +13862,39 @@ async function processCommand(ctx, command) {
       }
     }
     const finalStatus = commandResult.failed ? "failed" : "completed";
-    await ctx.client.mutation(api.machines.ackCommand, {
+    await ctx.deps.backend.mutation(api.machines.ackCommand, {
       sessionId: ctx.sessionId,
       commandId: command._id,
       status: finalStatus,
       result: commandResult.result
     });
-    if (commandResult.failed) {
-      console.log(`   ❌ Command failed: ${commandResult.result}`);
-    } else {
-      console.log(`   ✅ Command completed`);
-    }
-  } catch (error) {
-    console.error(`   ❌ Command failed: ${error.message}`);
-    try {
-      await ctx.client.mutation(api.machines.ackCommand, {
-        sessionId: ctx.sessionId,
-        commandId: command._id,
-        status: "failed",
-        result: error.message
-      });
-    } catch {}
-  }
-}
-async function discoverModels() {
-  const models = [];
-  try {
-    const registry = getDriverRegistry();
-    for (const driver of registry.all()) {
-      if (driver.capabilities.dynamicModelDiscovery) {
-        const driverModels = await driver.listModels();
-        models.push(...driverModels);
-      }
-    }
-  } catch {}
-  return models;
-}
-async function refreshModels(ctx) {
-  const models = await discoverModels();
-  if (!ctx.config)
-    return;
-  try {
-    await ctx.client.mutation(api.machines.register, {
-      sessionId: ctx.sessionId,
-      machineId: ctx.machineId,
-      hostname: ctx.config.hostname,
-      os: ctx.config.os,
-      availableHarnesses: ctx.config.availableHarnesses,
-      harnessVersions: ctx.config.harnessVersions,
-      availableModels: models
-    });
-    console.log(`[${formatTimestamp()}] \uD83D\uDD04 Model refresh: ${models.length > 0 ? `${models.length} models` : "none discovered"}`);
-  } catch (error) {
-    console.warn(`[${formatTimestamp()}] ⚠️  Model refresh failed: ${error.message}`);
-  }
-}
-async function initDaemon() {
-  if (!acquireLock()) {
-    process.exit(1);
-  }
-  const convexUrl = getConvexUrl();
-  const sessionId = getSessionId();
-  if (!sessionId) {
-    const otherUrls = getOtherSessionUrls();
-    console.error(`❌ Not authenticated for: ${convexUrl}`);
-    if (otherUrls.length > 0) {
-      console.error(`
-\uD83D\uDCA1 You have sessions for other environments:`);
-      for (const url of otherUrls) {
-        console.error(`   • ${url}`);
-      }
-    }
-    console.error(`
-Run: chatroom auth login`);
-    releaseLock();
-    process.exit(1);
-  }
-  const machineId = getMachineId();
-  if (!machineId) {
-    console.error(`❌ Machine not registered`);
-    console.error(`
-Run any chatroom command first to register this machine,`);
-    console.error(`for example: chatroom auth status`);
-    releaseLock();
-    process.exit(1);
-  }
-  const client2 = await getConvexClient();
-  const typedSessionId = sessionId;
-  const config3 = loadMachineConfig();
-  const availableModels = await discoverModels();
-  if (config3) {
-    try {
-      await client2.mutation(api.machines.register, {
-        sessionId: typedSessionId,
-        machineId,
-        hostname: config3.hostname,
-        os: config3.os,
-        availableHarnesses: config3.availableHarnesses,
-        harnessVersions: config3.harnessVersions,
-        availableModels
-      });
-    } catch (error) {
-      console.warn(`⚠️  Machine registration update failed: ${error.message}`);
-    }
-  }
-  try {
-    await client2.mutation(api.machines.updateDaemonStatus, {
-      sessionId: typedSessionId,
-      machineId,
-      connected: true
+    ctx.events.emit("command:completed", {
+      commandId: command._id.toString(),
+      type: command.type,
+      failed: commandResult.failed,
+      result: commandResult.result
     });
-  } catch (error) {
-    if (isNetworkError(error)) {
-      formatConnectivityError(error, convexUrl);
+    if (commandResult.failed) {
+      console.log(`   ❌ Command failed: ${commandResult.result}`);
     } else {
-      console.error(`❌ Failed to update daemon status: ${error.message}`);
+      console.log(`   ✅ Command completed`);
     }
-    releaseLock();
-    process.exit(1);
-  }
-  const ctx = { client: client2, sessionId: typedSessionId, machineId, config: config3 };
-  console.log(`[${formatTimestamp()}] \uD83D\uDE80 Daemon started`);
-  console.log(`   CLI version: ${getVersion()}`);
-  console.log(`   Machine ID: ${machineId}`);
-  console.log(`   Hostname: ${config3?.hostname ?? "Unknown"}`);
-  console.log(`   Available harnesses: ${config3?.availableHarnesses.join(", ") || "none"}`);
-  console.log(`   Available models: ${availableModels.length > 0 ? availableModels.length : "none discovered"}`);
-  console.log(`   PID: ${process.pid}`);
-  console.log(`
-[${formatTimestamp()}] \uD83D\uDD04 Recovering agent state...`);
-  try {
-    await recoverAgentState(ctx);
-  } catch (e) {
-    console.log(`   ⚠️  Recovery failed: ${e.message}`);
-    console.log(`   Continuing with fresh state`);
+  } catch (error) {
+    console.error(`   ❌ Command failed: ${error.message}`);
+    try {
+      await ctx.deps.backend.mutation(api.machines.ackCommand, {
+        sessionId: ctx.sessionId,
+        commandId: command._id,
+        status: "failed",
+        result: error.message
+      });
+    } catch {}
   }
-  return ctx;
 }
 async function startCommandLoop(ctx) {
   let heartbeatCount = 0;
   const heartbeatTimer = setInterval(() => {
-    ctx.client.mutation(api.machines.daemonHeartbeat, {
+    ctx.deps.backend.mutation(api.machines.daemonHeartbeat, {
       sessionId: ctx.sessionId,
       machineId: ctx.machineId
     }).then(() => {
@@ -13504,13 +13909,7 @@ async function startCommandLoop(ctx) {
     console.log(`
 [${formatTimestamp()}] Shutting down...`);
     clearInterval(heartbeatTimer);
-    try {
-      await ctx.client.mutation(api.machines.updateDaemonStatus, {
-        sessionId: ctx.sessionId,
-        machineId: ctx.machineId,
-        connected: false
-      });
-    } catch {}
+    await onDaemonShutdown(ctx);
     releaseLock();
     process.exit(0);
   };
@@ -13566,7 +13965,7 @@ Listening for commands...`);
         parsed.push(command);
       } else {
         try {
-          await ctx.client.mutation(api.machines.ackCommand, {
+          await ctx.deps.backend.mutation(api.machines.ackCommand, {
             sessionId: ctx.sessionId,
             commandId: raw._id,
             status: "failed",
@@ -13587,20 +13986,283 @@ Listening for commands...`);
   modelRefreshTimer.unref();
   return await new Promise(() => {});
 }
-async function daemonStart() {
-  const ctx = await initDaemon();
-  await startCommandLoop(ctx);
-}
-var MAX_CRASH_RESTART_ATTEMPTS = 3, CRASH_RESTART_DELAY_MS = 3000, MODEL_REFRESH_INTERVAL_MS;
-var init_daemon_start = __esm(() => {
+var MODEL_REFRESH_INTERVAL_MS;
+var init_command_loop = __esm(() => {
+  init_api3();
+  init_client2();
+  init_on_daemon_shutdown();
   init_pid();
+  init_start_agent();
+  init_stop_agent();
+  MODEL_REFRESH_INTERVAL_MS = 5 * 60 * 1000;
+});
+
+// src/commands/machine/daemon-start/handlers/state-recovery.ts
+async function recoverAgentState(ctx) {
+  const entries = ctx.deps.machine.listAgentEntries(ctx.machineId);
+  if (entries.length === 0) {
+    console.log(`   No agent entries found — nothing to recover`);
+    return;
+  }
+  let recovered = 0;
+  let cleared = 0;
+  for (const { chatroomId, role, entry } of entries) {
+    const { pid, harness } = entry;
+    const alive = ctx.remoteAgentService.isAlive(pid);
+    if (alive) {
+      console.log(`   ✅ Recovered: ${role} (PID ${pid}, harness: ${harness})`);
+      recovered++;
+    } else {
+      console.log(`   \uD83E\uDDF9 Stale PID ${pid} for ${role} — clearing`);
+      await clearAgentPidEverywhere(ctx, chatroomId, role);
+      cleared++;
+    }
+  }
+  console.log(`   Recovery complete: ${recovered} alive, ${cleared} stale cleared`);
+}
+var init_state_recovery = __esm(() => {
+  init_shared();
+});
+
+// src/commands/machine/daemon-start/event-bus.ts
+class DaemonEventBus {
+  listeners = new Map;
+  on(event, listener) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, new Set);
+    }
+    this.listeners.get(event).add(listener);
+    return () => {
+      this.listeners.get(event)?.delete(listener);
+    };
+  }
+  emit(event, payload) {
+    const set = this.listeners.get(event);
+    if (!set)
+      return;
+    for (const listener of set) {
+      try {
+        listener(payload);
+      } catch (err) {
+        console.warn(`[EventBus] Listener error on "${event}": ${err.message}`);
+      }
+    }
+  }
+  removeAllListeners() {
+    this.listeners.clear();
+  }
+}
+
+// src/commands/machine/daemon-start/event-listeners.ts
+function registerEventListeners(ctx) {
+  const unsubs = [];
+  unsubs.push(ctx.events.on("agent:exited", (payload) => {
+    const { chatroomId, role, pid, code: code2, signal, intentional } = payload;
+    const ts = formatTimestamp();
+    if (intentional) {
+      console.log(`[${ts}] ℹ️  Agent process exited after intentional stop ` + `(PID: ${pid}, role: ${role}, code: ${code2}, signal: ${signal})`);
+    } else {
+      console.log(`[${ts}] ⚠️  Agent process exited ` + `(PID: ${pid}, role: ${role}, code: ${code2}, signal: ${signal})`);
+    }
+    ctx.deps.backend.mutation(api.machines.updateSpawnedAgent, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId,
+      chatroomId,
+      role,
+      pid: undefined
+    }).catch((err) => {
+      console.log(`   ⚠️  Failed to clear PID in backend: ${err.message}`);
+    });
+    ctx.deps.machine.clearAgentPid(ctx.machineId, chatroomId, role);
+    ctx.remoteAgentService.untrack(pid);
+    ctx.deps.backend.mutation(api.participants.leave, {
+      sessionId: ctx.sessionId,
+      chatroomId,
+      role
+    }).catch((err) => {
+      console.log(`   ⚠️  Could not remove participant: ${err.message}`);
+    });
+  }));
+  unsubs.push(ctx.events.on("agent:started", (payload) => {
+    const ts = formatTimestamp();
+    console.log(`[${ts}] \uD83D\uDFE2 Agent started: ${payload.role} (PID: ${payload.pid}, harness: ${payload.harness})`);
+  }));
+  unsubs.push(ctx.events.on("agent:stopped", (payload) => {
+    const ts = formatTimestamp();
+    console.log(`[${ts}] \uD83D\uDD34 Agent stopped: ${payload.role} (PID: ${payload.pid})`);
+  }));
+  return () => {
+    for (const unsub of unsubs) {
+      unsub();
+    }
+  };
+}
+var init_event_listeners = __esm(() => {
+  init_api3();
+});
+
+// src/commands/machine/daemon-start/init.ts
+import { stat } from "node:fs/promises";
+async function discoverModels(service) {
+  try {
+    return await service.listModels();
+  } catch {
+    return [];
+  }
+}
+function createDefaultDeps16() {
+  return {
+    backend: {
+      mutation: async () => {
+        throw new Error("Backend not initialized");
+      },
+      query: async () => {
+        throw new Error("Backend not initialized");
+      }
+    },
+    processes: {
+      kill: (pid, signal) => process.kill(pid, signal)
+    },
+    fs: {
+      stat
+    },
+    stops: {
+      mark: markIntentionalStop,
+      consume: consumeIntentionalStop,
+      clear: clearIntentionalStop
+    },
+    machine: {
+      clearAgentPid,
+      persistAgentPid,
+      listAgentEntries
+    },
+    clock: {
+      now: () => Date.now(),
+      delay: (ms) => new Promise((resolve2) => setTimeout(resolve2, ms))
+    }
+  };
+}
+async function initDaemon() {
+  if (!acquireLock()) {
+    process.exit(1);
+  }
+  const convexUrl = getConvexUrl();
+  const sessionId = getSessionId();
+  if (!sessionId) {
+    const otherUrls = getOtherSessionUrls();
+    console.error(`❌ Not authenticated for: ${convexUrl}`);
+    if (otherUrls.length > 0) {
+      console.error(`
+\uD83D\uDCA1 You have sessions for other environments:`);
+      for (const url of otherUrls) {
+        console.error(`   • ${url}`);
+      }
+    }
+    console.error(`
+Run: chatroom auth login`);
+    releaseLock();
+    process.exit(1);
+  }
+  const machineId = getMachineId();
+  if (!machineId) {
+    console.error(`❌ Machine not registered`);
+    console.error(`
+Run any chatroom command first to register this machine,`);
+    console.error(`for example: chatroom auth status`);
+    releaseLock();
+    process.exit(1);
+  }
+  const client2 = await getConvexClient();
+  const typedSessionId = sessionId;
+  const config3 = loadMachineConfig();
+  const remoteAgentService = new OpenCodeAgentService;
+  const availableModels = await discoverModels(remoteAgentService);
+  if (config3) {
+    try {
+      await client2.mutation(api.machines.register, {
+        sessionId: typedSessionId,
+        machineId,
+        hostname: config3.hostname,
+        os: config3.os,
+        availableHarnesses: config3.availableHarnesses,
+        harnessVersions: config3.harnessVersions,
+        availableModels
+      });
+    } catch (error) {
+      console.warn(`⚠️  Machine registration update failed: ${error.message}`);
+    }
+  }
+  try {
+    await client2.mutation(api.machines.updateDaemonStatus, {
+      sessionId: typedSessionId,
+      machineId,
+      connected: true
+    });
+  } catch (error) {
+    if (isNetworkError(error)) {
+      formatConnectivityError(error, convexUrl);
+    } else {
+      console.error(`❌ Failed to update daemon status: ${error.message}`);
+    }
+    releaseLock();
+    process.exit(1);
+  }
+  const deps = createDefaultDeps16();
+  deps.backend.mutation = (endpoint, args) => client2.mutation(endpoint, args);
+  deps.backend.query = (endpoint, args) => client2.query(endpoint, args);
+  const events = new DaemonEventBus;
+  const ctx = {
+    client: client2,
+    sessionId: typedSessionId,
+    machineId,
+    config: config3,
+    deps,
+    events,
+    remoteAgentService
+  };
+  registerEventListeners(ctx);
+  console.log(`[${formatTimestamp()}] \uD83D\uDE80 Daemon started`);
+  console.log(`   CLI version: ${getVersion()}`);
+  console.log(`   Machine ID: ${machineId}`);
+  console.log(`   Hostname: ${config3?.hostname ?? "Unknown"}`);
+  console.log(`   Available harnesses: ${config3?.availableHarnesses.join(", ") || "none"}`);
+  console.log(`   Available models: ${availableModels.length > 0 ? `${availableModels.length} models` : "none discovered"}`);
+  console.log(`   PID: ${process.pid}`);
+  console.log(`
+[${formatTimestamp()}] \uD83D\uDD04 Recovering agent state...`);
+  try {
+    await recoverAgentState(ctx);
+  } catch (e) {
+    console.log(`   ⚠️  Recovery failed: ${e.message}`);
+    console.log(`   Continuing with fresh state`);
+  }
+  return ctx;
+}
+var init_init2 = __esm(() => {
+  init_state_recovery();
   init_api3();
-  init_agent_drivers();
   init_storage();
   init_client2();
   init_machine();
+  init_intentional_stops();
+  init_opencode();
+  init_error_formatting();
   init_version();
-  MODEL_REFRESH_INTERVAL_MS = 5 * 60 * 1000;
+  init_pid();
+  init_event_listeners();
+});
+
+// src/commands/machine/daemon-start/index.ts
+async function daemonStart() {
+  const ctx = await initDaemon();
+  await startCommandLoop(ctx);
+}
+var init_daemon_start = __esm(() => {
+  init_command_loop();
+  init_init2();
+  init_start_agent();
+  init_stop_agent();
+  init_state_recovery();
 });
 
 // src/commands/machine/daemon-stop.ts
@@ -13613,7 +14275,7 @@ async function daemonStop() {
   console.log(`Stopping daemon (PID: ${pid})...`);
   try {
     process.kill(pid, "SIGTERM");
-    await new Promise((resolve2) => setTimeout(resolve2, 1000));
+    await new Promise((resolve2) => setTimeout(resolve2, 8000));
     try {
       process.kill(pid, 0);
       console.log(`Process did not exit gracefully, forcing...`);
@@ -13661,29 +14323,56 @@ var init_machine2 = __esm(() => {
   init_daemon_status();
 });
 
-// src/commands/opencode-install.ts
+// src/commands/opencode-install/index.ts
 var exports_opencode_install = {};
 __export(exports_opencode_install, {
   installTool: () => installTool
 });
-async function isChatroomInstalled() {
+async function isChatroomInstalledDefault() {
   try {
-    const { execSync: execSync4 } = await import("child_process");
-    execSync4("chatroom --version", { stdio: "pipe" });
+    const { execSync: execSync3 } = await import("child_process");
+    execSync3("chatroom --version", { stdio: "pipe" });
     return true;
   } catch {
     return false;
   }
 }
-async function installTool(options = {}) {
+async function createDefaultDeps17() {
+  const client2 = await getConvexClient();
+  const fs = await import("fs/promises");
+  return {
+    backend: {
+      mutation: (endpoint, args) => client2.mutation(endpoint, args),
+      query: (endpoint, args) => client2.query(endpoint, args)
+    },
+    session: {
+      getSessionId,
+      getConvexUrl,
+      getOtherSessionUrls
+    },
+    fs: {
+      access: async (p) => {
+        await fs.access(p);
+      },
+      mkdir: async (p, options) => {
+        await fs.mkdir(p, options);
+      },
+      writeFile: async (p, content, encoding) => {
+        await fs.writeFile(p, content, encoding);
+      }
+    },
+    isChatroomInstalled: isChatroomInstalledDefault
+  };
+}
+async function installTool(options = {}, deps) {
+  const d = deps ?? await createDefaultDeps17();
   const { checkExisting = true } = options;
   const os = await import("os");
-  const fs = await import("fs/promises");
-  const path = await import("path");
+  const path2 = await import("path");
   const homeDir = os.homedir();
-  const toolDir = path.join(homeDir, ".config", "opencode", "tool");
-  const toolPath = path.join(toolDir, "chatroom.ts");
-  const handoffToolPath = path.join(toolDir, "chatroom-handoff.ts");
+  const toolDir = path2.join(homeDir, ".config", "opencode", "tool");
+  const toolPath = path2.join(toolDir, "chatroom.ts");
+  const handoffToolPath = path2.join(toolDir, "chatroom-handoff.ts");
   const toolContent = `import { tool } from "@opencode-ai/plugin";
 
 /**
@@ -13713,7 +14402,7 @@ async function checkChatroomStatus(): Promise<{ installed: boolean; authenticate
 
 export default tool({
   description:
-    "Wait for tasks in a multi-agent chatroom. This command joins a chatroom with a specific role and waits for tasks to be assigned. It's a long-running operation that polls for pending tasks and handles the complete workflow including authentication, task claiming, and graceful interruption handling. Use this instead of bash 'chatroom wait-for-task' to avoid timeout issues.",
+    "Get next task in a multi-agent chatroom. This command joins a chatroom with a specific role and waits for tasks to be assigned. It's a long-running operation that polls for pending tasks and handles the complete workflow including authentication, task claiming, and graceful interruption handling. Use this instead of bash 'chatroom get-next-task' to avoid timeout issues.",
   args: {
     chatroomId: tool.schema
       .string()
@@ -13773,7 +14462,7 @@ After logging in, try this command again.\`;
     }
 
     // Build command arguments
-    const cmdArgs = ['wait-for-task', args.chatroomId, '--role', args.role];
+    const cmdArgs = ['get-next-task', args.chatroomId, '--role', args.role];
 
     if (args.duration !== undefined) {
       cmdArgs.push('--duration', args.duration);
@@ -13790,7 +14479,7 @@ After logging in, try this command again.\`;
       env.CHATROOM_CONVEX_URL = args.convexUrl;
     }
 
-    // Execute the wait-for-task command
+    // Execute the get-next-task command
     // This is a long-running operation that polls for tasks
     const proc = Bun.spawn(['chatroom', ...cmdArgs], { 
       stdout: 'pipe',
@@ -13967,11 +14656,11 @@ After logging in, try this command again.\`;
     if (checkExisting) {
       const existingFiles = [];
       try {
-        await fs.access(toolPath);
+        await d.fs.access(toolPath);
         existingFiles.push(toolPath);
       } catch {}
       try {
-        await fs.access(handoffToolPath);
+        await d.fs.access(handoffToolPath);
         existingFiles.push(handoffToolPath);
       } catch {}
       if (existingFiles.length > 0) {
@@ -13991,7 +14680,7 @@ Then run this command again, or use --force to overwrite.`;
         };
       }
     }
-    const installed = await isChatroomInstalled();
+    const installed = await d.isChatroomInstalled();
     if (!installed) {
       const message2 = `⚠️  Chatroom CLI is not installed.
 
@@ -14005,9 +14694,9 @@ After installation, run this command again.`;
         message: message2
       };
     }
-    await fs.mkdir(toolDir, { recursive: true });
-    await fs.writeFile(toolPath, toolContent, "utf-8");
-    await fs.writeFile(handoffToolPath, handoffToolContent, "utf-8");
+    await d.fs.mkdir(toolDir, { recursive: true });
+    await d.fs.writeFile(toolPath, toolContent, "utf-8");
+    await d.fs.writeFile(handoffToolPath, handoffToolContent, "utf-8");
     const message = `✅ Installed chatroom OpenCode tools successfully!
 
 Locations:
@@ -14015,7 +14704,7 @@ Locations:
   • ${handoffToolPath}
 
 The following commands are now available in OpenCode:
-  • chatroom (wait-for-task) - Join chatroom and wait for tasks (no more timeouts!)
+  • chatroom (get-next-task) - Get next task from chatroom (no more timeouts!)
   • chatroom-handoff - Complete your task and hand off to the next role
 
 Both tools will automatically check for:
@@ -14043,8 +14732,56 @@ If you're not authenticated, run:
     };
   }
 }
+var init_opencode_install = __esm(() => {
+  init_storage();
+  init_client2();
+});
+
+// src/infrastructure/retry-queue.ts
+async function withRetry(fn, opts) {
+  const { maxRetries, baseDelayMs, maxDelayMs } = { ...DEFAULTS, ...opts };
+  for (let attempt = 0;attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (e) {
+      if (attempt === maxRetries) {
+        console.warn(`[retry-queue] All ${maxRetries + 1} attempts exhausted: ${e.message}`);
+        return;
+      }
+      const delay = Math.min(baseDelayMs * 2 ** attempt, maxDelayMs);
+      await new Promise((resolve2) => setTimeout(resolve2, delay));
+    }
+  }
+  return;
+}
+var DEFAULTS;
+var init_retry_queue = __esm(() => {
+  DEFAULTS = {
+    maxRetries: 3,
+    baseDelayMs: 500,
+    maxDelayMs: 5000
+  };
+});
+
+// src/infrastructure/lifecycle-heartbeat.ts
+var exports_lifecycle_heartbeat = {};
+__export(exports_lifecycle_heartbeat, {
+  sendLifecycleHeartbeat: () => sendLifecycleHeartbeat
+});
+function sendLifecycleHeartbeat(client2, opts) {
+  withRetry(() => client2.mutation(api.participants.join, {
+    sessionId: opts.sessionId,
+    chatroomId: opts.chatroomId,
+    role: opts.role,
+    ...opts.action !== undefined ? { action: opts.action } : {}
+  })).catch(() => {});
+}
+var init_lifecycle_heartbeat = __esm(() => {
+  init_api3();
+  init_retry_queue();
+});
 
-// ../../node_modules/.pnpm/commander@14.0.2/node_modules/commander/esm.mjs
+// ../../node_modules/.pnpm/commander@14.0.3/node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
 var {
   program,
@@ -14089,8 +14826,8 @@ async function maybeRequireAuth() {
     console.log("⚠️  Skipping authentication (--skip-auth flag)");
     return;
   }
-  const { requireAuth: requireAuth2 } = await Promise.resolve().then(() => (init_middleware(), exports_middleware));
-  await requireAuth2();
+  const { requireAuth: requireAuth3 } = await Promise.resolve().then(() => (init_middleware(), exports_middleware));
+  await requireAuth3();
 }
 var authCommand = program2.command("auth").description("Manage CLI authentication");
 authCommand.command("login").description("Authenticate the CLI via browser").option("-f, --force", "Re-authenticate even if already logged in").action(async (options) => {
@@ -14109,6 +14846,10 @@ program2.command("update").description("Update the CLI to the latest version").a
   const { update: update2 } = await Promise.resolve().then(() => (init_update(), exports_update));
   await update2();
 });
+program2.command("init").description("Initialize chatroom integration in your project").option("--dir <path>", "Directory to initialize (default: current directory)").action(async (options) => {
+  const { init: init2 } = await Promise.resolve().then(() => (init_init(), exports_init));
+  await init2({ dir: options.dir });
+});
 program2.command("register-agent").description("Register agent type for a chatroom role").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Role to register as (e.g., builder, reviewer)").requiredOption("--type <type>", "Agent type: remote or custom").action(async (options) => {
   await maybeRequireAuth();
   if (options.type !== "remote" && options.type !== "custom") {
@@ -14121,10 +14862,10 @@ program2.command("register-agent").description("Register agent type for a chatro
     type: options.type
   });
 });
-program2.command("wait-for-task").description("Join a chatroom and wait for tasks").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Role to join as (e.g., builder, reviewer)").action(async (options) => {
+program2.command("get-next-task").description("Join a chatroom and get the next task").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Role to join as (e.g., builder, reviewer)").action(async (options) => {
   await maybeRequireAuth();
-  const { waitForTask: waitForTask2 } = await Promise.resolve().then(() => (init_wait_for_task(), exports_wait_for_task));
-  await waitForTask2(options.chatroomId, {
+  const { getNextTask: getNextTask2 } = await Promise.resolve().then(() => (init_get_next_task(), exports_get_next_task));
+  await getNextTask2(options.chatroomId, {
     role: options.role
   });
 });
@@ -14177,13 +14918,6 @@ program2.command("task-started").description("Acknowledge a task and optionally
     noClassify: skipClassification
   });
 });
-program2.command("task-complete").description("Complete the current task without handing off to another role").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Your role").action(async (options) => {
-  await maybeRequireAuth();
-  const { taskComplete: taskComplete2 } = await Promise.resolve().then(() => (init_task_complete(), exports_task_complete));
-  await taskComplete2(options.chatroomId, {
-    role: options.role
-  });
-});
 program2.command("handoff").description("Complete your task and hand off to the next role").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Your role").requiredOption("--next-role <nextRole>", "Role to hand off to").option("--attach-artifact <artifactId>", "Attach artifact to handoff (can be used multiple times)", (value, previous) => {
   return previous ? [...previous, value] : [value];
 }, []).action(async (options) => {
@@ -14292,11 +15026,6 @@ backlogCommand.command("score").description("Score a backlog task by complexity,
   const { scoreBacklog: scoreBacklog2 } = await Promise.resolve().then(() => (init_backlog(), exports_backlog));
   await scoreBacklog2(options.chatroomId, options);
 });
-backlogCommand.command("reset-task").description("Reset a stuck in_progress task back to pending").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Your role").requiredOption("--task-id <taskId>", "Task ID to reset").action(async (options) => {
-  await maybeRequireAuth();
-  const { resetBacklog: resetBacklog2 } = await Promise.resolve().then(() => (init_backlog(), exports_backlog));
-  await resetBacklog2(options.chatroomId, options);
-});
 backlogCommand.command("mark-for-review").description("Mark a backlog task as ready for user review (backlog → pending_user_review)").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Your role").requiredOption("--task-id <taskId>", "Task ID to mark for review").action(async (options) => {
   await maybeRequireAuth();
   const { markForReviewBacklog: markForReviewBacklog2 } = await Promise.resolve().then(() => (init_backlog(), exports_backlog));
@@ -14336,7 +15065,7 @@ contextCommand.command("read").description("Read context for your role (conversa
   const { readContext: readContext2 } = await Promise.resolve().then(() => (init_context(), exports_context));
   await readContext2(options.chatroomId, options);
 });
-contextCommand.command("new").description("Create a new context and pin it for all agents").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Your role (creator of the context)").option("--content <content>", "Context summary/description (alternative: provide via stdin/heredoc)").action(async (options) => {
+contextCommand.command("new").description("Create a new context and pin it for all agents").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Your role (creator of the context)").option("--content <content>", "Context summary/description (alternative: provide via stdin/heredoc)").option("--trigger-message-id <messageId>", "Message ID that triggered this context (anchors the context window)").action(async (options) => {
   await maybeRequireAuth();
   let content;
   if (options.content && options.content.trim().length > 0) {
@@ -14401,6 +15130,11 @@ artifactCommand.command("view-many").description("View multiple artifacts").requ
     artifactIds: options.artifact || []
   });
 });
+program2.command("get-system-prompt").description("Fetch the system prompt for your role in a chatroom").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Your role (e.g., planner, builder, reviewer)").action(async (options) => {
+  await maybeRequireAuth();
+  const { getSystemPrompt: getSystemPrompt2 } = await Promise.resolve().then(() => (init_get_system_prompt(), exports_get_system_prompt));
+  await getSystemPrompt2(options.chatroomId, { role: options.role });
+});
 var machineCommand = program2.command("machine").description("Machine daemon management for remote agent control");
 var daemonCommand = machineCommand.command("daemon").description("Manage the machine daemon");
 daemonCommand.command("start").description("Start the machine daemon to listen for remote commands").action(async () => {
@@ -14418,7 +15152,22 @@ daemonCommand.command("status").description("Check if the machine daemon is runn
 });
 var opencodeCommand = program2.command("opencode").description("OpenCode integration harness");
 opencodeCommand.command("install").description("Install chatroom as an OpenCode harness").option("--force", "Overwrite existing harness installation").action(async (options) => {
-  const { installTool: installTool2 } = await Promise.resolve().then(() => exports_opencode_install);
+  const { installTool: installTool2 } = await Promise.resolve().then(() => (init_opencode_install(), exports_opencode_install));
   await installTool2({ checkExisting: !options.force });
 });
+program2.hook("preAction", async (_thisCommand, actionCommand) => {
+  const opts = actionCommand.opts();
+  const chatroomId = opts["chatroomId"];
+  const role = opts["role"];
+  if (!chatroomId || !role)
+    return;
+  const { getSessionId: getSessionId2 } = await Promise.resolve().then(() => (init_storage(), exports_storage));
+  const { getConvexClient: getConvexClient2 } = await Promise.resolve().then(() => (init_client2(), exports_client));
+  const { sendLifecycleHeartbeat: sendLifecycleHeartbeat2 } = await Promise.resolve().then(() => (init_lifecycle_heartbeat(), exports_lifecycle_heartbeat));
+  const sessionId = getSessionId2();
+  if (!sessionId)
+    return;
+  const client2 = await getConvexClient2();
+  sendLifecycleHeartbeat2(client2, { sessionId, chatroomId, role, action: actionCommand.name() });
+});
 program2.parse();