very-happy-cli 0.2.198 → 0.2.200

package/dist/{run-Be0yicft.cjs → run-CVAIFpsp.cjs}

@@ -1,28 +1,28 @@
 'use strict';
 
-var mirrorProtocol = require('./mirrorProtocol-CNF1eHsm.cjs');
+var mirrorProtocol = require('./mirrorProtocol-CCl9dtzh.cjs');
 var fsMkdir = require('./fsMkdir-0K3yENml.cjs');
-var piRunnerArgs = require('./piRunnerArgs-C1dLsoXF.cjs');
+var piRunnerArgs = require('./piRunnerArgs-DOEJJymf.cjs');
 var fs = require('fs/promises');
 var os$1 = require('os');
 var tmp = require('tmp');
 var axios = require('axios');
 var node_fs = require('node:fs');
 var path = require('node:path');
-var configuration = require('./configuration-DfRs3WLd.cjs');
-var api = require('./api-te19Pzi3.cjs');
-var spawnAgents = require('./spawnAgents-CrHgpAzU.cjs');
-var logger = require('./logger-BrAF4iuT.cjs');
-var index$2 = require('./index-EGwuuFdL.cjs');
-var auth = require('./auth-SH0o7ue7.cjs');
+var configuration = require('./configuration-ClUt7pqs.cjs');
+var api = require('./api-BPWRzeNF.cjs');
+var spawnAgents = require('./spawnAgents-IiuqX0S5.cjs');
+var logger = require('./logger-D28MY1Bv.cjs');
+var index$2 = require('./index-DUwOmhnq.cjs');
+var auth = require('./auth-oAnLi4Tl.cjs');
 var child_process = require('child_process');
-var _package = require('./package-CStJrLG3.cjs');
-var doctor = require('./doctor-Dn1G6QhF.cjs');
-var spawnHappyCLI = require('./spawnHappyCLI-CYzlz9Sl.cjs');
-var persistence = require('./persistence-DGfEdbA5.cjs');
-var controlClient = require('./controlClient-B61crTpk.cjs');
-var sessionOps = require('./sessionOps-Cw_JivR2.cjs');
-var index = require('./index-BknTkVnR.cjs');
+var _package = require('./package-BFSsS_dl.cjs');
+var doctor = require('./doctor-C9D-t20z.cjs');
+var spawnHappyCLI = require('./spawnHappyCLI-C3XuIB2N.cjs');
+var persistence = require('./persistence-TpVFA5-I.cjs');
+var controlClient = require('./controlClient-SYDFcIkk.cjs');
+var sessionOps = require('./sessionOps-CIFvoFPA.cjs');
+var index = require('./index-BiutHOAO.cjs');
 var fastify = require('fastify');
 var z = require('zod');
 var fastifyTypeProviderZod = require('fastify-type-provider-zod');
@@ -30,68 +30,69 @@ var authRelay = require('./authRelay-Dy1qU9td.cjs');
 var node_crypto = require('node:crypto');
 var previewPath = require('./previewPath-B0rBdhy1.cjs');
 var backgroundTaskActivity = require('./backgroundTaskActivity-CBvUdj39.cjs');
-var rateLimitWindows = require('./rateLimitWindows-DiiGHS9r.cjs');
-var peerTools = require('./peerTools-Drow2-P4.cjs');
+var rateLimitWindows = require('./rateLimitWindows-BREA7OZj.cjs');
+var peerTools = require('./peerTools-Z8V2E0AF.cjs');
 var os = require('node:os');
-var remoteSessionClient = require('./remoteSessionClient-DSC5Cj21.cjs');
-var bootstrap = require('./bootstrap-GZDknvPy.cjs');
-var index$1 = require('./index-DCfEzudP.cjs');
+var remoteSessionClient = require('./remoteSessionClient-DleOeQlN.cjs');
+var bootstrap = require('./bootstrap-DUKAKxrJ.cjs');
+var index$1 = require('./index-CbzettaI.cjs');
 var require$$0 = require('fs');
 var require$$1 = require('path');
 var node_child_process = require('node:child_process');
 var projectPath = require('./projectPath-C3ioB4Bu.cjs');
 var doctorReadiness = require('./doctorReadiness-Dl6yRQCy.cjs');
