very-happy-cli 0.2.199 → 0.2.201

package/dist/{run-BXyfDvCk.mjs → run-mHeOSOEt.mjs}

@@ -1,26 +1,27 @@
-import { i as isClaudeSessionId, h as extractCompleteLines, j as decideBackfill, k as parseTerminalHookPayload, m as decideMirrorBinding, M as MIRROR_BACKFILL_LINES_DEFAULT, n as mirrorLineKey, o as mirrorLocalId, q as initializeOwnedWorktree, f as summarizeSpawnSessionForLog, t as startAgentVersionChecks, W as WORKTREE_CAPABILITY_VERSION, u as currentWorktreeService } from './mirrorProtocol-CoXxepvL.mjs';
+import { i as isClaudeSessionId, h as extractCompleteLines, j as decideBackfill, k as parseTerminalHookPayload, m as decideMirrorBinding, M as MIRROR_BACKFILL_LINES_DEFAULT, n as mirrorLineKey, o as mirrorLocalId, q as initializeOwnedWorktree, f as summarizeSpawnSessionForLog, t as startAgentVersionChecks, W as WORKTREE_CAPABILITY_VERSION, u as currentWorktreeService } from './mirrorProtocol-dRyartIG.mjs';
 import { F as FS_MKDIR_CAPABILITY_VERSION } from './fsMkdir-DumgLTzR.mjs';
-import { P as PI_ADAPTER_INSTALL_HINT, s as sanitizeSpawnModel } from './piRunnerArgs-DOV74xAt.mjs';
+import { P as PI_ADAPTER_INSTALL_HINT, s as sanitizeSpawnModel } from './piRunnerArgs-Cfc-F-FJ.mjs';
 import fs from 'fs/promises';
 import os from 'os';
 import * as tmp from 'tmp';
 import axios from 'axios';
+import { a as issueRelaunchEnv } from './sessionMetadata-C1eoAi89.mjs';
 import { readFileSync, openSync, fsyncSync, closeSync, renameSync, existsSync, readdirSync, statSync, unlinkSync, readSync, writeSync, ftruncateSync, utimesSync, realpathSync, promises, constants as constants$1, writeFileSync, mkdirSync, accessSync, rmdirSync } from 'node:fs';
 import { join, isAbsolute, resolve, dirname, sep, basename, relative } from 'node:path';
-import { f as ensurePrivateDirectorySync, w as writePrivateFileSync, c as configuration } from './configuration-D9k5yIzV.mjs';
-import { T as TurnActivityTracker, A as ApiClient } from './api-DibgCucH.mjs';
-import { S as SPAWN_AGENTS, i as isSpawnAgent, s as sanitizeSpawnPermissionMode, r as resolveSpawnPermissionMode, a as resolveFirstMessageMeta, j as joinProject } from './spawnAgents-SeUX5gIq.mjs';
-import { l as logger } from './logger-n9NOzHhK.mjs';
-import { p as pruneStaleCompileCaches } from './index-DcfbjaVL.mjs';
-import { a as authAndSetupMachineIfNeeded } from './auth-BjWk9sHU.mjs';
+import { f as ensurePrivateDirectorySync, w as writePrivateFileSync, c as configuration } from './configuration-DhEqAYzz.mjs';
+import { T as TurnActivityTracker, A as ApiClient } from './api-1CD4oRSW.mjs';
+import { S as SPAWN_AGENTS, i as isSpawnAgent, s as sanitizeSpawnPermissionMode, r as resolveSpawnPermissionMode, a as resolveFirstMessageMeta, j as joinProject } from './spawnAgents-BclZYkov.mjs';
+import { l as logger } from './logger-CFrzcRHD.mjs';
+import { p as pruneStaleCompileCaches } from './index-C_Y9426m.mjs';
+import { a as authAndSetupMachineIfNeeded } from './auth-WCd2S1zA.mjs';
 import { spawn, execSync } from 'child_process';
