very-happy-cli 0.2.199 → 0.2.201

package/dist/{run-9aB7U4BF.cjs → run-BqlWdDTL.cjs}

@@ -1,28 +1,29 @@
 'use strict';
 
-var mirrorProtocol = require('./mirrorProtocol-5bgkr1Or.cjs');
+var mirrorProtocol = require('./mirrorProtocol-YUoEuIYO.cjs');
 var fsMkdir = require('./fsMkdir-0K3yENml.cjs');
-var piRunnerArgs = require('./piRunnerArgs-rygeUdRz.cjs');
+var piRunnerArgs = require('./piRunnerArgs-T2cAiaGW.cjs');
 var fs = require('fs/promises');
 var os$1 = require('os');
 var tmp = require('tmp');
 var axios = require('axios');
+var sessionMetadata = require('./sessionMetadata-B44cL4Xj.cjs');
 var node_fs = require('node:fs');
 var path = require('node:path');
-var configuration = require('./configuration-CAzuk0Xs.cjs');
-var api = require('./api-CgzfmyYS.cjs');
-var spawnAgents = require('./spawnAgents-B8GT4JQX.cjs');
-var logger = require('./logger-LsJ3Cl5o.cjs');
-var index$2 = require('./index-DL6ONx6v.cjs');
-var auth = require('./auth-B6H2wHTy.cjs');
+var configuration = require('./configuration-LWFmTxty.cjs');
+var api = require('./api-KVVs-GkM.cjs');
+var spawnAgents = require('./spawnAgents-DvbEDCIq.cjs');
+var logger = require('./logger-Hyhy2boA.cjs');
+var index$2 = require('./index-DnEgpRo4.cjs');
+var auth = require('./auth-CXCX-iJ-.cjs');
 var child_process = require('child_process');
-var _package = require('./package-D7V1BX2I.cjs');
-var doctor = require('./doctor-CH_pTY3Q.cjs');
-var spawnHappyCLI = require('./spawnHappyCLI-Cvk2ZMYj.cjs');
-var persistence = require('./persistence-Dl3sBrCF.cjs');
-var controlClient = require('./controlClient-Bb188cU0.cjs');
-var sessionOps = require('./sessionOps-CYNOycqT.cjs');
-var index = require('./index-BnT8yvlF.cjs');
+var _package = require('./package-06cGlmeD.cjs');
+var doctor = require('./doctor-DOzji0f7.cjs');
+var spawnHappyCLI = require('./spawnHappyCLI-CI7Ax4mF.cjs');
+var persistence = require('./persistence-_W9tE-bW.cjs');
+var controlClient = require('./controlClient-TVMpETsR.cjs');
+var sessionOps = require('./sessionOps-SxZr9veq.cjs');
+var index = require('./index-44o_qMvE.cjs');
 var fastify = require('fastify');
 var z = require('zod');
 var fastifyTypeProviderZod = require('fastify-type-provider-zod');
@@ -30,68 +31,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-C7xi99Eb.cjs');
-var peerTools = require('./peerTools-Dv6bgHkW.cjs');
+var rateLimitWindows = require('./rateLimitWindows-DjJjgjt4.cjs');
+var peerTools = require('./peerTools-CTCyRdg2.cjs');
 var os = require('node:os');
-var remoteSessionClient = require('./remoteSessionClient-9NzkfL13.cjs');
-var bootstrap = require('./bootstrap-Brd_jnA2.cjs');
-var index$1 = require('./index-qVJYCmRA.cjs');
+var remoteSessionClient = require('./remoteSessionClient-DoxfnpnK.cjs');
+var bootstrap = require('./bootstrap-N1PY4ypX.cjs');
+var index$1 = require('./index-BuOzDU17.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-CUU2NSYl.cjs');
+var machineMetadata = require('./machineMetadata-BLymhM03.cjs');
 var fileStore = require('./fileStore-7qhnbs6N.cjs');
 var pi = require('./pi-DlsrPCTa.cjs');