-var machineMetadata = require('./machineMetadata-D5PO2ylb.cjs');
+var machineMetadata = require('./machineMetadata-BzjrIn_N.cjs');
 var fileStore = require('./fileStore-7qhnbs6N.cjs');
 var pi = require('./pi-DlsrPCTa.cjs');
-var codexAccount = require('./codexAccount-CQ4W1Ax8.cjs');
+var codexAccount = require('./codexAccount-DfeCHUOU.cjs');
 var require$$3 = require('crypto');
 var detectCLI = require('./detectCLI-BuYR_Qxe.cjs');
-var handleResumeCommand = require('./handleResumeCommand-hzho-lp7.cjs');
+var handleResumeCommand = require('./handleResumeCommand-CjCtwrrm.cjs');
 var webPanels = require('./webPanels-FCgFKvVe.cjs');
 var promises = require('node:fs/promises');
 var cliUpdate = require('./cliUpdate-DsKXPFYp.cjs');
-var client = require('./client-D-HEr922.cjs');
-var sessionLock = require('./sessionLock-CJiayMcZ.cjs');
-var client$1 = require('./client-oqSAKwmy.cjs');
+var client = require('./client-BnoN4P4t.cjs');
+var sessionLock = require('./sessionLock-DglhFHzB.cjs');
+var client$1 = require('./client-D0_UOmC1.cjs');
 var daemonSupervisor = require('./daemonSupervisor-alqGPANc.cjs');
-var accountService = require('./accountService-BWUjgHl0.cjs');
-var daemonAccounts = require('./daemonAccounts-CqAnPXDJ.cjs');
+var accountService = require('./accountService-BDJo14mY.cjs');
+var daemonAccounts = require('./daemonAccounts-Ch_rSTSX.cjs');
 var path$1 = require('./path-B7zW-WwE.cjs');
 var editPaths = require('./editPaths-Bqp4OFPw.cjs');
-var startFileWatcher = require('./startFileWatcher-C0u3J6Bj.cjs');
-var sync = require('./sync-BO4DRSub.cjs');
+var startFileWatcher = require('./startFileWatcher-CeDJl9mN.cjs');
+var sync = require('./sync-BvxhuW9R.cjs');
 var types = require('./types-CRS-srZK.cjs');
 var tmuxSocket = require('./tmuxSocket-Dg11Olx0.cjs');
 var processTermination = require('./processTermination-f17wxlMb.cjs');
 var doctor$1 = require('./doctor-CJpFhHoK.cjs');
 var resources = require('./resources-BZ_Be0qM.cjs');
 var node_util = require('node:util');
-var template = require('./template-uSKZ53Sv.cjs');
+var template = require('./template-M1YGFYUT.cjs');
+var client$2 = require('./client-1zIbVVX5.cjs');
 var loginShellEnv = require('./loginShellEnv-BkuYtExZ.cjs');
-var store = require('./store-QBBJB5Ox.cjs');
-require('./acpSessionResume-CeQu84Ol.cjs');
-require('./pushNotifications-3YsyCEfY.cjs');
+var store = require('./store-DOZAMV4W.cjs');
+require('./acpSessionResume-B_W8uTI6.cjs');
+require('./pushNotifications-C1i2W1GQ.cjs');
 require('./contentLogMetadata-ZSFk_NjQ.cjs');
-require('./reconnectGate-BpePVLPu.cjs');
+require('./reconnectGate-YQ5jXJfY.cjs');
 require('node:events');
 require('socket.io-client');
 require('./limits-C-a7gr04.cjs');
-require('./time-Cv4hbCLT.cjs');
-require('./registerCommonHandlers-6iKpECuR.cjs');
+require('./time-D-v2Cd9e.cjs');
+require('./registerCommonHandlers-D95IxqDN.cjs');
 require('util');
 require('cross-spawn');
 require('@paralleldrive/cuid2');
 require('chalk');
 require('node:module');
 require('tweetnacl');
-require('./browser-DwCi-9Ya.cjs');
+require('./browser-Ds-N-Dup.cjs');
 require('open');
 require('./specialCommands-J3JFOq0J.cjs');
 require('./ids-B6ZC0HGt.cjs');
 require('url');