-import { p as packageJson } from './package-CCF6FHr2.mjs';
-import { a as globalPrefixForPackage, N as NPM_SAFE_ARG, g as getEnvironmentInfo } from './doctor-jAPeyoi6.mjs';
-import { s as spawnHappyCLI } from './spawnHappyCLI-DnT_QEdn.mjs';
-import { c as readPersistedSessions, r as readSettings, l as latchKeepAwake, s as reportSignature, t as decideDaemonHibernation, v as nextCheckDelay, x as persistSession, d as readDaemonState, y as acquireDaemonLock, a as resolveCheckMs, z as resolveIdleMs, A as deletePersistedSessions, B as writeDaemonState, C as writeSettings, D as settingIdleMs, u as updateSettings, E as rewriteCredentialsForRelay, g as readCredentials, F as releaseDaemonLock } from './persistence-B5U9rC15.mjs';
-import { i as isDaemonRunningCurrentlyInstalledHappyVersion, s as stopDaemon, w as cleanupDaemonState } from './controlClient-DhFAPGHz.mjs';
-import { e as sendUserMessage, f as readSessionMetadata, r as readSessionTranscript, l as listAccountSessions, a as listSessions, M as MAX_READ_LIMIT, s as sessionWebUrl, n as lineageOf, g as waitForSessionKey, d as archiveSession, h as analyzeLatestTurn, i as readSessionLog, j as TURN_WINDOW, p as userPromptText } from './sessionOps-VS1baPz_.mjs';
-import { Q as AgentProfilesStateSchema, ab as ServerMigrateNoticeSchema, ac as isHarnessInstallId, ad as agentProfileUnavailableReason, ae as MODEL_INTENT_CONFIG, j as AUTOMATION_SUMMARY_MAX_CHARS, af as AUTOMATION_PRECHECK_OUTPUT_MAX_CHARS, ag as AUTOMATION_PRECHECK_DEFAULT_TIMEOUT_MS, d as AUTOMATION_PRECHECK_MAX_TIMEOUT_MS, ah as AUTOMATION_CLAIM_MAX_RUNS, ai as AUTOMATION_DAEMON_CAPABILITY_PRECHECK, aj as AUTOMATION_DEFAULT_LEASE_MS, i as isAutomationRunTerminal, v as resolveLaunchAgentProfile, ak as HARNESS_INSTALL_CAPABILITY_VERSION } from './index-BQvPYTNM.mjs';
+import { p as packageJson } from './package-DxE8PttX.mjs';
+import { a as globalPrefixForPackage, N as NPM_SAFE_ARG, g as getEnvironmentInfo } from './doctor-BanQ3jQg.mjs';
+import { s as spawnHappyCLI } from './spawnHappyCLI-D6OcgFDR.mjs';
+import { c as readPersistedSessions, r as readSettings, l as latchKeepAwake, s as reportSignature, t as decideDaemonHibernation, v as nextCheckDelay, x as persistSession, d as readDaemonState, y as acquireDaemonLock, a as resolveCheckMs, z as resolveIdleMs, A as deletePersistedSessions, B as writeDaemonState, C as writeSettings, D as settingIdleMs, u as updateSettings, E as rewriteCredentialsForRelay, g as readCredentials, F as releaseDaemonLock } from './persistence-CF7oV1oH.mjs';
+import { i as isDaemonRunningCurrentlyInstalledHappyVersion, s as stopDaemon, w as cleanupDaemonState } from './controlClient-PaIiDxM6.mjs';
+import { e as sendUserMessage, f as readSessionMetadata, r as readSessionTranscript, l as listAccountSessions, a as listSessions, M as MAX_READ_LIMIT, s as sessionWebUrl, n as lineageOf, g as waitForSessionKey, d as archiveSession, h as analyzeLatestTurn, i as readSessionLog, j as TURN_WINDOW, p as userPromptText } from './sessionOps-BmhqmPPd.mjs';
+import { a2 as AgentProfilesStateSchema, an as ServerMigrateNoticeSchema, ao as isHarnessInstallId, ap as agentProfileUnavailableReason, aq as MODEL_INTENT_CONFIG, q as AUTOMATION_SUMMARY_MAX_CHARS, ar as AUTOMATION_PRECHECK_OUTPUT_MAX_CHARS, as as AUTOMATION_PRECHECK_DEFAULT_TIMEOUT_MS, d as AUTOMATION_PRECHECK_MAX_TIMEOUT_MS, at as AUTOMATION_CLAIM_MAX_RUNS, au as AUTOMATION_DAEMON_CAPABILITY_PRECHECK, av as AUTOMATION_DEFAULT_LEASE_MS, i as isAutomationRunTerminal, D as resolveLaunchAgentProfile, aw as ISSUE_SENT_FROM, ax as ISSUE_DISPATCH_LOCAL_ID_PREFIX, f as ISSUE_ASSIGNABLE_AGENTS, ay as HARNESS_INSTALL_CAPABILITY_VERSION } from './index-CiRMvS73.mjs';
 import fastify from 'fastify';
 import { z } from 'zod';
 import { validatorCompiler, serializerCompiler } from 'fastify-type-provider-zod';