-var codexAccount = require('./codexAccount-8Wv5enLR.cjs');
+var codexAccount = require('./codexAccount-D-OBY29W.cjs');
 var require$$3 = require('crypto');
 var detectCLI = require('./detectCLI-BuYR_Qxe.cjs');
-var handleResumeCommand = require('./handleResumeCommand-DsaEUiax.cjs');
+var handleResumeCommand = require('./handleResumeCommand-ChnR-12l.cjs');
 var webPanels = require('./webPanels-FCgFKvVe.cjs');
 var promises = require('node:fs/promises');
 var cliUpdate = require('./cliUpdate-DsKXPFYp.cjs');
-var client = require('./client-KbhVRYjy.cjs');
-var sessionLock = require('./sessionLock-CuPN9xfW.cjs');
-var client$1 = require('./client-BKyTA9Hf.cjs');
+var client = require('./client-BoymtYLP.cjs');
+var sessionLock = require('./sessionLock-unMOEniJ.cjs');
+var client$1 = require('./client-P1VkI76z.cjs');
 var daemonSupervisor = require('./daemonSupervisor-alqGPANc.cjs');
-var accountService = require('./accountService-B59oKwa4.cjs');
-var daemonAccounts = require('./daemonAccounts-nLyHz8WB.cjs');
+var accountService = require('./accountService-Cns8UYGI.cjs');
+var daemonAccounts = require('./daemonAccounts-ciidbU2h.cjs');
 var path$1 = require('./path-B7zW-WwE.cjs');
 var editPaths = require('./editPaths-Bqp4OFPw.cjs');
-var startFileWatcher = require('./startFileWatcher-DLfkP-IW.cjs');
-var sync = require('./sync-B-B5mc8Z.cjs');
+var startFileWatcher = require('./startFileWatcher-DBW14aP2.cjs');
+var sync = require('./sync-C764ZzE6.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-CB4gXtUX.cjs');
+var template = require('./template-3fV9bi0X.cjs');
+var client$2 = require('./client-DI8Rxsbw.cjs');
 var loginShellEnv = require('./loginShellEnv-BkuYtExZ.cjs');
-var store = require('./store-D41VdZcL.cjs');
-require('./acpSessionResume-CfogEHtT.cjs');
-require('./pushNotifications-IZaTtVDG.cjs');
+var store = require('./store-Cpb1LMNW.cjs');
+require('./acpSessionResume-DklOhwir.cjs');
+require('./pushNotifications-DdzTbrA3.cjs');
 require('./contentLogMetadata-ZSFk_NjQ.cjs');
-require('./reconnectGate-CHI12y0Y.cjs');
+require('./reconnectGate-DeDhtQJW.cjs');
 require('node:events');
 require('socket.io-client');
 require('./limits-C-a7gr04.cjs');
-require('./time-DTaj0RVK.cjs');
-require('./registerCommonHandlers-CUCw-rad.cjs');
+require('./time-CDBZWYDb.cjs');
+require('./registerCommonHandlers-BrEtSwNk.cjs');
 require('util');
 require('cross-spawn');
 require('@paralleldrive/cuid2');
 require('chalk');
 require('node:module');
 require('tweetnacl');
-require('./browser-BhncBLE4.cjs');
+require('./browser-B0SEB6r3.cjs');
 require('open');
 require('./specialCommands-J3JFOq0J.cjs');
 require('./ids-B6ZC0HGt.cjs');
 require('url');
-require('./localHappyAgentAuth-Bsk_VyUN.cjs');
-require('./claudeAccountEnv-z_ecsJAP.cjs');
+require('./localHappyAgentAuth-DxlQgaer.cjs');
+require('./claudeAccountEnv-Btp39mfa.cjs');
 require('node:readline');
 require('node-pty');
 require('./processTreeSnapshot-D5iNblp6.cjs');