-require('./localHappyAgentAuth-B6xdH-Fr.cjs');
-require('./claudeAccountEnv-DSaFKajJ.cjs');
+require('./localHappyAgentAuth-CjtNcaI0.cjs');
+require('./claudeAccountEnv-D33xXRE7.cjs');
 require('node:readline');
 require('node-pty');
 require('./processTreeSnapshot-D5iNblp6.cjs');
@@ -7028,6 +7029,337 @@ ${action.prompt}`, { localId: `automation-${run.id}`, ...meta });
   };
 }
 
+const ID = /^[A-Za-z0-9_-]{1,128}$/;
+const ISSUE_RECEIPT_TTL_MS = 7 * 24 * 36e5;
+function dir(home) {
+  return path.join(home, "issues", "receipts");
+}
+function readIssueReceipt(home, dispatchId) {
+  if (!ID.test(dispatchId)) return null;
+  try {
+    return JSON.parse(node_fs.readFileSync(path.join(dir(home), `${dispatchId}.json`), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeIssueReceipt(home, receipt) {
+  if (!ID.test(receipt.dispatchId)) throw new Error("Invalid dispatch id");
+  configuration.ensurePrivateDirectorySync(dir(home));
+  configuration.writePrivateFileSync(path.join(dir(home), `${receipt.dispatchId}.json`), JSON.stringify({ ...receipt, updatedAt: Date.now() }));
+}
+function listIssueReceipts(home, now = Date.now()) {
+  let files;
+  try {
+    files = node_fs.readdirSync(dir(home));
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const file of files) {
+    if (!file.endsWith(".json")) continue;
+    const path$1 = path.join(dir(home), file);
+    try {
+      const receipt = JSON.parse(node_fs.readFileSync(path$1, "utf8"));
+      const at = typeof receipt.updatedAt === "number" ? receipt.updatedAt : node_fs.statSync(path$1).mtimeMs;
+      if (now - at > ISSUE_RECEIPT_TTL_MS) {
+        node_fs.unlinkSync(path$1);
+        continue;
+      }
+      out.push(receipt);
+    } catch {
+    }
+  }
+  return out;
+}
+
+const ISSUE_POLL_MS = 5e3;
+const ISSUE_SPAWNED_BY = "issue";
+const FIRST_MESSAGE_KEY_WAIT_MS = 1e4;
+function issueKeyFromPrompt(prompt) {
+  return /^You are assigned issue ([A-Z]+-\d{1,9}):/.exec(prompt)?.[1] ?? null;
+}
+function issueSpawnAccount(spawn) {
+  if (spawn.agentProfile === void 0) return void 0;
+  return spawn.agentProfile === null ? null : spawn.agentProfile.id;
+}
+function issueAccountRefusal(resolve, agent, requested) {
+  if (!resolve) return null;
+  if (agent !== "claude" && agent !== "codex") return typeof requested === "string" ? `Account unavailable (agent-mismatch): accounts are not supported for ${agent} yet` : null;
+  try {
+    resolve(agent, requested);
+    return null;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return accountUnavailableError(message, "issue");
+  }
+}
+function issueExitEvent(exit) {
+  if (!exit) return "exited";
+  if (exit.signal) return ["SIGTERM", "SIGINT", "SIGHUP"].includes(exit.signal) ? "exited" : "crashed";
+  return exit.code === 0 || exit.code === null || exit.code === 130 || exit.code === 143 ? "exited" : "crashed";
+}
+function persistedRunSessions(runId) {
+  return Object.entries(persistence.readPersistedSessions()).filter(([, entry]) => entry.metadata?.issue?.runId === runId).map(([sessionId]) => sessionId);
+}
+function httpCode(error) {
+  return error instanceof client$2.IssueRequestError ? error.code : null;
+}
+function createIssueWorker(deps) {
+  const home = deps.home ?? configuration.configuration.happyHomeDir;
+  const client = deps.client;
+  const send = deps.send ?? (async (sessionId, text, options) => {
+    const key = await sessionOps.waitForSessionKey(sessionId, FIRST_MESSAGE_KEY_WAIT_MS);
+    await sessionOps.sendUserMessage(sessionId, key, text, "issue", options);
+  });
+  const capabilities = deps.capabilities ?? ((sessionId) => persistence.readPersistedSessions()[sessionId]?.metadata?.capabilities ?? null);
+  let running = false;
+  let closed = false;
+  let retryAt = 0;
+  const runBySession = /* @__PURE__ */ new Map();
+  const lastEvent = /* @__PURE__ */ new Map();
+  const events = [];
+  for (const r of listIssueReceipts(home)) {
+    if (r.kind === "spawn" && r.sessionId && !r.ended && (r.phase === "delivered" || r.phase === "completed")) runBySession.set(r.sessionId, r.runId);
+  }
+  const save = (receipt) => {
+    writeIssueReceipt(home, receipt);
+    return receipt;
+  };
+  async function fail(receipt, error, unknown = false) {
+    await client.fail(receipt.dispatchId, { machineId: deps.machineId, claimId: receipt.claimId, error: error.slice(0, 4e3), ...unknown ? { unknown: true } : {} });
+    save({ ...receipt, phase: unknown ? receipt.phase : "failed" });
+    deps.log(`Issue dispatch ${receipt.dispatchId} ${unknown ? "outcome unknown" : "failed"}`);
+  }
+  async function complete(receipt) {
+    let lastError;
+    for (let attempt = 0; attempt < 3; attempt++) {
+      try {
+        await client.complete(receipt.dispatchId, { machineId: deps.machineId, claimId: receipt.claimId, sessionId: receipt.sessionId });
+        save({ ...receipt, phase: "completed" });
+        return;
+      } catch (error) {
+        lastError = error;
+        if (httpCode(error) === "issue_dispatch_claim_mismatch" || error instanceof client$2.IssuesUnsupportedError) break;
+        await new Promise((resolve) => setTimeout(resolve, 500 * (attempt + 1)));
+      }
+    }
+    throw lastError;
+  }
+  async function runSpawn(view, receipt) {
+    const spawn = view.spawn;
+    if (receipt.phase === "failed") {
+      await fail(receipt, "This dispatch already failed on this machine");
+      return;
+    }
+    if (!spawn) {
+      await fail(receipt, "Dispatch has no spawn payload");
+      return;
+    }
+    const agent = spawn.agent;
+    if (receipt.phase === "claimed") {
+      if (!index.ISSUE_ASSIGNABLE_AGENTS.includes(agent)) {
+        await fail(receipt, `Agent "${agent}" cannot run issues on this machine`);
+        return;
+      }
+      if (!path.isAbsolute(spawn.directory)) {
+        await fail(receipt, `Directory must be absolute: ${spawn.directory}`);
+        return;
+      }
+      const account = issueSpawnAccount(spawn);
+      const refusal = issueAccountRefusal(deps.resolveAccount, agent, account);
+      if (refusal) {
+        await fail(receipt, refusal);
+        return;
+      }
+      const mode = spawnAgents.sanitizeSpawnPermissionMode(spawn.permissionMode ?? void 0);
+      const permissionMode = spawnAgents.resolveSpawnPermissionMode(agent, mode ?? void 0);
+      const key = issueKeyFromPrompt(spawn.prompt);
+      receipt = save({ ...receipt, phase: "spawning" });
+      const spawned = await deps.spawn({
+        directory: spawn.directory,
+        agent,
+        permissionMode,
+        spawnedBy: ISSUE_SPAWNED_BY,
+        environmentVariables: { VH_ISSUE_ID: view.issueId, VH_ISSUE_RUN_ID: view.runId, ...key ? { VH_ISSUE_KEY: key } : {} },
+        ...account !== void 0 ? { agentProfileId: account } : {}
+      });
+      if (spawned.type === "error" && index.agentProfileUnavailableReason(spawned.errorMessage)) {
+        await fail({ ...receipt, phase: "claimed" }, accountUnavailableError(spawned.errorMessage, "issue") ?? spawned.errorMessage);
+        return;
+      }
+      if (spawned.type === "error" && spawned.startupExit?.exited) {
+        await fail(receipt, `Session failed to start: ${spawned.errorMessage}`);
+        return;
+      }
+      if (spawned.type === "requestToApproveDirectoryCreation") {
+        await fail(receipt, `Directory does not exist on this machine: ${spawn.directory}`);
+        return;
+      }
+      if (spawned.type !== "success") {
+        const matches = persistedRunSessions(view.runId);
+        if (matches.length !== 1) {
+          await fail(receipt, `Spawn outcome unknown: ${spawned.errorMessage}`, true);
+          return;
+        }
+        receipt = save({ ...receipt, sessionId: matches[0], phase: "spawned" });
+      } else {
+        receipt = save({ ...receipt, sessionId: spawned.sessionId, phase: "spawned" });
+      }
+      runBySession.set(receipt.sessionId, view.runId);
+      if (spawn.projectId && deps.joinProject) await deps.joinProject(receipt.sessionId, spawn.projectId).catch(() => void 0);
+    }
+    if (receipt.phase === "spawning") {
+      const matches = persistedRunSessions(view.runId);
+      if (matches.length !== 1) {
+        await fail(receipt, "Spawn outcome unknown; verify the old process before retrying", true);
+        return;
+      }
+      receipt = save({ ...receipt, sessionId: matches[0], phase: "spawned" });
+      runBySession.set(receipt.sessionId, view.runId);
+    }
+    if (receipt.phase === "spawned") {
+      const sessionId = receipt.sessionId;
+      const mode = spawnAgents.sanitizeSpawnPermissionMode(spawn.permissionMode ?? void 0);
+      const permissionMode = spawnAgents.resolveSpawnPermissionMode(agent, mode ?? void 0);
+      const meta = spawnAgents.resolveFirstMessageMeta({ agent, permissionMode, explicitModel: spawn.model ?? void 0, capabilities: capabilities(sessionId) });
+      try {
+        await send(sessionId, spawn.prompt, { localId: `${index.ISSUE_DISPATCH_LOCAL_ID_PREFIX}${view.id}`, sentFrom: index.ISSUE_SENT_FROM, ...meta });
+      } catch (error) {
+        await fail(receipt, `First message failed: ${error instanceof Error ? error.message : String(error)}`);
+        return;
+      }
+      receipt = save({ ...receipt, phase: "delivered" });
+    }
+    if (receipt.phase === "delivered" || receipt.phase === "completed") {
+      await complete(receipt);
+      lastEvent.set(receipt.sessionId, "running");
+    }
+  }
+  async function runMessage(view, receipt) {
+    const message = view.message;
+    if (receipt.phase === "failed") {
+      await fail(receipt, "Session is not running on this machine");
+      return;
+    }
+    if (!message) {
+      await fail(receipt, "Dispatch has no message payload");
+      return;
+    }
+    if (receipt.phase === "claimed") {
+      if (!deps.live(message.sessionId)) {
+        await fail(receipt, "Session is not running on this machine");
+        return;
+      }
+      try {
+        await send(message.sessionId, message.text, { localId: `${index.ISSUE_DISPATCH_LOCAL_ID_PREFIX}${view.id}`, sentFrom: index.ISSUE_SENT_FROM });
+      } catch (error) {
+        await fail(receipt, `Message delivery failed: ${error instanceof Error ? error.message : String(error)}`);
+        return;
+      }
+      receipt = save({ ...receipt, sessionId: message.sessionId, phase: "delivered" });
+    }
+    await complete({ ...receipt, sessionId: receipt.sessionId ?? message.sessionId });
+  }
+  async function execute(polled) {
+    let claimed;
+    try {
+      claimed = (await client.claim(polled.id, deps.machineId)).dispatch;
+    } catch (error) {
+      const code = httpCode(error);
+      if (code === "issue_dispatch_claim_mismatch" || code === "issue_run_not_current" || code === "issue_dispatch_not_found") return;
+      throw error;
+    }
+    if (!claimed.claimId) throw new Error("Dispatch claim did not return a claim id");
+    const prior = readIssueReceipt(home, claimed.id);
+    const receipt = save(prior ? { ...prior, claimId: claimed.claimId } : { dispatchId: claimed.id, kind: claimed.kind === "message" ? "message" : "spawn", runId: claimed.runId, issueId: claimed.issueId, claimId: claimed.claimId, phase: "claimed", updatedAt: Date.now() });
+    if (claimed.kind === "message") await runMessage(claimed, receipt);
+    else if (claimed.kind === "spawn") await runSpawn(claimed, receipt);
+    else await fail(receipt, `Unknown dispatch kind "${claimed.kind}"`);
+  }
+  let flushing = false;
+  async function flushEvents() {
+    if (flushing) return;
+    flushing = true;
+    try {
+      await drainEvents();
+    } finally {
+      flushing = false;
+    }
+  }
+  async function drainEvents() {
+    while (events.length && !closed) {
+      const next = events[0];
+      try {
+        await client.sessionEvent(next.runId, { machineId: deps.machineId, sessionId: next.sessionId, event: next.event });
+      } catch (error) {
+        const code = httpCode(error);
+        if (!(error instanceof client$2.IssuesUnsupportedError) && code !== "issue_run_not_found" && !(error instanceof client$2.IssueRequestError && error.status < 500 && error.status !== 429)) return;
+      }
+      events.shift();
+      if (next.event === "exited" || next.event === "crashed") {
+        runBySession.delete(next.sessionId);
+        lastEvent.delete(next.sessionId);
+        for (const r of listIssueReceipts(home)) if (r.sessionId === next.sessionId && r.kind === "spawn") save({ ...r, ended: true });
+      }
+    }
+  }
+  async function tick() {
+    if (running || closed || Date.now() < retryAt) return;
+    running = true;
+    try {
+      let dispatches;
+      try {
+        dispatches = (await client.poll(deps.machineId)).dispatches ?? [];
+      } catch (error) {
+        if (!(error instanceof client$2.IssuesUnsupportedError)) {
+          retryAt = Date.now() + 3e4;
+          deps.log(`Issue dispatch poll unavailable${error instanceof client$2.IssueRequestError ? ` (${error.status}${error.code ? ` ${error.code}` : ""})` : ""}`);
+        }
+        return;
+      }
+      for (const dispatch of dispatches) {
+        if (closed) break;
+        try {
+          await execute(dispatch);
+        } catch (error) {
+          deps.log(`Issue dispatch ${dispatch.id} remains pending${error instanceof client$2.IssueRequestError && error.code ? ` (${error.code})` : ""}`);
+        }
+      }
+      await flushEvents();
+    } finally {
+      running = false;
+    }
+  }
+  let timer;
+  if (deps.autoStart !== false) {
+    timer = setInterval(() => {
+      void tick();
+    }, ISSUE_POLL_MS);
+    timer.unref();
+    void tick();
+  }
+  return {
+    tick,
+    hasSession: (sessionId) => runBySession.has(sessionId),
+    /** Daemon hooks (turn start/end, wrapper exit) → run session event; deduplicated per session. */
+    report(sessionId, event) {
+      const runId = runBySession.get(sessionId);
+      if (!runId || closed || lastEvent.get(sessionId) === event) return;
+      lastEvent.set(sessionId, event);
+      events.push({ sessionId, runId, event });
+      if (events.length > 500) events.splice(0, events.length - 500);
+      void flushEvents();
+    },
+    get busy() {
+      return running;
+    },
+    stop: () => {
+      closed = true;
+      if (timer) clearInterval(timer);
+    }
+  };
+}
+
 function daemonExitCode(source) {
   return source === "exception" ? 1 : 0;
 }
@@ -7183,6 +7515,7 @@ async function startDaemon() {
     logger.logger.debug("[DAEMON RUN] Auth and machine setup complete");
     const pidToTrackedSession = /* @__PURE__ */ new Map();
     const turnActivity = new api.TurnActivityTracker();
+    turnActivity.onEvent((sessionId, event) => issueWorker?.report(sessionId, event === "turn_started" ? "running" : "idle"));
     const backgroundTasks = new backgroundTaskActivity.BackgroundTaskTracker();
     const peerCoordinator = createPeerCoordinator({ getChildren: () => Array.from(pidToTrackedSession.values()) });
     const hibernationAutomations = client$1.createAutomationsClient({ serverUrl: configuration.configuration.serverUrl, token: credentials.token, client: "daemon-hibernate" });
@@ -7218,6 +7551,7 @@ async function startDaemon() {
     let autoRestart;
     let bundleReplacedSeen = false;
     let automationRunner;
+    let issueWorker;
     let projectPresence;
     const persisted = persistence.readPersistedSessions();
     const liveHappyProcesses = await doctor$1.findAllHappyProcesses();
@@ -7739,7 +8073,7 @@ async function startDaemon() {
       happyProcess.on("exit", (code, signal) => {
         logger.logger.debug(`[DAEMON RUN] Child PID ${happyProcess.pid} exited with code ${code}, signal ${signal}`);
         if (happyProcess.pid) {
-          onChildExited(happyProcess.pid);
+          onChildExited(happyProcess.pid, { code, signal });
         }
       });
       happyProcess.on("error", (error) => {
@@ -8130,8 +8464,11 @@ async function startDaemon() {
       logger.logger.debug(`[DAEMON RUN] Session ${sessionId} not found`);
       return false;
     };
-    const onChildExited = (pid) => {
+    const onChildExited = (pid, exit) => {
       const session = pidToTrackedSession.get(pid);
+      if (session?.happySessionId && !autoRestartExits.has(session.happySessionId) && issueWorker?.hasSession(session.happySessionId)) {
+        issueWorker.report(session.happySessionId, daemonHibernation.pendingExit(session.happySessionId) ? "idle" : issueExitEvent(exit));
+      }
       if (session?.happySessionId && !autoRestartExits.has(session.happySessionId) && (session.spawnedBy === "teams" || teamWorker?.hasSession(session.happySessionId))) teamWorker?.report(session.happySessionId, "exited");
       if (session?.happySessionId && automationRunner?.hasSession(session.happySessionId)) automationRunner.report(session.happySessionId, "exited");
       if (session?.happySessionId) turnActivity.forget(session.happySessionId);
@@ -8661,6 +8998,7 @@ async function startDaemon() {
             const sessionsHold = () => daemonSupervisor.handoverWaitsForSessions({ bundleReplaced, relayMove: !!relayMove, sparesWrappers: handoverSparesWrappers }) && (turnActivity.hasActiveTurn() || backgroundTasks.hasAny());
             if ((bundleReplaced || relayMove) && !teamWorker?.busy && !automationRunner?.busy && !updateController.isRunning() && !harnessInstaller?.isRunning() && !sessionsHold()) {
               const preflight = bundleReplaced ? await preflightNewBundle(bundlePath) : { action: "proceed" };
+              if (issueWorker?.busy) return;
               if (preflight.action === "hold") {
                 if (lastHandoverHold !== preflight.reason) {
                   lastHandoverHold = preflight.reason;
@@ -8674,6 +9012,7 @@ async function startDaemon() {
               logger.logger.debug(relayMove ? `[DAEMON RUN] Relay moved to ${relayMove.serverUrl}; handing off to a new daemon on the new settings` : "[DAEMON RUN] Daemon bundle replaced on disk and verified, handing off to new daemon");
               teamWorker?.stop();
               automationRunner?.stop();
+              issueWorker?.stop();
               projectPresence?.stop();
               clearInterval(restartOnStaleVersionAndHeartbeat);
               clearInterval(cliUpdateInterval);
@@ -8770,6 +9109,15 @@ async function startDaemon() {
       } : {},
       log: (message) => logger.logger.debug(`[DAEMON RUN] ${message}`)
     });
+    issueWorker = createIssueWorker({
+      machineId,
+      client: client$2.createIssuesClient({ token: async () => credentials.token }),
+      spawn: spawnSession,
+      live: (id) => [...pidToTrackedSession.values()].some((s) => s.happySessionId === id && isPidAlive(s.pid)),
+      ...accountServiceRef ? { resolveAccount: (agent, requested) => accountServiceRef.resolveSpawnAccount(agent, requested) } : {},
+      joinProject: (sessionId, projectId) => spawnAgents.joinProject(projectsClient, sessionId, { kind: "explicit", projectId }, { via: "issue" }),
+      log: (message) => logger.logger.debug(`[DAEMON RUN] ${message}`)
+    });
     projectPresence = createProjectPresenceReporter({
       machineId,
       client: projectsClient,
@@ -8803,6 +9151,7 @@ async function startDaemon() {
       const scrollbackFlush = apiMachine.flushTerminalScrollback();
       teamWorker?.stop();
       automationRunner?.stop({ killScripts: true });
+      issueWorker?.stop();
       projectPresence?.stop();
       mirrorProtocol.currentWorktreeService()?.stopAll();
       if (restartOnStaleVersionAndHeartbeat) {