@@ -28,68 +29,69 @@ import { d as decodeBase64, s as sameRelay, e as encodeBase64, h as decrypt } fr
 import { randomBytes, createHash, timingSafeEqual, randomUUID } from 'node:crypto';
 import { c as checkPreviewPath } from './previewPath-CXN4Vag0.mjs';
 import { a as BACKGROUND_TASKS_MAX, d as BACKGROUND_TASK_DESCRIPTION_MAX, e as BackgroundTaskTracker } from './backgroundTaskActivity-8PdPxrvy.mjs';
-import { b as sanitizeRateLimitReport } from './rateLimitWindows-DnLJ-gve.mjs';
-import { f as formatEditConflictNotice, b as SESSION_PEER_SENT_FROM, s as sendPeerMessage, l as listPeerSessions, C as CLI_PEER_SENDER_ID } from './peerTools-gR_3dwdA.mjs';
+import { b as sanitizeRateLimitReport } from './rateLimitWindows-DdUMUEoy.mjs';
+import { f as formatEditConflictNotice, b as SESSION_PEER_SENT_FROM, s as sendPeerMessage, l as listPeerSessions, C as CLI_PEER_SENDER_ID } from './peerTools-BiFpxXdf.mjs';
 import os$1, { hostname, homedir, tmpdir } from 'node:os';
-import { c as RemoteCallBudget, e as REMOTE_WRITE_CALLS_PER_MINUTE, d as deliverToSession, g as guardRemoteSessionOpsRequest, h as remoteError, i as REMOTE_OP_DEADLINE_MS, j as formatRemoteAuditLine, k as REMOTE_SEND_COMMIT_DEADLINE_MS, m as REMOTE_RESUME_WAIT_MS, n as capRemoteTranscript, o as capRemoteText, p as REMOTE_ANSWER_MAX_BYTES, q as REMOTE_TITLE_MAX_BYTES } from './remoteSessionClient-Blz-z9jM.mjs';
-import { assistantHome, bootstrapAssistantHome } from './bootstrap-CY7Db_VV.mjs';
-import { refreshAgentHomes, locateClaudeConversation, agentHomeSpawnEnv } from './index-BAjoMeJi.mjs';
+import { c as RemoteCallBudget, e as REMOTE_WRITE_CALLS_PER_MINUTE, d as deliverToSession, g as guardRemoteSessionOpsRequest, h as remoteError, i as REMOTE_OP_DEADLINE_MS, j as formatRemoteAuditLine, k as REMOTE_SEND_COMMIT_DEADLINE_MS, m as REMOTE_RESUME_WAIT_MS, n as capRemoteTranscript, o as capRemoteText, p as REMOTE_ANSWER_MAX_BYTES, q as REMOTE_TITLE_MAX_BYTES } from './remoteSessionClient-Dj2rV8Az.mjs';
+import { assistantHome, bootstrapAssistantHome } from './bootstrap-D_1MskAl.mjs';
+import { refreshAgentHomes, locateClaudeConversation, agentHomeSpawnEnv } from './index-HJFzeG0B.mjs';
 import require$$0, { existsSync as existsSync$1, statSync as statSync$1, mkdtempSync, rmSync } from 'fs';
 import require$$1, { join as join$1 } from 'path';
 import { spawn as spawn$1, execFile, spawnSync } from 'node:child_process';
 import { p as projectPath } from './projectPath-BTBIMB57.mjs';
 import { d as daemonEndpointsMatch, r as resolveClaudeCredentialReadiness } from './doctorReadiness-C208SMN9.mjs';