@@ -7028,6 +7030,375 @@ ${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 ISSUE_SPAWN_UNKNOWN_GRACE_MS = 6e4;
+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;
+  };
+  const now = deps.now ?? Date.now;
+  const unknownSpawns = /* @__PURE__ */ new Map();
+  async function fail(receipt, error) {
+    await client.fail(receipt.dispatchId, { machineId: deps.machineId, claimId: receipt.claimId, error: error.slice(0, 4e3) });
+    save({ ...receipt, phase: "failed" });
+    deps.log(`Issue dispatch ${receipt.dispatchId} failed`);
+  }
+  function holdUnknown(view, receipt, reason) {
+    const held = unknownSpawns.get(view.id);
+    unknownSpawns.set(view.id, { view, receipt, reason, deadline: held?.deadline ?? now() + ISSUE_SPAWN_UNKNOWN_GRACE_MS });
+    deps.log(`Issue dispatch ${view.id} spawn outcome unknown; re-checking`);
+  }
+  async function recheckUnknown() {
+    for (const [id, held] of [...unknownSpawns]) {
+      if (closed) return;
+      const matches = persistedRunSessions(held.view.runId);
+      try {
+        if (matches.length === 1) {
+          unknownSpawns.delete(id);
+          await afterSpawn(held.view, save({ ...held.receipt, sessionId: matches[0], phase: "spawned" }));
+        } else if (matches.length > 1 || now() >= held.deadline) {
+          unknownSpawns.delete(id);
+          await fail(held.receipt, matches.length > 1 ? `Spawn produced ${matches.length} sessions for this run; stop the extra ones and retry` : `Session did not start within ${Math.round(ISSUE_SPAWN_UNKNOWN_GRACE_MS / 1e3)} s (${held.reason}); check the machine before retrying`);
+        }
+      } catch (error) {
+        if (httpCode(error) === "issue_dispatch_claim_mismatch" || error instanceof client$2.IssuesUnsupportedError) unknownSpawns.delete(id);
+        deps.log(`Issue dispatch ${id} remains pending${error instanceof client$2.IssueRequestError && error.code ? ` (${error.code})` : ""}`);
+      }
+    }
+  }
+  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 || spawned.notStarted)) {
+        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) {
+          holdUnknown(view, receipt, spawned.errorMessage);
+          return;
+        }
+        receipt = save({ ...receipt, sessionId: matches[0], phase: "spawned" });
+      } else {
+        receipt = save({ ...receipt, sessionId: spawned.sessionId, phase: "spawned" });
+      }
+    } else if (receipt.phase === "spawning") {
+      const matches = persistedRunSessions(view.runId);
+      if (matches.length !== 1) {
+        holdUnknown(view, receipt, "the spawn was interrupted by a daemon restart");
+        return;
+      }
+      receipt = save({ ...receipt, sessionId: matches[0], phase: "spawned" });
+    } else {
+      if (receipt.sessionId && !receipt.ended) runBySession.set(receipt.sessionId, view.runId);
+      await deliverAndComplete(view, receipt);
+      return;
+    }
+    await afterSpawn(view, receipt);
+  }
+  async function afterSpawn(view, receipt) {
+    runBySession.set(receipt.sessionId, view.runId);
+    const projectId = view.spawn?.projectId;
+    if (projectId && deps.joinProject) await deps.joinProject(receipt.sessionId, projectId).catch(() => void 0);
+    await deliverAndComplete(view, receipt);
+  }
+  async function deliverAndComplete(view, receipt) {
+    const spawn = view.spawn;
+    const agent = spawn.agent;
+    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 {
+      await recheckUnknown();
+      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 +7554,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 +7590,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();
@@ -7454,7 +7827,8 @@ async function startDaemon() {
           logger.logger.debug(`[DAEMON RUN] Directory creation failed: ${errorMessage}`);
           return {
             type: "error",
-            errorMessage
+            errorMessage,
+            notStarted: true
           };
         }
       }
@@ -7513,11 +7887,11 @@ async function startDaemon() {
             const requested = forkSpawnAccount(options.agentProfileId, options.parentSessionId, (id) => accountServiceRef.sessionAccount(id));
             spawnAccountId = accountServiceRef.resolveSpawnAccount(accountAgent, requested);
           } catch (error) {
-            return { type: "error", errorMessage: error instanceof Error ? error.message : String(error) };
+            return { type: "error", errorMessage: error instanceof Error ? error.message : String(error), notStarted: true };
           }
           if (spawnAccountId) extraEnv[store.SPAWN_ACCOUNT_ENV] = spawnAccountId;
         } else if (options.agentProfileId) {
-          return { type: "error", errorMessage: `agent-profile-unavailable:agent-mismatch: accounts are not supported for ${options.agent} yet` };
+          return { type: "error", errorMessage: `agent-profile-unavailable:agent-mismatch: accounts are not supported for ${options.agent} yet`, notStarted: true };
         }
         const claudeAuthStatus = claudeAuthServiceRef?.current()?.status;
         if ((options.agent ?? "claude") === "claude" && claudeAuthStatus && !spawnAccountId) {
@@ -7544,7 +7918,8 @@ async function startDaemon() {
           logger.logger.warn(`[DAEMON RUN] ${errorMessage}`);
           return {
             type: "error",
-            errorMessage
+            errorMessage,
+            notStarted: true
           };
         }
         let tmuxSessionName = extraEnv.TMUX_SESSION_NAME;
@@ -7565,7 +7940,8 @@ async function startDaemon() {
           if (!spawnAgents.isSpawnAgent(agent)) {
             return {
               type: "error",
-              errorMessage: `Unsupported agent type: '${options.agent}'. Please update your CLI to the latest version.`
+              errorMessage: `Unsupported agent type: '${options.agent}'. Please update your CLI to the latest version.`,
+              notStarted: true
             };
           }
           const resumeId = agent === "claude" ? options.resumeClaudeSessionId : agent === "codex" ? options.resumeCodexThreadId : void 0;
@@ -7651,7 +8027,8 @@ async function startDaemon() {
             default:
               return {
                 type: "error",
-                errorMessage: `Unsupported agent type: '${options.agent}'. Please update your CLI to the latest version.`
+                errorMessage: `Unsupported agent type: '${options.agent}'. Please update your CLI to the latest version.`,
+                notStarted: true
               };
           }
           const args = [
@@ -7721,7 +8098,8 @@ async function startDaemon() {
         logger.logger.debug("[DAEMON RUN] Failed to spawn process - no PID returned");
         return Promise.resolve({
           type: "error",
-          errorMessage: "Failed to spawn Happy process - no PID returned"
+          errorMessage: "Failed to spawn Happy process - no PID returned",
+          notStarted: true
         });
       }
       timer?.mark("spawned");
@@ -7739,7 +8117,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) => {
@@ -7947,7 +8325,9 @@ async function startDaemon() {
             HAPPY_RECONNECT_SEQ: String(tracked.encryption.seq),
             HAPPY_RECONNECT_METADATA_VERSION: String(tracked.encryption.metadataVersion),
             HAPPY_RECONNECT_AGENT_STATE_VERSION: String(tracked.encryption.agentStateVersion),
-            ...teamEnv
+            ...teamEnv,
+            // B-874c: an issue run's binding rides every relaunch (digest, MCP context).
+            ...sessionMetadata.issueRelaunchEnv(metadata)
           }
         });
         if (result.type === "success") {
@@ -8089,6 +8469,8 @@ async function startDaemon() {
             HAPPY_RECONNECT_METADATA_VERSION: String(tracked.encryption.metadataVersion),
             HAPPY_RECONNECT_AGENT_STATE_VERSION: String(tracked.encryption.agentStateVersion),
             ...teamEnv,
+            // B-874c: see resumeSessionImpl.
+            ...sessionMetadata.issueRelaunchEnv(metadata),
             ...options?.auto ? { [sessionLock.AUTO_RESTARTED_ENV]: sessionLock.encodeAutoRestarted(options.auto.kind, options.auto.target) } : {}
           }
         });
@@ -8130,8 +8512,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 +9046,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 +9060,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 +9157,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 +9199,7 @@ async function startDaemon() {
       const scrollbackFlush = apiMachine.flushTerminalScrollback();
       teamWorker?.stop();
       automationRunner?.stop({ killScripts: true });
+      issueWorker?.stop();
       projectPresence?.stop();
       mirrorProtocol.currentWorktreeService()?.stopAll();
       if (restartOnStaleVersionAndHeartbeat) {