-import { o as ownerRetryPending, c as consumeOwnerRetry, s as spawnGate, a as afterStartupFailure, b as startupFailureMessage, T as TEAM_SPAWN_MAX_ATTEMPTS, d as TEAM_CLEANUP_RETRY_MS, g as getInitialMachineMetadata, e as getStartupCliAvailability, f as TEAM_RETRY_CAPABILITY_VERSION, w as withRunningCliFacts } from './machineMetadata-Bc7FwngX.mjs';
+import { o as ownerRetryPending, c as consumeOwnerRetry, s as spawnGate, a as afterStartupFailure, b as startupFailureMessage, T as TEAM_SPAWN_MAX_ATTEMPTS, d as TEAM_CLEANUP_RETRY_MS, g as getInitialMachineMetadata, e as getStartupCliAvailability, f as TEAM_RETRY_CAPABILITY_VERSION, w as withRunningCliFacts } from './machineMetadata-DiStbYik.mjs';
 import { M as ModelConfigError, B as BackupStore, r as readConfigFile, s as sha256, a as atomicWriteFile } from './fileStore-5qpetZS0.mjs';
 import { c as collectSecretValues, a as parseJsonObject, b as childObject, s as setOrDelete, d as changedPaths, e as stringifyLike, f as fail, n as normalizeModelList, g as normalizeModelId, h as normalizeSecret, i as normalizeBaseUrl, u as uniq, j as baseUrlWarnings, m as maskSecret, k as getPath$1, l as normalizeProviderId, o as piAdapter, r as redactText } from './pi-CqyoZMjI.mjs';
-import { p as parse } from './codexAccount-DeFAjaHW.mjs';
+import { p as parse } from './codexAccount-CieIQLOX.mjs';
 import require$$3 from 'crypto';
 import { c as commandOnPath } from './detectCLI-CSGMlV51.mjs';
-import { buildResumeLaunch } from './handleResumeCommand-DbFTdwoc.mjs';
+import { buildResumeLaunch } from './handleResumeCommand-BRV-9h0o.mjs';
 import { n as normalizeWebPanels } from './webPanels-B2_C2-3g.mjs';
 import { access, symlink, readFile, rm, unlink, readlink, lstat, constants, rename, mkdir, copyFile, readdir, stat, open } from 'node:fs/promises';
 import { p as parseExactVersion, c as compareExactVersions, f as fetchCliUpdateState, r as resolveCliUpdateCheckInterval, D as DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS } from './cliUpdate-Y34VGe9Y.mjs';
-import { P as ProjectsUnsupportedError, c as createProjectsClient } from './client-DKPLBLvx.mjs';
-import { d as wrapperReportsIdle, f as decideAutoRestart, s as statusFromVerdict, g as autoRestartNextCheck, h as wrapperStaleness, r as recordAttempt, i as AUTO_RESTART_MAX_ATTEMPTS, j as AUTO_RESTART_MIN_GAP_MS, p as processIdentityFields, k as readSessionLock, l as AUTO_RESTARTED_ENV, n as encodeAutoRestarted, o as pendingUpgradeVersion, q as resolveQuietMs, u as AUTO_RESTART_RECHECK_CAP_MS } from './sessionLock-JWBEd8g_.mjs';
-import { c as createAutomationsClient, i as isAutomationsUnavailable, d as AutomationsRequestError } from './client-B5uvkdLn.mjs';
+import { P as ProjectsUnsupportedError, c as createProjectsClient } from './client-BgInTvr6.mjs';
+import { d as wrapperReportsIdle, f as decideAutoRestart, s as statusFromVerdict, g as autoRestartNextCheck, h as wrapperStaleness, r as recordAttempt, i as AUTO_RESTART_MAX_ATTEMPTS, j as AUTO_RESTART_MIN_GAP_MS, p as processIdentityFields, k as readSessionLock, l as AUTO_RESTARTED_ENV, n as encodeAutoRestarted, o as pendingUpgradeVersion, q as resolveQuietMs, u as AUTO_RESTART_RECHECK_CAP_MS } from './sessionLock-Dj9_lShU.mjs';
+import { c as createAutomationsClient, i as isAutomationsUnavailable, d as AutomationsRequestError } from './client-4YWjreN3.mjs';
 import { w as withKeychainOffPath, a as keychainIdentityFor, i as interpretSecurityRead, s as securityReadArgs, b as securityDeleteArgs, c as keychainOffShimDir, d as interpretCredentialsFile, C as CREDENTIALS_REJECTED_DETAIL, e as buildClaudeAuthState, f as claudeAuthStateChanged, r as resolveSdkClaudeBinary, g as classifyAuthStatus, h as diagnoseStores, p as parseLaunchctlPid, H as HAPPY_DAEMON_LAUNCHD_LABEL, j as classifyLineage, l as probeLaunchdJob, m as detectDaemonSupervisor, n as daemonLineage, o as probeSystemdKillMode, q as wrappersSurviveHandover, t as handoverWaitsForSessions } from './daemonSupervisor-BxohggqN.mjs';
-import { A as AccountService } from './accountService-WPnOpkvs.mjs';
-import { spawnSetupTokenPty, watchAccountFiles } from './daemonAccounts-DD5YBwku.mjs';
+import { A as AccountService } from './accountService-DEpIq6CF.mjs';
+import { spawnSetupTokenPty, watchAccountFiles } from './daemonAccounts-D5shoCLt.mjs';
 import { g as getProjectPath } from './path-D2wdaNSk.mjs';
 import { b as extractClaudeEditPaths } from './editPaths-BVfS_FFL.mjs';
-import { s as startFileWatcher } from './startFileWatcher-Djf0SdmK.mjs';
-import { I as InvalidateSync } from './sync-Dfr1zgLx.mjs';
+import { s as startFileWatcher } from './startFileWatcher-BiWGhlGW.mjs';
+import { I as InvalidateSync } from './sync-CcBrziWp.mjs';
 import { R as RawJSONLinesSchema } from './types-CkqAACXx.mjs';
 import { t as tmuxArgs, a as scrubTmuxClientEnv, s as shellescape } from './tmuxSocket-BmZyixRM.mjs';
 import { i as isProcessAlive, t as terminateProcessTree } from './processTermination-ChJG5SLW.mjs';
 import { findAllHappyProcesses } from './doctor-GN5mPOn5.mjs';
 import { T as TEAM_SKILL, a as TEAM_LEAD_PLAYBOOK, b as TEAM_MEMBER_RULES } from './resources-CLP_MpK4.mjs';
 import { promisify } from 'node:util';
-import { b as clipText, r as renderAction, c as clipAutomationReport, e as renderTemplate } from './template-DE9JMShn.mjs';
+import { b as clipText, r as renderAction, c as clipAutomationReport, e as renderTemplate } from './template-CtRLg2PG.mjs';
+import { I as IssuesUnsupportedError, a as IssueRequestError, c as createIssuesClient } from './client-CMUlpYcy.mjs';
 import { d as describeAgentHome } from './loginShellEnv-Dw8M7tkI.mjs';
-import { S as SPAWN_ACCOUNT_ENV } from './store-DnaIrYLA.mjs';
-import './acpSessionResume-BVroOlVN.mjs';
-import './pushNotifications-pHkbUkqT.mjs';
+import { S as SPAWN_ACCOUNT_ENV } from './store-DWmjM4Ex.mjs';
+import './acpSessionResume-urFpnGsk.mjs';
+import './pushNotifications-CxX10K6n.mjs';
 import './contentLogMetadata-BlWI0egu.mjs';
-import './reconnectGate-DPDXEkOX.mjs';
+import './reconnectGate-uTLj82tS.mjs';
 import 'node:events';
 import 'socket.io-client';
 import './limits-DIo7rEBR.mjs';
-import './time-PqfO1O58.mjs';
-import './registerCommonHandlers-BrTglZnC.mjs';
+import './time-DJF2csbV.mjs';
+import './registerCommonHandlers-BYrmi-A4.mjs';
 import 'util';
 import 'cross-spawn';
 import '@paralleldrive/cuid2';
 import 'chalk';
 import 'node:module';
 import 'tweetnacl';
-import './browser-BpwBEJDU.mjs';
+import './browser-DL3QIQLS.mjs';
 import 'open';
 import './specialCommands-MXUN0wfI.mjs';
 import './ids-DU6sLx4C.mjs';
 import 'url';
-import './localHappyAgentAuth-CD896cy4.mjs';
-import './claudeAccountEnv-CYwfvK1u.mjs';
+import './localHappyAgentAuth-kg2RFvOy.mjs';
+import './claudeAccountEnv-DowsOlDB.mjs';
 import 'node:readline';
 import 'node-pty';
 import './processTreeSnapshot-fuwxC0fr.mjs';
@@ -7007,6 +7009,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 join(home, "issues", "receipts");
+}
+function readIssueReceipt(home, dispatchId) {
+  if (!ID.test(dispatchId)) return null;
+  try {
+    return JSON.parse(readFileSync(join(dir(home), `${dispatchId}.json`), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeIssueReceipt(home, receipt) {
+  if (!ID.test(receipt.dispatchId)) throw new Error("Invalid dispatch id");
+  ensurePrivateDirectorySync(dir(home));
+  writePrivateFileSync(join(dir(home), `${receipt.dispatchId}.json`), JSON.stringify({ ...receipt, updatedAt: Date.now() }));
+}
+function listIssueReceipts(home, now = Date.now()) {
+  let files;
+  try {
+    files = readdirSync(dir(home));
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const file of files) {
+    if (!file.endsWith(".json")) continue;
+    const path = join(dir(home), file);
+    try {
+      const receipt = JSON.parse(readFileSync(path, "utf8"));
+      const at = typeof receipt.updatedAt === "number" ? receipt.updatedAt : statSync(path).mtimeMs;
+      if (now - at > ISSUE_RECEIPT_TTL_MS) {
+        unlinkSync(path);
+        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(readPersistedSessions()).filter(([, entry]) => entry.metadata?.issue?.runId === runId).map(([sessionId]) => sessionId);
+}
+function httpCode(error) {
+  return error instanceof IssueRequestError ? error.code : null;
+}
+function createIssueWorker(deps) {
+  const home = deps.home ?? configuration.happyHomeDir;
+  const client = deps.client;
+  const send = deps.send ?? (async (sessionId, text, options) => {
+    const key = await waitForSessionKey(sessionId, FIRST_MESSAGE_KEY_WAIT_MS);
+    await sendUserMessage(sessionId, key, text, "issue", options);
+  });
+  const capabilities = deps.capabilities ?? ((sessionId) => 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 IssuesUnsupportedError) unknownSpawns.delete(id);
+        deps.log(`Issue dispatch ${id} remains pending${error instanceof 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 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 (!ISSUE_ASSIGNABLE_AGENTS.includes(agent)) {
+        await fail(receipt, `Agent "${agent}" cannot run issues on this machine`);
+        return;
+      }
+      if (!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 = sanitizeSpawnPermissionMode(spawn.permissionMode ?? void 0);
+      const permissionMode = 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" && 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 = sanitizeSpawnPermissionMode(spawn.permissionMode ?? void 0);
+      const permissionMode = resolveSpawnPermissionMode(agent, mode ?? void 0);
+      const meta = resolveFirstMessageMeta({ agent, permissionMode, explicitModel: spawn.model ?? void 0, capabilities: capabilities(sessionId) });
+      try {
+        await send(sessionId, spawn.prompt, { localId: `${ISSUE_DISPATCH_LOCAL_ID_PREFIX}${view.id}`, sentFrom: 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: `${ISSUE_DISPATCH_LOCAL_ID_PREFIX}${view.id}`, sentFrom: 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 IssuesUnsupportedError) && code !== "issue_run_not_found" && !(error instanceof 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 IssuesUnsupportedError)) {
+          retryAt = Date.now() + 3e4;
+          deps.log(`Issue dispatch poll unavailable${error instanceof 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 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;
 }
@@ -7162,6 +7533,7 @@ async function startDaemon() {
     logger.debug("[DAEMON RUN] Auth and machine setup complete");
     const pidToTrackedSession = /* @__PURE__ */ new Map();
     const turnActivity = new TurnActivityTracker();
+    turnActivity.onEvent((sessionId, event) => issueWorker?.report(sessionId, event === "turn_started" ? "running" : "idle"));
     const backgroundTasks = new BackgroundTaskTracker();
     const peerCoordinator = createPeerCoordinator({ getChildren: () => Array.from(pidToTrackedSession.values()) });
     const hibernationAutomations = createAutomationsClient({ serverUrl: configuration.serverUrl, token: credentials.token, client: "daemon-hibernate" });
@@ -7197,6 +7569,7 @@ async function startDaemon() {
     let autoRestart;
     let bundleReplacedSeen = false;
     let automationRunner;
+    let issueWorker;
     let projectPresence;
     const persisted = readPersistedSessions();
     const liveHappyProcesses = await findAllHappyProcesses();
@@ -7433,7 +7806,8 @@ async function startDaemon() {
           logger.debug(`[DAEMON RUN] Directory creation failed: ${errorMessage}`);
           return {
             type: "error",
-            errorMessage
+            errorMessage,
+            notStarted: true
           };
         }
       }
@@ -7492,11 +7866,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[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) {
@@ -7523,7 +7897,8 @@ async function startDaemon() {
           logger.warn(`[DAEMON RUN] ${errorMessage}`);
           return {
             type: "error",
-            errorMessage
+            errorMessage,
+            notStarted: true
           };
         }
         let tmuxSessionName = extraEnv.TMUX_SESSION_NAME;
@@ -7544,7 +7919,8 @@ async function startDaemon() {
           if (!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;
@@ -7630,7 +8006,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 = [
@@ -7700,7 +8077,8 @@ async function startDaemon() {
         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");
@@ -7718,7 +8096,7 @@ async function startDaemon() {
       happyProcess.on("exit", (code, signal) => {
         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) => {
@@ -7926,7 +8304,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).
+            ...issueRelaunchEnv(metadata)
           }
         });
         if (result.type === "success") {
@@ -8068,6 +8448,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.
+            ...issueRelaunchEnv(metadata),
             ...options?.auto ? { [AUTO_RESTARTED_ENV]: encodeAutoRestarted(options.auto.kind, options.auto.target) } : {}
           }
         });
@@ -8109,8 +8491,11 @@ async function startDaemon() {
       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);
@@ -8640,6 +9025,7 @@ async function startDaemon() {
             const sessionsHold = () => 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;
@@ -8653,6 +9039,7 @@ async function startDaemon() {
               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);
@@ -8749,6 +9136,15 @@ async function startDaemon() {
       } : {},
       log: (message) => logger.debug(`[DAEMON RUN] ${message}`)
     });
+    issueWorker = createIssueWorker({
+      machineId,
+      client: 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) => joinProject(projectsClient, sessionId, { kind: "explicit", projectId }, { via: "issue" }),
+      log: (message) => logger.debug(`[DAEMON RUN] ${message}`)
+    });
     projectPresence = createProjectPresenceReporter({
       machineId,
       client: projectsClient,
@@ -8782,6 +9178,7 @@ async function startDaemon() {
       const scrollbackFlush = apiMachine.flushTerminalScrollback();
       teamWorker?.stop();
       automationRunner?.stop({ killScripts: true });
+      issueWorker?.stop();
       projectPresence?.stop();
       currentWorktreeService()?.stopAll();
       if (restartOnStaleVersionAndHeartbeat) {