very-happy-cli 0.2.151 → 0.2.153

package/dist/{index-CIyjJy8D.mjs → index-BacwoXzs.mjs}

@@ -1,14 +1,14 @@
 import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import chalk from 'chalk';
 import os, { homedir, userInfo, tmpdir } from 'node:os';
 import { randomUUID, randomInt, randomBytes, createHash as createHash$1, timingSafeEqual } from 'node:crypto';
-import { H as notifyDaemonSessionEvent, q as getProjectPath, z as BUILTIN_TODO_DISCOVERY, I as initializeSandbox, J as wrapCommand, E as contentLogMetadata, K as InvalidateSync, R as RawJSONLinesSchema, G as delay, L as AsyncLock, S as STREAM_DELTA_MAX_CHARS, M as MAX_CHAT_ATTACHMENT_SOURCE_BYTES, N as notifyDaemonClaudeAuthFailed, O as commandOnPath, u as checkIfDaemonRunningAndCleanupStaleState, P as deriveLocalCliUpdateSummary, Q as AGENT_VERSION_SOURCES, T as isClaudeSessionId, U as getLocalHappyAgentCredentialPath, V as readLocalHappyAgentCredentials, W as parseExactVersion, X as compareExactVersions, Y as extractCompleteLines, Z as decideBackfill, _ as parseTerminalHookPayload, $ as tmuxArgs, a0 as scrubTmuxClientEnv, a1 as decideMirrorBinding, a2 as MIRROR_BACKFILL_LINES_DEFAULT, a3 as mirrorLineKey, a4 as mirrorLocalId, a5 as listDaemonSessions, w as stopDaemonSession, a6 as detectCLIAvailability, a7 as detectResumeSupport, a8 as refreshAgentHomes, d as describeAgentHome, a9 as isDaemonRunningCurrentlyInstalledHappyVersion, aa as stopDaemon, ab as TurnActivityTracker, ac as summarizeSpawnSessionForLog, ad as locateClaudeConversation, ae as agentHomeSpawnEnv, af as shellescape, A as ApiClient, ag as fetchCliUpdateState, ah as resolveCliUpdateCheckInterval, ai as DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS, aj as cleanupDaemonState, i as isValidSessionId, v as spawnDaemonSession, ak as listVhTerminals, al as isValidTerminalId, am as readVhTerminal, an as sendToVhTerminal, ao as ContextUsageSchema, ap as TITLE_PROMPT_PREFIX, aq as BOARD_ANALYZER_PROMPT_PREFIX, x as connectionState, ar as startOfflineReconnection, y as notifyDaemonSessionStarted, c as createEnvelope, C as CodexAppServerClient } from './types-BN3eiipi.mjs';
-import { l as logger, F as ensurePrivateDirectory, G as hardenPrivateFile, c as configuration, p as packageJson, r as readSettings, H as readCredentials, x as credentialRelayProblem, o as readDaemonState, g as encodeBase64, I as readSettingsOutcome, u as updateSettings, J as encodeBase64Url, m as decodeBase64, K as writeCredentialsLegacy, L as writeCredentialsDataKey, e as readCredentialsForConfiguredRelay, j as encrypt, d as readPersistedSessions, w as writePrivateFileSync, M as decryptWithDataKey, N as decryptLegacy, O as persistSession, k as decrypt, h as ensurePrivateDirectorySync, P as acquireDaemonLock, Q as deletePersistedSessions, R as writeDaemonState, S as writeSettings, T as releaseDaemonLock, C as CLIPBOARD_TOOL_NAME, a as CLIPBOARD_TOOL_TITLE, b as CLIPBOARD_TOOL_DESCRIPTION, f as CLIPBOARD_MAX_BYTES, U as clearCredentials, V as clearMachineId, W as SandboxConfigSchema, X as getLatestDaemonLog } from './limits-DS-bnYYp.mjs';
+import { v as notifyDaemonSessionEvent, g as getProjectPath, w as initializeSandbox, x as wrapCommand, u as contentLogMetadata, I as InvalidateSync, R as RawJSONLinesSchema, c as delay, y as AsyncLock, M as MAX_CHAT_ATTACHMENT_SOURCE_BYTES, z as notifyDaemonClaudeAuthFailed, B as commandOnPath, j as checkIfDaemonRunningAndCleanupStaleState, D as deriveLocalCliUpdateSummary, E as isClaudeSessionId, G as getLocalHappyAgentCredentialPath, H as readLocalHappyAgentCredentials, J as parseExactVersion, K as compareExactVersions, L as extractCompleteLines, N as decideBackfill, O as parseTerminalHookPayload, P as tmuxArgs, Q as scrubTmuxClientEnv, S as decideMirrorBinding, T as MIRROR_BACKFILL_LINES_DEFAULT, U as mirrorLineKey, V as mirrorLocalId, W as listDaemonSessions, k as stopDaemonSession, X as detectCLIAvailability, Y as detectResumeSupport, Z as refreshAgentHomes, d as describeAgentHome, _ as isDaemonRunningCurrentlyInstalledHappyVersion, $ as stopDaemon, a0 as TurnActivityTracker, a1 as summarizeSpawnSessionForLog, a2 as locateClaudeConversation, a3 as agentHomeSpawnEnv, a4 as shellescape, A as ApiClient, a5 as fetchCliUpdateState, a6 as resolveCliUpdateCheckInterval, a7 as DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS, a8 as cleanupDaemonState, i as isValidSessionId, s as spawnDaemonSession, a9 as listVhTerminals, aa as isValidTerminalId, ab as readVhTerminal, ac as sendToVhTerminal, ad as TITLE_PROMPT_PREFIX, ae as BOARD_ANALYZER_PROMPT_PREFIX, o as connectionState, af as startOfflineReconnection, q as notifyDaemonSessionStarted, C as CodexAppServerClient } from './types-BvqOVUOW.mjs';
+import { l as logger, k as BUILTIN_TODO_DISCOVERY, U as STREAM_DELTA_MAX_CHARS, V as ensurePrivateDirectory, W as hardenPrivateFile, c as configuration, p as packageJson, r as readSettings, X as readCredentials, L as credentialRelayProblem, F as readDaemonState, Y as AGENT_VERSION_SOURCES, j as encodeBase64, Z as readSettingsOutcome, u as updateSettings, _ as encodeBase64Url, E as decodeBase64, $ as writeCredentialsLegacy, a0 as writeCredentialsDataKey, f as readCredentialsForConfiguredRelay, z as encrypt, d as readPersistedSessions, w as writePrivateFileSync, a1 as decryptWithDataKey, a2 as decryptLegacy, a3 as persistSession, D as decrypt, m as ensurePrivateDirectorySync, a4 as getAgentCodeDefaults, a5 as normalizeAgentKey, a6 as isClaudeOpus55Model, a7 as supportsClaudeOpus55, a8 as AUTOMATION_SUMMARY_MAX_CHARS, a9 as AUTOMATION_CLAIM_MAX_RUNS, aa as AUTOMATION_DEFAULT_LEASE_MS, i as isAutomationRunTerminal, ab as acquireDaemonLock, ac as deletePersistedSessions, ad as writeDaemonState, ae as writeSettings, af as releaseDaemonLock, ag as ContextUsageSchema, C as CLIPBOARD_TOOL_NAME, a as CLIPBOARD_TOOL_TITLE, b as CLIPBOARD_TOOL_DESCRIPTION, h as CLIPBOARD_MAX_BYTES, ah as clearCredentials, ai as clearMachineId, aj as SandboxConfigSchema, e as createEnvelope, ak as getLatestDaemonLog } from './limits-BtAuKRl2.mjs';
 import spawn$1, { spawn } from 'cross-spawn';
 import path, { join, resolve, basename, delimiter, isAbsolute, dirname, sep, normalize } from 'node:path';
 import { createInterface } from 'node:readline';
 import { existsSync, readFileSync, readdirSync, statSync, mkdirSync, realpathSync, unlinkSync, renameSync, writeFileSync, accessSync, constants as constants$1, openSync, fsyncSync, closeSync, rmSync as rmSync$1, chmodSync as chmodSync$1 } from 'node:fs';
-import { p as projectPath } from './projectPath-CSpqWdxp.mjs';
-import { f as trimIdent, A as AGENT_GUIDANCE, t as teamScopePath, T as TeamConnectionPreflightError, e as createTeamsClient, P as PREVIEW_TOOL_NAME, R as REPORT_PROGRESS_TOOL_NAME, g as TEAM_TOOL_NAMES, r as registerTeamsTools, a as PREVIEW_TOOL_TITLE, b as PREVIEW_TOOL_DESCRIPTION, h as REPORT_PROGRESS_TOOL_TITLE, i as REPORT_PROGRESS_TOOL_DESCRIPTION } from './agentGuidance-Dvo3cZMW.mjs';
+import { p as projectPath } from './terminalTitleSuggest-DKgX3osW.mjs';
+import { j as trimIdent, k as AGENT_GUIDANCE, l as createAutomationsClient, i as isAutomationsUnavailable, m as AutomationsRequestError, t as teamScopePath, T as TeamConnectionPreflightError, h as createTeamsClient, P as PREVIEW_TOOL_NAME, R as REPORT_PROGRESS_TOOL_NAME, n as TEAM_TOOL_NAMES, o as AUTOMATION_TOOL_NAMES, r as registerTeamsTools, c as registerAutomationTools, a as PREVIEW_TOOL_TITLE, b as PREVIEW_TOOL_DESCRIPTION, p as REPORT_PROGRESS_TOOL_TITLE, q as REPORT_PROGRESS_TOOL_DESCRIPTION } from './agentGuidance-C8unGWp7.mjs';
 import { readFile, writeFile, rename, unlink, mkdir, access as access$1, symlink, rm, readlink, lstat, constants, stat, open as open$1, appendFile } from 'node:fs/promises';
 import fs, { watch, access } from 'fs/promises';
 import { useStdout, useInput, Box, Text, render } from 'ink';
@@ -5380,8 +5380,8 @@ ${typeLabels[type] || type}:`));
   }
   console.log(chalk.gray("  An external claude command is only needed for native terminal/mirror use."));
   try {
-    const { resolveAgentHomesForCli } = await import('./agentHome-CeFDNzvq.mjs');
-    const { describeAgentHome } = await import('./types-BN3eiipi.mjs').then(function (n) { return n.as; });
+    const { resolveAgentHomesForCli } = await import('./agentHome-D68Xh2ae.mjs');
+    const { describeAgentHome } = await import('./types-BvqOVUOW.mjs').then(function (n) { return n.ag; });
     const homes = await resolveAgentHomesForCli();
     console.log(chalk.green(`\u2713 Claude config dir: ${describeAgentHome(homes.claudeConfigDir)}`));
     console.log(chalk.green(`\u2713 Codex home: ${describeAgentHome(homes.codexHome)}`));
@@ -6208,7 +6208,7 @@ const DENIED_BASENAME_PATTERNS = [
 const DENIED_PATH_SUFFIXES = [
   `${sep}.git${sep}config`
 ];
-function expandHome(input, home) {
+function expandHome$1(input, home) {
   if (input === "~") return home;
   if (input.startsWith(`~${sep}`) || input.startsWith("~/")) {
     return resolve(home, input.slice(2));
@@ -6231,7 +6231,7 @@ function checkPreviewPath(input, opts) {
   if (input.includes("\0")) {
     return { resolved: "", deniedReason: "path contains a NUL byte" };
   }
-  const expanded = expandHome(input.trim(), home);
+  const expanded = expandHome$1(input.trim(), home);
   const resolved = isAbsolute(expanded) ? resolve(expanded) : resolve(cwd, expanded);
   for (const dir of DENIED_HOME_DIRS) {
     if (isUnder(resolved, resolve(home, dir))) {
@@ -9358,6 +9358,20 @@ export default async function(pi) {
     return data.result;
   }
   await rpc('initialize', {protocolVersion:'2024-11-05',capabilities:{},clientInfo:{name:'very-happy-pi-teams',version:'1'}});
+  if (!managed && pi.setSessionName) {
+    // B-500: name the pi session from its first prompt (managed sessions are titled by TitleGenerator).
+    let titleArmed = false, generation = 0;
+    pi.on('session_start', async () => { generation += 1; titleArmed = !pi.getSessionName?.(); });
+    pi.on('before_agent_start', async (event) => {
+      const prompt = event && typeof event.prompt === 'string' ? event.prompt : '';
+      if (!titleArmed || !prompt.trim()) return;
+      titleArmed = false;
+      const expected = generation;
+      rpc('very-happy/terminal-title-suggest', {prompt}).then(result => {
+        if (result && result.title && expected === generation && !pi.getSessionName?.()) pi.setSessionName(result.title);
+      }).catch(() => {});
+    });
+  }
   const available = await rpc('tools/list', {});
   for (const tool of available.tools || []) {
     pi.registerTool({name:tool.name,label:tool.name,description:tool.description || tool.name,parameters:tool.inputSchema,
@@ -9517,11 +9531,14 @@ function agentPiece(body) {
   }
   return null;
 }
-function analyzeLatestTurn(entries) {
+function userPromptText(body) {
+  return isUserPrompt(body) ? body.content.text : null;
+}
+function analyzeLatestTurn(entries, options = {}) {
   const lastSeq = entries.length > 0 ? entries[entries.length - 1].seq : 0;
   let userIndex = -1;
   for (let i = entries.length - 1; i >= 0; i--) {
-    if (isUserPrompt(entries[i].body)) {
+    if (isUserPrompt(entries[i].body) && (!options.anchor || options.anchor(entries[i].body))) {
       userIndex = i;
       break;
     }
@@ -9535,6 +9552,10 @@ function analyzeLatestTurn(entries) {
   const emitsStarts = entries.some((entry) => sessionEnvelope(entry.body)?.ev?.t === "turn-start");
   for (let i = userIndex + 1; i < entries.length; i++) {
     const body = entries[i].body;
+    if (options.anchor && isUserPrompt(body)) {
+      if (ended) break;
+      continue;
+    }
     const env = sessionEnvelope(body);
     if (env?.ev?.t === "turn-start") {
       lastMarker = "start";
@@ -10027,7 +10048,7 @@ function readReceipt(home, id) {
     throw error;
   }
 }
-function writeReceipt(home, receipt) {
+function writeReceipt$1(home, receipt) {
   ensurePrivateDirectorySync(join(home, "teams", "effects"));
   const target = receiptPath(home, receipt.operationId);
   const tmp = `${target}.${process.pid}.tmp`;
@@ -10104,7 +10125,7 @@ function createTeamWorker(deps) {
   const action = async (teamId, requestId, value) => (await http.post(`/v1/teams/${encodeURIComponent(teamId)}/actions`, { requestId, action: value })).data;
   async function complete(op, receipt) {
     await action(op.teamId, `complete-${op.id}`, { type: "complete-operation", operationId: op.id, machineId: deps.machineId, claimId: receipt.claimId, ...receipt.sessionId ? { sessionId: receipt.sessionId } : {}, ...op.type === "spawn" && receipt.directory ? { workingDirectory: receipt.directory } : {} });
-    writeReceipt(home, { ...receipt, phase: "completed" });
+    writeReceipt$1(home, { ...receipt, phase: "completed" });
   }
   async function execute(op) {
     let receipt = readReceipt(home, op.id);
@@ -10121,7 +10142,7 @@ function createTeamWorker(deps) {
       op = claimed.operation;
       credential = claimed.credential;
       receipt = { operationId: op.id, teamId: op.teamId, claimId: op.claimId, phase: "prepared" };
-      writeReceipt(home, receipt);
+      writeReceipt$1(home, receipt);
     }
     if (receipt.phase === "completed") return;
     try {
@@ -10134,7 +10155,7 @@ function createTeamWorker(deps) {
           if (!task) throw new Error("Task state unavailable; refusing to start");
           if (task.currentAttemptId !== op.attemptId || ["done", "cancelled"].includes(task.status)) {
             await action(op.teamId, `cancelled-before-spawn-${op.id}`, { type: "fail-operation", operationId: op.id, machineId: deps.machineId, claimId: receipt.claimId, error: "task_closed_before_spawn" });
-            writeReceipt(home, { ...receipt, phase: "completed" });
+            writeReceipt$1(home, { ...receipt, phase: "completed" });
             return;
           }
           if (!op.directory) throw new Error("No repository selected for worker");
@@ -10144,17 +10165,17 @@ function createTeamWorker(deps) {
           const scopeFile = join(scopes, `${op.id}.json`);
           writePrivateFileSync(scopeFile, JSON.stringify({ serverUrl: server, scopeToken: credential.token, teamId: op.teamId, botId: op.botId, taskId: op.taskId, attemptId: op.attemptId }));
           receipt = { ...receipt, ...resource, scopeFile, phase: "spawning" };
-          writeReceipt(home, receipt);
+          writeReceipt$1(home, receipt);
           const spawned = await deps.spawn({ directory: resource.directory, agent: op.assistant === "pi-acp" ? "pi" : op.assistant, permissionMode: op.permissionMode === "bypassPermissions" ? "bypassPermissions" : "default", spawnedBy: "teams", environmentVariables: { VH_TEAM_SCOPE_FILE: scopeFile, VH_TEAM_OPERATION_ID: op.id } });
           if (spawned.type !== "success") throw new Error(spawned.type === "error" ? spawned.errorMessage : "Directory approval required");
           receipt = { ...receipt, sessionId: spawned.sessionId, phase: "spawned" };
-          writeReceipt(home, receipt);
+          writeReceipt$1(home, receipt);
         }
         if (receipt.phase === "spawning") {
           const matches = Object.entries(readPersistedSessions()).filter(([, entry]) => entry.metadata?.teamOperationId === op.id);
           if (matches.length !== 1) throw new Error("Spawn outcome unknown; reconcile the worker before retrying");
           receipt = { ...receipt, sessionId: matches[0][0], phase: "spawned" };
-          writeReceipt(home, receipt);
+          writeReceipt$1(home, receipt);
         }
         if (receipt.phase === "spawned") {
           const current = (await http.get(`/v1/teams/${encodeURIComponent(op.teamId)}`)).data.team;
@@ -10169,14 +10190,14 @@ function createTeamWorker(deps) {
           const key = await waitForSessionKey(receipt.sessionId, 1e4);
           await sendUserMessage(receipt.sessionId, key, teamInitialPrompt(op.prompt, bot?.root === true, receipt.directory), "teams", { localId: `teams-initial-${op.id}`, sentFrom: "team", ...op.model ? { model: op.model } : {} });
           receipt = { ...receipt, phase: "delivered" };
-          writeReceipt(home, receipt);
+          writeReceipt$1(home, receipt);
         }
         await complete(op, receipt);
       } else {
         const team = (await http.get(`/v1/teams/${encodeURIComponent(op.teamId)}`)).data.team;
         const latest = team.operations.find((candidate) => candidate.id === op.id);
         if (latest?.status === "completed") {
-          writeReceipt(home, { ...receipt, phase: "completed" });
+          writeReceipt$1(home, { ...receipt, phase: "completed" });
           return;
         }
         const bot = team.bots.find((candidate) => candidate.id === op.botId);
@@ -10306,6 +10327,643 @@ Use the teams tools to inspect current task state before acting. This message is
   } };
 }
 
+function resolveSpawnPermissionMode(agent, explicit) {
+  return explicit ?? getAgentCodeDefaults(agent ?? "claude").permissionMode;
+}
+function outboundPermissionMode(agent, mode) {
+  const key = normalizeAgentKey(agent ?? "claude");
+  if ((key === "claude" || key === "pi") && mode === "yolo") return "bypassPermissions";
+  return mode;
+}
+function resolveFirstMessageMeta(input) {
+  const meta = {
+    permissionMode: outboundPermissionMode(input.agent, input.permissionMode)
+  };
+  if (input.explicitModel !== void 0) {
+    meta.model = input.explicitModel === "default" ? null : input.explicitModel;
+  }
+  if (normalizeAgentKey(input.agent ?? "claude") !== "claude") return meta;
+  if (meta.model === void 0) {
+    const model = getAgentCodeDefaults("claude").modelMode;
+    const runnable = !isClaudeOpus55Model(model) || supportsClaudeOpus55({ capabilities: input.capabilities ?? null });
+    meta.model = runnable && model !== "default" ? model : null;
+  }
+  meta.effort = null;
+  return meta;
+}
+
+function payloadJson(payload) {
+  if (!payload) return void 0;
+  try {
+    return JSON.parse(payload);
+  } catch {
+    return void 0;
+  }
+}
+function lookupPath(root, path) {
+  let current = root;
+  for (const segment of path) {
+    if (current === null || typeof current !== "object") return void 0;
+    current = current[segment];
+  }
+  return current;
+}
+function scalar(value) {
+  if (value === void 0 || value === null) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "";
+  }
+}
+function formatNow(now, tz) {
+  if (!tz) return new Date(now).toISOString();
+  try {
+    const parts = new Intl.DateTimeFormat("en-CA", { timeZone: tz, hourCycle: "h23", year: "numeric", month: "2-digit", day: "2-digit", hour: "2-digit", minute: "2-digit", second: "2-digit", timeZoneName: "longOffset" }).formatToParts(new Date(now));
+    const get = (type) => parts.find((p) => p.type === type)?.value ?? "";
+    const offset = get("timeZoneName").replace(/^GMT$/, "+00:00").replace(/^GMT/, "");
+    return `${get("year")}-${get("month")}-${get("day")}T${get("hour")}:${get("minute")}:${get("second")}${offset || "Z"}`;
+  } catch {
+    return new Date(now).toISOString();
+  }
+}
+function renderTemplate(text, context) {
+  const json = payloadJson(context.payload);
+  return text.replace(/\{\{\s*([a-zA-Z_][a-zA-Z0-9_.-]*)\s*\}\}/g, (whole, name) => {
+    if (name === "payload") return context.payload ?? "";
+    if (name.startsWith("payload.")) return scalar(lookupPath(json, name.slice("payload.".length).split(".")));
+    if (name === "run.id") return context.runId;
+    if (name === "automation.name") return context.automationName;
+    if (name === "now") return formatNow(context.now ?? Date.now(), context.tz);
+    return whole;
+  });
+}
+function renderAction(action, context) {
+  const r = (value) => renderTemplate(value, context);
+  if (action.kind === "spawn") return { ...action, prompt: r(action.prompt) };
+  if (action.kind === "send") return { ...action, prompt: r(action.prompt) };
+  return { ...action, command: action.command.map(r), ...action.env ? { env: Object.fromEntries(Object.entries(action.env).map(([k, v]) => [k, r(v)])) } : {} };
+}
+function clipText(text, maxChars, keep = "head") {
+  if (text.length <= maxChars) return text;
+  return keep === "head" ? text.slice(0, maxChars) : text.slice(text.length - maxChars);
+}
+const DURATION_UNITS = { ms: 1, s: 1e3, m: 6e4, h: 36e5, d: 864e5 };
+function parseDuration(raw) {
+  const text = raw.trim();
+  if (/^\d+$/.test(text)) return Number(text);
+  const re = /(\d+(?:\.\d+)?)(ms|s|m|h|d)/gy;
+  let total = 0;
+  let matched = 0;
+  let last = 0;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    total += Number(m[1]) * DURATION_UNITS[m[2]];
+    matched++;
+    last = re.lastIndex;
+  }
+  if (matched === 0 || last !== text.length) throw new Error(`Invalid duration: ${raw} (use e.g. 90s, 5m, 1h30m, 2d)`);
+  return Math.round(total);
+}
+function formatDuration(ms) {
+  if (ms % 864e5 === 0) return `${ms / 864e5}d`;
+  if (ms % 36e5 === 0) return `${ms / 36e5}h`;
+  if (ms % 6e4 === 0) return `${ms / 6e4}m`;
+  if (ms % 1e3 === 0) return `${ms / 1e3}s`;
+  return `${ms}ms`;
+}
+function triggerFromFlags(flags, now = Date.now()) {
+  const given = [flags.cron !== void 0, flags.every !== void 0, flags.at !== void 0, flags.manual === true].filter(Boolean).length;
+  if (given === 0) {
+    if (flags.tz !== void 0) throw new Error("--tz only applies with --cron");
+    return void 0;
+  }
+  if (given > 1) throw new Error("Use exactly one of --cron, --every, --at, --manual");
+  if (flags.cron !== void 0) {
+    if (!flags.tz) throw new Error("--cron requires --tz <IANA zone> (e.g. Asia/Singapore)");
+    return { kind: "cron", expr: flags.cron, tz: flags.tz };
+  }
+  if (flags.tz !== void 0) throw new Error("--tz only applies with --cron");
+  if (flags.every !== void 0) return { kind: "interval", everyMs: parseDuration(flags.every), anchorAt: now };
+  if (flags.at !== void 0) {
+    const at = Date.parse(flags.at);
+    if (!Number.isFinite(at)) throw new Error(`--at must be an ISO 8601 timestamp, got: ${flags.at}`);
+    return { kind: "once", at };
+  }
+  return { kind: "manual" };
+}
+function describeTrigger(trigger) {
+  switch (trigger.kind) {
+    case "cron":
+      return `cron ${trigger.expr} (${trigger.tz})`;
+    case "interval":
+      return `every ${formatDuration(trigger.everyMs)}`;
+    case "once":
+      return `once at ${new Date(trigger.at).toISOString()}`;
+    default:
+      return "manual";
+  }
+}
+function describeAction(action) {
+  if (action.kind === "spawn") return `spawn ${action.agent} in ${action.directory}${action.sticky ? ` (sticky ${action.sticky.key})` : ""}`;
+  if (action.kind === "send") return `send to session ${action.sessionId}`;
+  return `script ${action.command.join(" ")}`;
+}
+
+const RECEIPT_RETENTION_MS = 7 * 864e5;
+const RECEIPT_MAX_ENTRIES = 2e3;
+function receiptsPath(home) {
+  return join(home, "automation-receipts.json");
+}
+function readReceipts(home) {
+  let raw;
+  try {
+    raw = readFileSync(receiptsPath(home), "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return {};
+    throw error;
+  }
+  const parsed = JSON.parse(raw);
+  if (!parsed || typeof parsed !== "object" || typeof parsed.receipts !== "object") throw new Error("Invalid automation receipts file");
+  return parsed.receipts;
+}
+function writeReceipt(home, receipt, now = Date.now()) {
+  if (!/^[a-zA-Z0-9_-]{1,128}$/.test(receipt.runId)) throw new Error("Invalid automation run id");
+  const all = readReceipts(home);
+  const next = { ...receipt, updatedAt: now };
+  all[receipt.runId] = next;
+  const entries = Object.values(all).sort((a, b) => b.updatedAt - a.updatedAt);
+  const kept = {};
+  let finished = 0;
+  for (const entry of entries) {
+    if (entry.phase === "finished") {
+      if (now - entry.updatedAt > RECEIPT_RETENTION_MS || finished >= RECEIPT_MAX_ENTRIES) continue;
+      finished++;
+    }
+    kept[entry.runId] = entry;
+  }
+  const target = receiptsPath(home);
+  ensurePrivateDirectorySync(dirname(target));
+  const tmp = `${target}.${process.pid}.tmp`;
+  writePrivateFileSync(tmp, JSON.stringify({ version: 1, receipts: kept }));
+  const file = openSync(tmp, "r");
+  try {
+    fsyncSync(file);
+  } finally {
+    closeSync(file);
+  }
+  renameSync(tmp, target);
+  if (process.platform !== "win32") {
+    const directory = openSync(dirname(target), "r");
+    try {
+      fsyncSync(directory);
+    } finally {
+      closeSync(directory);
+    }
+  }
+  return next;
+}
+
+const SCRIPT_KILL_GRACE_MS = 1e4;
+const SCRIPT_DRAIN_MS = 2e3;
+class TailBuffer {
+  constructor(maxChars) {
+    this.maxChars = maxChars;
+  }
+  text = "";
+  push(chunk) {
+    this.text += chunk;
+    if (this.text.length > this.maxChars * 2) this.text = this.text.slice(this.text.length - this.maxChars);
+  }
+  value() {
+    return this.text.length > this.maxChars ? this.text.slice(this.text.length - this.maxChars) : this.text;
+  }
+}
+function killScriptTree(child, signal) {
+  if (child.exitCode !== null || child.signalCode !== null || !child.pid) return;
+  try {
+    if (process.platform !== "win32") process.kill(-child.pid, signal);
+    else child.kill(signal);
+  } catch {
+    try {
+      child.kill(signal);
+    } catch {
+    }
+  }
+}
+function terminateScriptTree(child) {
+  killScriptTree(child, "SIGTERM");
+  const killer = setTimeout(() => killScriptTree(child, "SIGKILL"), SCRIPT_KILL_GRACE_MS);
+  killer.unref();
+  child.once("exit", () => clearTimeout(killer));
+}
+function runScript(options) {
+  return new Promise((resolve) => {
+    const tail = new TailBuffer(AUTOMATION_SUMMARY_MAX_CHARS);
+    let timedOut = false;
+    let settled = false;
+    let child;
+    const timers = [];
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      for (const t of timers) clearTimeout(t);
+      resolve(result);
+    };
+    const timer = setTimeout(() => {
+      timedOut = true;
+      terminateScriptTree(child);
+    }, options.timeoutMs);
+    timer.unref();
+    timers.push(timer);
+    try {
+      child = spawn$3(options.command[0], options.command.slice(1), {
+        cwd: options.cwd,
+        shell: false,
+        windowsHide: true,
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: process.platform !== "win32",
+        env: { ...options.baseEnv ?? process.env, ...options.env ?? {} }
+      });
+    } catch (error) {
+      finish({ exitCode: null, signal: null, timedOut: false, output: "", error: error instanceof Error ? error.message : String(error) });
+      return;
+    }
+    options.onStart?.(child);
+    child.stdout?.setEncoding("utf8").on("data", (chunk) => tail.push(chunk));
+    child.stderr?.setEncoding("utf8").on("data", (chunk) => tail.push(chunk));
+    child.on("error", (error) => finish({ exitCode: null, signal: null, timedOut, output: tail.value(), error: error.message }));
+    child.on("close", (code, signal) => finish({ exitCode: code, signal, timedOut, output: tail.value() }));
+    child.on("exit", (code, signal) => {
+      const drain = setTimeout(() => {
+        killScriptTree(child, "SIGKILL");
+        finish({ exitCode: code, signal, timedOut, output: tail.value() });
+      }, SCRIPT_DRAIN_MS);
+      drain.unref();
+      timers.push(drain);
+    });
+  });
+}
+
+const AUTOMATION_TICK_MS = 5e3;
+const AUTOMATION_LEASE_RENEW_MS = 3e4;
+const AUTOMATION_LOG_READ_MS = 3e4;
+const AUTOMATION_UNAVAILABLE_LOG_MS = 10 * 6e4;
+const AUTOMATION_MAX_CONCURRENT = AUTOMATION_CLAIM_MAX_RUNS;
+const AUTOMATION_SPAWNED_BY = "automation";
+function automationPromptHeader(name, runId) {
+  return `[Very Happy automation "${name}" run ${runId}; finish with automation_report (runId ${runId}) or \`very-happy auto report --run ${runId}\`]`;
+}
+function automationRunAnchor(runId) {
+  const marker = ` run ${runId};`;
+  return (body) => userPromptText(body)?.startsWith("[Very Happy automation ") === true && userPromptText(body).includes(marker);
+}
+async function defaultReadTurn(sessionId, runId) {
+  const persisted = readPersistedSessions()[sessionId];
+  if (!persisted) throw new Error(`No local key for session ${sessionId}`);
+  return analyzeLatestTurn(await readSessionLog(sessionId, persisted, TURN_WINDOW), { anchor: automationRunAnchor(runId) });
+}
+async function defaultSend(sessionId, text, meta) {
+  const persisted = await waitForSessionKey(sessionId, 15e3);
+  await sendUserMessage(sessionId, persisted, text, "automation", { ...meta, sentFrom: "automation" });
+}
+function expandHome(path) {
+  if (path === "~") return homedir();
+  if (path.startsWith("~/")) return join(homedir(), path.slice(2));
+  return path;
+}
+function isSettledByServer(error) {
+  if (!(error instanceof AutomationsRequestError)) return false;
+  if (error.status === 409 && (error.code === "run_finished" || error.code === "claim_mismatch")) return true;
+  return error.status === 404 && error.code === "run_not_found";
+}
+function scriptAlive(item) {
+  return !!item.child && item.child.exitCode === null && item.child.signalCode === null;
+}
+function createAutomationRunner(deps) {
+  const home = deps.home ?? configuration.happyHomeDir;
+  const client = deps.client ?? createAutomationsClient({ serverUrl: deps.serverUrl ?? configuration.serverUrl, token: deps.token, client: "daemon-auto" });
+  const runScript$1 = deps.runScript ?? runScript;
+  const readTurn = deps.readTurn ?? defaultReadTurn;
+  const send = deps.send ?? defaultSend;
+  const prepareWorktree = deps.prepareWorktree ?? prepareTeamWorktree;
+  const now = deps.now ?? (() => Date.now());
+  const tracked = /* @__PURE__ */ new Map();
+  let running = false;
+  let renewing = false;
+  let closed = false;
+  let disabledUntil = 0;
+  let lastUnavailableLogAt = -Infinity;
+  let recovered = false;
+  function persist(receipt) {
+    writeReceipt(home, receipt, now());
+  }
+  async function finish(item, report2) {
+    try {
+      await client.report(item.runId, report2);
+    } catch (error) {
+      if (!isSettledByServer(error)) {
+        item.pendingFinal = report2;
+        deps.log(`Automation run ${item.runId} final report deferred`);
+        return;
+      }
+    }
+    persist({ runId: item.runId, automationId: item.automationId, kind: item.kind, phase: "finished", claimId: item.claimId, sessionId: item.sessionId });
+    tracked.delete(item.runId);
+  }
+  function track(claimed, kind, sessionId, child) {
+    const at = now();
+    const item = { runId: claimed.run.id, automationId: claimed.automation.id, claimId: claimed.run.claimId, kind, sessionId, child, sawTurn: false, startedAt: at, lastLeaseAt: at, nextLogReadAt: at + AUTOMATION_LOG_READ_MS, attentionReported: false, exited: false };
+    tracked.set(item.runId, item);
+    return item;
+  }
+  async function failNow(claimed, kind, error, attentionReason, sessionId) {
+    const item = track(claimed, kind, sessionId);
+    await finish(item, { claimId: item.claimId, status: "failed", error: clipText(error, AUTOMATION_SUMMARY_MAX_CHARS), ...sessionId ? { sessionId } : {}, ...attentionReason ? { needsAttention: true, attentionReason } : {} });
+  }
+  async function reportRunning(item, sessionId, stickyKey) {
+    const body = { claimId: item.claimId, status: "running", ...sessionId ? { sessionId } : {}, ...stickyKey ? { stickyKey } : {} };
+    try {
+      await client.report(item.runId, body);
+    } catch (error) {
+      if (isSettledByServer(error)) {
+        settleExternally(item);
+        return;
+      }
+      if (sessionId) item.pendingRunning = { sessionId, ...stickyKey ? { stickyKey } : {} };
+      deps.log(`Automation run ${item.runId} running report deferred`);
+    }
+  }
+  async function execute(claimed) {
+    const { run, automation } = claimed;
+    const existing = readReceipts(home)[run.id];
+    if (existing) {
+      if (existing.phase === "finished" || tracked.has(run.id)) return;
+      if (existing.phase === "starting") {
+        await failNow(claimed, existing.kind, "Local execution outcome unknown after restart; verify before re-running", "unknown_outcome");
+        return;
+      }
+      if (existing.kind === "script") {
+        await failNow(claimed, "script", "Daemon restarted while the script was running", "daemon_restarted");
+        return;
+      }
+      track(claimed, existing.kind, existing.sessionId).sawTurn = true;
+      return;
+    }
+    const context = { payload: run.payload, runId: run.id, automationName: automation.name, ...automation.trigger.kind === "cron" ? { tz: automation.trigger.tz } : {}, now: now() };
+    const action = renderAction(automation.action, context);
+    const env = { VH_AUTOMATION_RUN_ID: run.id, VH_AUTOMATION_NAME: automation.name };
+    const header = automationPromptHeader(automation.name, run.id);
+    if (action.kind === "script") {
+      const timeoutMs = action.timeoutMs ?? automation.maxRuntimeMs;
+      persist({ runId: run.id, automationId: automation.id, kind: "script", phase: "starting", claimId: run.claimId });
+      const item2 = track(claimed, "script");
+      const finished = runScript$1({
+        command: action.command,
+        cwd: action.cwd ? expandHome(action.cwd) : void 0,
+        timeoutMs,
+        env: { ...action.env ?? {}, ...env, ...run.payload ? { VH_AUTOMATION_PAYLOAD: run.payload } : {} },
+        onStart: (child) => {
+          item2.child = child;
+        }
+      });
+      persist({ runId: run.id, automationId: automation.id, kind: "script", phase: "running", claimId: run.claimId });
+      await reportRunning(item2);
+      void finished.then(async (result) => {
+        if (!tracked.has(run.id)) return;
+        const ok = result.exitCode === 0 && !result.timedOut && !result.error;
+        const error = result.error ? `Launch failed: ${result.error}` : result.timedOut ? `Timed out after ${timeoutMs}ms` : result.exitCode !== 0 ? `Exit ${result.exitCode ?? `signal ${result.signal}`}` : void 0;
+        await finish(item2, { claimId: run.claimId, status: ok ? "done" : "failed", summary: clipText(result.output, AUTOMATION_SUMMARY_MAX_CHARS, "tail"), exitCode: result.exitCode, ...error ? { error } : {} });
+      });
+      return;
+    }
+    if (action.kind === "send") {
+      if (!deps.live(action.sessionId)) {
+        await failNow(claimed, "send", `Session ${action.sessionId} is not running on this machine`, "session_not_live", action.sessionId);
+        return;
+      }
+      persist({ runId: run.id, automationId: automation.id, kind: "send", phase: "running", claimId: run.claimId, sessionId: action.sessionId });
+      try {
+        await send(action.sessionId, `${header}
+${action.prompt}`, { localId: `automation-${run.id}` });
+      } catch (error) {
+        await failNow(claimed, "send", `Message delivery failed: ${error instanceof Error ? error.message : String(error)}`, "send_failed", action.sessionId);
+        return;
+      }
+      await reportRunning(track(claimed, "send", action.sessionId), action.sessionId);
+      return;
+    }
+    const agent = action.agent;
+    if (!isSpawnAgent(agent)) {
+      await failNow(claimed, "spawn", `Unknown agent "${agent}"`, "invalid_action");
+      return;
+    }
+    if (action.permissionMode && sanitizeSpawnPermissionMode(action.permissionMode) === null) {
+      await failNow(claimed, "spawn", `Invalid permission mode "${action.permissionMode}"`, "invalid_action");
+      return;
+    }
+    const permissionMode = resolveSpawnPermissionMode(agent, action.permissionMode ?? void 0);
+    const stickyKey = action.sticky ? renderTemplate(action.sticky.key, context) : void 0;
+    if (stickyKey) {
+      const bound = claimed.stickies.find((sticky) => sticky.key === stickyKey);
+      if (bound && deps.live(bound.sessionId)) {
+        persist({ runId: run.id, automationId: automation.id, kind: "send", phase: "running", claimId: run.claimId, sessionId: bound.sessionId, stickyKey });
+        try {
+          await send(bound.sessionId, `${header}
+${action.prompt}`, { localId: `automation-${run.id}` });
+        } catch (error) {
+          await failNow(claimed, "send", `Sticky session delivery failed: ${error instanceof Error ? error.message : String(error)}`, "send_failed", bound.sessionId);
+          return;
+        }
+        await reportRunning(track(claimed, "send", bound.sessionId), bound.sessionId, stickyKey);
+        return;
+      }
+      if (bound) await client.deleteSticky(automation.id, stickyKey).catch(() => deps.log(`Automation ${automation.name}: stale sticky ${stickyKey} not cleared`));
+    }
+    let directory = expandHome(action.directory);
+    if (!isAbsolute(directory)) {
+      await failNow(claimed, "spawn", `Directory must be absolute: ${action.directory}`, "invalid_action");
+      return;
+    }
+    if (action.worktree) {
+      try {
+        directory = (await prepareWorktree(home, directory, `auto-${run.id}`)).directory;
+      } catch (error) {
+        await failNow(claimed, "spawn", `Worktree preparation failed: ${error instanceof Error ? error.message : String(error)}`, "worktree_failed");
+        return;
+      }
+    }
+    persist({ runId: run.id, automationId: automation.id, kind: "spawn", phase: "starting", claimId: run.claimId, stickyKey, ...action.worktree ? { directory } : {} });
+    const spawned = await deps.spawn({ directory, agent, permissionMode, spawnedBy: AUTOMATION_SPAWNED_BY, environmentVariables: env });
+    if (spawned.type !== "success") {
+      await failNow(claimed, "spawn", spawned.type === "error" ? spawned.errorMessage : "Directory approval required", "spawn_failed");
+      return;
+    }
+    persist({ runId: run.id, automationId: automation.id, kind: "spawn", phase: "running", claimId: run.claimId, sessionId: spawned.sessionId, stickyKey, ...action.worktree ? { directory } : {} });
+    const item = track(claimed, "spawn", spawned.sessionId);
+    try {
+      const capabilities = readPersistedSessions()[spawned.sessionId]?.metadata?.capabilities ?? null;
+      const meta = resolveFirstMessageMeta({ agent, permissionMode, explicitModel: action.model ?? void 0, capabilities });
+      await send(spawned.sessionId, `${header}
+${action.prompt}`, { localId: `automation-${run.id}`, ...meta });
+    } catch (error) {
+      await finish(item, { claimId: run.claimId, status: "failed", sessionId: spawned.sessionId, error: `First message failed: ${error instanceof Error ? error.message : String(error)}`, needsAttention: true, attentionReason: "first_message_failed" });
+      return;
+    }
+    await reportRunning(item, spawned.sessionId, stickyKey);
+  }
+  async function monitor() {
+    for (const item of [...tracked.values()]) {
+      if (closed) return;
+      if (item.pendingFinal) {
+        await finish(item, item.pendingFinal);
+        continue;
+      }
+      if (item.kind === "script") continue;
+      const sessionId = item.sessionId;
+      const active = deps.turnActive(sessionId);
+      if (active) item.sawTurn = true;
+      const alive = deps.live(sessionId) && !item.exited;
+      if (!alive) {
+        const turn2 = await readTurn(sessionId, item.runId).catch(() => null);
+        if (turn2?.ended && turn2.status !== "failed" && turn2.status !== "cancelled") await finish(item, { claimId: item.claimId, status: "done", sessionId, summary: clipText(turn2.answer, AUTOMATION_SUMMARY_MAX_CHARS) });
+        else await finish(item, { claimId: item.claimId, status: "failed", sessionId, error: turn2?.error ?? "Session exited before the turn ended", needsAttention: true, attentionReason: "session_exited" });
+        continue;
+      }
+      const edgeFell = item.sawTurn && !active;
+      if (!edgeFell && now() < item.nextLogReadAt) continue;
+      item.nextLogReadAt = now() + AUTOMATION_LOG_READ_MS;
+      if (edgeFell) item.sawTurn = false;
+      const turn = await readTurn(sessionId, item.runId).catch(() => null);
+      if (!turn?.ended) continue;
+      if (turn.status === "failed" || turn.status === "cancelled") await finish(item, { claimId: item.claimId, status: "failed", sessionId, error: turn.error ?? `Turn ${turn.status}`, needsAttention: true, attentionReason: `turn_${turn.status}` });
+      else await finish(item, { claimId: item.claimId, status: "done", sessionId, summary: clipText(turn.answer, AUTOMATION_SUMMARY_MAX_CHARS) });
+    }
+  }
+  async function renewAll() {
+    if (renewing || closed) return;
+    renewing = true;
+    try {
+      const at = now();
+      for (const item of [...tracked.values()]) {
+        if (closed) return;
+        if (at - item.lastLeaseAt < AUTOMATION_LEASE_RENEW_MS) continue;
+        item.lastLeaseAt = at;
+        const body = { claimId: item.claimId, leaseMs: AUTOMATION_DEFAULT_LEASE_MS, ...item.pendingRunning ? { status: "running", ...item.pendingRunning } : {} };
+        try {
+          const run = await client.report(item.runId, body);
+          item.pendingRunning = void 0;
+          if (isAutomationRunTerminal(run.status)) settleExternally(item);
+        } catch (error) {
+          if (isSettledByServer(error)) settleExternally(item);
+          else deps.log(`Automation run ${item.runId} lease renewal failed`);
+        }
+      }
+    } finally {
+      renewing = false;
+    }
+  }
+  function settleExternally(item) {
+    if (item.child && scriptAlive(item)) terminateScriptTree(item.child);
+    persist({ runId: item.runId, automationId: item.automationId, kind: item.kind, phase: "finished", claimId: item.claimId, sessionId: item.sessionId });
+    tracked.delete(item.runId);
+  }
+  async function recover() {
+    recovered = true;
+    let receipts;
+    try {
+      receipts = readReceipts(home);
+    } catch {
+      deps.log("Automation receipts unreadable; refusing to execute until repaired");
+      closed = true;
+      return;
+    }
+    for (const receipt of Object.values(receipts)) {
+      if (receipt.phase === "finished") continue;
+      const item = track({ run: { id: receipt.runId, claimId: receipt.claimId }, automation: { id: receipt.automationId } }, receipt.kind, receipt.sessionId);
+      item.sawTurn = true;
+      item.lastLeaseAt = 0;
+      if (receipt.phase === "starting") await finish(item, { claimId: receipt.claimId, status: "failed", error: "Daemon restarted before the launch outcome was known", needsAttention: true, attentionReason: "unknown_outcome" });
+      else if (receipt.kind === "script") await finish(item, { claimId: receipt.claimId, status: "failed", error: "Daemon restarted while the script was running", needsAttention: true, attentionReason: "daemon_restarted" });
+    }
+  }
+  async function tick() {
+    if (running || closed) return;
+    running = true;
+    try {
+      if (!recovered) await recover();
+      if (closed) return;
+      await monitor();
+      const capacity = AUTOMATION_MAX_CONCURRENT - tracked.size;
+      if (now() >= disabledUntil && capacity > 0) {
+        try {
+          const claimed = await client.claim({ machineId: deps.machineId, limit: capacity, leaseMs: AUTOMATION_DEFAULT_LEASE_MS });
+          await Promise.all(claimed.runs.map((entry) => closed ? Promise.resolve() : execute(entry).catch((error) => deps.log(`Automation run ${entry.run.id} failed to start: ${error instanceof Error ? error.message : String(error)}`))));
+        } catch (error) {
+          if (isAutomationsUnavailable(error)) {
+            disabledUntil = now() + 6e4;
+            if (now() - lastUnavailableLogAt >= AUTOMATION_UNAVAILABLE_LOG_MS) {
+              lastUnavailableLogAt = now();
+              deps.log("Automations unavailable on this server (404); claim loop idle");
+            }
+          } else {
+            disabledUntil = now() + 1e4;
+            deps.log(`Automation claim failed${error instanceof AutomationsRequestError ? ` (${error.status})` : ""}`);
+          }
+        }
+      }
+    } finally {
+      running = false;
+    }
+  }
+  function report(sessionId, event) {
+    for (const item of tracked.values()) {
+      if (item.sessionId !== sessionId) continue;
+      if (event === "exited") item.exited = true;
+      if (event === "blocked" && !item.attentionReported) {
+        item.attentionReported = true;
+        void client.report(item.runId, { claimId: item.claimId, needsAttention: true, attentionReason: "needs_input" }).catch(() => deps.log(`Automation run ${item.runId} attention report failed`));
+      }
+    }
+  }
+  const tickMs = deps.tickMs ?? AUTOMATION_TICK_MS;
+  const timer = setInterval(() => {
+    void tick();
+  }, tickMs);
+  timer.unref();
+  const leaseTimer = setInterval(() => {
+    void renewAll();
+  }, tickMs);
+  leaseTimer.unref();
+  void tick();
+  return {
+    tick,
+    renewAll,
+    report,
+    hasSession: (id) => [...tracked.values()].some((item) => item.sessionId === id),
+    trackedRunIds: () => [...tracked.keys()],
+    /** Executing a claim, or a script child is still alive — handover and auto-update wait for this. */
+    get busy() {
+      return running || [...tracked.values()].some(scriptAlive);
+    },
+    /**
+     * Stop the loops. `killScripts` (real shutdown) terminates live script
+     * trees; the next daemon's recovery reports them failed + attention from
+     * the receipt, never re-running them. A handover waits on `busy` instead.
+     */
+    stop: (options = {}) => {
+      closed = true;
+      clearInterval(timer);
+      clearInterval(leaseTimer);
+      if (options.killScripts) {
+        for (const item of tracked.values()) if (item.child && scriptAlive(item)) terminateScriptTree(item.child);
+      }
+    }
+  };
+}
+
 function daemonExitCode(source) {
   return source === "exception" ? 1 : 0;
 }
@@ -10466,6 +11124,7 @@ async function startDaemon() {
     const turnActivity = new TurnActivityTracker();
     const sessionIdToFinishedSession = /* @__PURE__ */ new Map();
     let teamWorker;
+    let automationRunner;
     const persisted = readPersistedSessions();
     const liveHappyProcesses = await findAllHappyProcesses();
     for (const [id, s] of Object.entries(persisted)) {
@@ -11320,6 +11979,7 @@ async function startDaemon() {
     const onChildExited = (pid) => {
       const session = pidToTrackedSession.get(pid);
       if (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);
       if (session?.happySessionId && session.encryption) {
         sessionIdToFinishedSession.set(session.happySessionId, session);
@@ -11339,6 +11999,7 @@ async function startDaemon() {
       }
     };
     const onSessionStateEvent = (sessionId, event, spawnedByFromSession) => {
+      if (automationRunner?.hasSession(sessionId)) automationRunner.report(sessionId, event === "completed" ? "idle" : "blocked");
       if (spawnedByFromSession === "teams" || teamWorker?.hasSession(sessionId) || [...pidToTrackedSession.values()].some((s) => s.happySessionId === sessionId && s.spawnedBy === "teams")) {
         teamWorker?.report(sessionId, event === "completed" ? "idle" : "blocked");
         return;
@@ -11577,7 +12238,7 @@ async function startDaemon() {
             } catch {
             }
           }
-          if (bundleReplaced && !teamWorker?.busy && !updateController.isRunning() && !turnActivity.hasActiveTurn()) {
+          if (bundleReplaced && !teamWorker?.busy && !automationRunner?.busy && !updateController.isRunning() && !turnActivity.hasActiveTurn()) {
             const preflight = await preflightNewBundle(bundlePath);
             if (preflight.action === "hold") {
               if (lastHandoverHold !== preflight.reason) {
@@ -11587,10 +12248,11 @@ async function startDaemon() {
               updateController.holdHandover(preflight.reason);
               return;
             }
-            if (teamWorker?.busy || updateController.isRunning() || turnActivity.hasActiveTurn()) return;
+            if (teamWorker?.busy || automationRunner?.busy || updateController.isRunning() || turnActivity.hasActiveTurn()) return;
             lastHandoverHold = null;
             logger.debug("[DAEMON RUN] Daemon bundle replaced on disk and verified, handing off to new daemon");
             teamWorker?.stop();
+            automationRunner?.stop();
             clearInterval(restartOnStaleVersionAndHeartbeat);
             clearInterval(cliUpdateInterval);
             stopAgentVersionChecks();
@@ -11642,6 +12304,14 @@ async function startDaemon() {
       live: (id) => [...pidToTrackedSession.values()].some((s) => s.happySessionId === id && isPidAlive(s.pid)),
       log: (message) => logger.debug(`[DAEMON RUN] ${message}`)
     });
+    automationRunner = createAutomationRunner({
+      machineId,
+      token: credentials.token,
+      spawn: spawnSession,
+      live: (id) => [...pidToTrackedSession.values()].some((s) => s.happySessionId === id && isPidAlive(s.pid)),
+      turnActive: (id) => turnActivity.activeSessions().includes(id),
+      log: (message) => logger.debug(`[DAEMON RUN] ${message}`)
+    });
     void apiMachine.updateMachineMetadata((current) => ({
       ...current ?? initialMachineMetadata,
       teamsVersion: 1,
@@ -11650,6 +12320,7 @@ async function startDaemon() {
     const cleanupAndShutdown = async (source, errorMessage) => {
       logger.debug(`[DAEMON RUN] Starting proper cleanup (source: ${source}, errorMessage: ${errorMessage})...`);
       teamWorker?.stop();
+      automationRunner?.stop({ killScripts: true });
       if (restartOnStaleVersionAndHeartbeat) {
         clearInterval(restartOnStaleVersionAndHeartbeat);
         logger.debug("[DAEMON RUN] Health check interval cleared");
@@ -12154,6 +12825,7 @@ function createMcpServer(handlers, options, sessionId) {
     version: "1.0.0"
   });
   registerTeamsTools(mcp, sessionId);
+  registerAutomationTools(mcp);
   mcp.registerTool("change_title", {
     description: "Change the title of the current chat session",
     title: "Change Chat Title",
@@ -12396,6 +13068,7 @@ async function startHappyServer(client, options) {
       PREVIEW_TOOL_NAME,
       REPORT_PROGRESS_TOOL_NAME,
       ...TEAM_TOOL_NAMES,
+      ...AUTOMATION_TOOL_NAMES,
       ...options?.assistant && !process.env.VH_TEAM_SCOPE_FILE ? ASSISTANT_TOOL_NAMES : []
     ],
     stop: () => {
@@ -12732,7 +13405,7 @@ function registerSideQuestionHandler(rpc, deps) {
   const retainMs = deps.retainMs ?? SIDE_QUESTION_RETAIN_MS;
   const maxRunMs = deps.maxRunMs ?? SIDE_QUESTION_MAX_RUN_MS;
   const fork = deps.run ?? (async (input) => {
-    const { query } = await import('./index-DYQgcgL2.mjs');
+    const { query } = await import('./index-BXA9fxbK.mjs');
     return runSideQuestion(query, input);
   });
   const run = async (input, live) => {
@@ -12909,7 +13582,12 @@ function runClaudeOneShot(binary, prompt) {
     try {
       child = spawn$3(binary, ["-p", "--model", "haiku", prompt], {
         stdio: ["ignore", "pipe", "ignore"],
-        env: process.env
+        // HAPPY_MANAGED=1: this claude is run BY happy. The user-wide
+        // terminal-mirror SessionStart hook exits on it, so a one-shot
+        // spawned from inside a vh web terminal (VH_TERMINAL_ID
+        // inherited — B-500's pi terminal bridge, or `very-happy` typed
+        // in a terminal) never binds a mirror session to itself.
+        env: { ...process.env, HAPPY_MANAGED: "1" }
       });
     } catch (error) {
       logger.debug("[titleGenerator] spawn failed", { error: String(error) });
@@ -12944,6 +13622,18 @@ function runClaudeOneShot(binary, prompt) {
     });
   });
 }
+async function suggestTitleForPrompt(prompt) {
+  const binary = resolveClaudeBinary();
+  if (!binary) {
+    logger.debug("[titleGenerator] no claude binary; skipping auto-title");
+    return null;
+  }
+  const stdout = await runClaudeOneShot(binary, buildPrompt(prompt));
+  if (stdout == null) return null;
+  const title = sanitizeTitle(stdout);
+  if (!title) logger.debug("[titleGenerator] empty/unusable title output; skipping");
+  return title;
+}
 class TitleGenerator {
   constructor(session) {
     this.session = session;
@@ -12967,23 +13657,12 @@ class TitleGenerator {
     });
   }
   async generate(firstUserMessage) {
-    const binary = resolveClaudeBinary();
-    if (!binary) {
-      logger.debug("[titleGenerator] no claude binary; skipping auto-title");
-      return;
-    }
     if (this.session.getMetadata()?.summary?.text) {
       logger.debug("[titleGenerator] summary appeared before generation; skipping");
       return;
     }
-    const prompt = buildPrompt(firstUserMessage);
-    const stdout = await runClaudeOneShot(binary, prompt);
-    if (stdout == null) return;
-    const title = sanitizeTitle(stdout);
-    if (!title) {
-      logger.debug("[titleGenerator] empty/unusable title output; skipping");
-      return;
-    }
+    const title = await suggestTitleForPrompt(firstUserMessage);
+    if (!title) return;
     if (this.session.getMetadata()?.summary?.text) {
       logger.debug("[titleGenerator] summary set during generation; not overwriting");
       return;
@@ -18011,7 +18690,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     process.exit(0);
   } else if (subcommand === "install-pi-tools") {
     try {
-      const { handleInstallPiTools } = await import('./installPiTools-C-Lxv4Bt.mjs');
+      const { handleInstallPiTools } = await import('./installPiTools-Cj7yU9Fc.mjs');
       await handleInstallPiTools(args.slice(1));
     } catch (error) {
       console.error(error instanceof Error ? error.message : "Pi tools installation failed");
@@ -18020,7 +18699,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "install-terminal-hooks") {
     try {
-      const { installTerminalHooks, parseTerminalHooksArgs, TERMINAL_HOOKS_HELP } = await import('./installTerminalHooks-Ch_yTtEA.mjs');
+      const { installTerminalHooks, parseTerminalHooksArgs, TERMINAL_HOOKS_HELP } = await import('./installTerminalHooks-Bpl32K75.mjs');
       const command = parseTerminalHooksArgs(args.slice(1));
       if (command.action === "help") {
         console.log(TERMINAL_HOOKS_HELP);
@@ -18037,7 +18716,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     }
   } else if (subcommand === "agent-home") {
     try {
-      const { parseAgentHomeArgs, runAgentHomeCommand } = await import('./agentHome-CeFDNzvq.mjs');
+      const { parseAgentHomeArgs, runAgentHomeCommand } = await import('./agentHome-D68Xh2ae.mjs');
       await runAgentHomeCommand(parseAgentHomeArgs(args.slice(1)));
       process.exit(0);
     } catch (error) {
@@ -18046,7 +18725,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     }
   } else if (subcommand === "spawn") {
     try {
-      const { handleSpawnCommand } = await import('./spawn-DxHIIqhi.mjs');
+      const { handleSpawnCommand } = await import('./spawn-C6fRkedx.mjs');
       await handleSpawnCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -18058,7 +18737,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "sessions") {
     try {
-      const { handleSessionsCommand } = await import('./sessions-DlU3foY_.mjs');
+      const { handleSessionsCommand } = await import('./sessions-iBnYzVUK.mjs');
       await handleSessionsCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -18070,7 +18749,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "send") {
     try {
-      const { handleSendCommand } = await import('./send-o6WM-1G8.mjs');
+      const { handleSendCommand } = await import('./send-Cs-RwqNf.mjs');
       await handleSendCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -18176,9 +18855,9 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     if (geminiSubcommand === "project" && args[2] === "set" && args[3]) {
       const projectId = args[3];
       try {
-        const { saveGoogleCloudProjectToConfig } = await import('./config-C-A1XF62.mjs');
-        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await import('./limits-DS-bnYYp.mjs').then(function (n) { return n.Y; });
-        const { ApiClient: ApiClient2 } = await import('./types-BN3eiipi.mjs').then(function (n) { return n.at; });
+        const { saveGoogleCloudProjectToConfig } = await import('./config-CHJ189UJ.mjs');
+        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await import('./limits-BtAuKRl2.mjs').then(function (n) { return n.al; });
+        const { ApiClient: ApiClient2 } = await import('./types-BvqOVUOW.mjs').then(function (n) { return n.ah; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentialsForConfiguredRelay2();
@@ -18209,7 +18888,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     }
     if (geminiSubcommand === "project" && args[2] === "get") {
       try {
-        const { readGeminiLocalConfig } = await import('./config-C-A1XF62.mjs');
+        const { readGeminiLocalConfig } = await import('./config-CHJ189UJ.mjs');
         const config = readGeminiLocalConfig();
         if (config.googleCloudProject) {
           console.log(`Current Google Cloud Project: ${config.googleCloudProject}`);
@@ -18249,7 +18928,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
       process.exit(0);
     }
     try {
-      const { runGemini } = await import('./runGemini-DvJwQVGp.mjs');
+      const { runGemini } = await import('./runGemini-YqH7a-7O.mjs');
       let startedBy = void 0;
       for (let i = 1; i < args.length; i++) {
         if (args[i] === "--started-by") {
@@ -18272,7 +18951,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
   } else if (subcommand === "pi") {
     if (args[1] === "--terminal") {
       try {
-        const { runPiTerminal } = await import('./piTerminal-M677UP7y.mjs');
+        const { runPiTerminal } = await import('./piTerminal-BoHvPEZ_.mjs');
         process.exitCode = await runPiTerminal(args.slice(2));
       } catch (error) {
         console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -18289,7 +18968,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
       }
     };
     try {
-      const { runAcp, resolveAcpAgentConfig } = await import('./index-DEp6CmmS.mjs');
+      const { runAcp, resolveAcpAgentConfig } = await import('./index-BgYZGODP.mjs');
       const parsed = parsePiRunnerArgs(args.slice(1));
       const resolved = resolveAcpAgentConfig(["pi", ...parsed.passthrough]);
       const { credentials } = await authAndSetupMachineIfNeeded();
@@ -18317,7 +18996,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "acp") {
     try {
-      const { runAcp, resolveAcpAgentConfig } = await import('./index-DEp6CmmS.mjs');
+      const { runAcp, resolveAcpAgentConfig } = await import('./index-BgYZGODP.mjs');
       let startedBy = void 0;
       let verbose = false;
       const acpArgs = [];
@@ -18357,7 +19036,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "openclaw") {
     try {
-      const { runOpenClaw } = await import('./runOpenClaw-BG82bF18.mjs');
+      const { runOpenClaw } = await import('./runOpenClaw-DSSyFQBb.mjs');
       let startedBy = void 0;
       let verbose = false;
       let gatewayUrl;
@@ -18408,7 +19087,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "todo") {
     try {
-      const { handleTodoCommand } = await import('./todo-BhJbG5eq.mjs');
+      const { handleTodoCommand } = await import('./todo-aCZmSt27.mjs');
       await handleTodoCommand(args.slice(1));
     } catch (error) {
       console.error(JSON.stringify({ error: error instanceof Error ? error.message : "Todo command failed" }));
@@ -18417,16 +19096,28 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "teams") {
     try {
-      const { handleTeamsCommand } = await import('./teams-DoAA_CcN.mjs');
+      const { handleTeamsCommand } = await import('./teams-CkrWQ4uM.mjs');
       await handleTeamsCommand(args.slice(1));
     } catch (error) {
       console.error(error instanceof Error ? error.message : "Teams command failed");
       process.exitCode = 1;
     }
     return;
+  } else if (subcommand === "auto") {
+    try {
+      const { handleAutoCommand } = await import('./auto-CcXxfqkC.mjs');
+      await handleAutoCommand(args.slice(1));
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Automation command failed");
+      if (process.env.DEBUG) {
+        console.error(error);
+      }
+      process.exitCode = 1;
+    }
+    return;
   } else if (subcommand === "mcp" && (args.length === 1 || args.length === 2 && args[1] === "--terminal-tools")) {
     try {
-      const { handleMcpCommand } = await import('./mcp-zu8n8TkR.mjs');
+      const { handleMcpCommand } = await import('./mcp-DQkmk4VV.mjs');
       await handleMcpCommand(args[1] === "--terminal-tools");
     } catch (error) {
       process.stderr.write(`[very-happy mcp] Fatal: ${error instanceof Error ? error.message : String(error)}
@@ -18660,6 +19351,8 @@ ${chalk.bold("Usage:")}
                             conversations on this machine (agent-home --help)
   very-happy connect           Connect AI vendor API keys
   very-happy todo              Built-in Todos and official agent skill (todo --help)
+  very-happy auto              Scheduled / triggered automations: spawn, sticky
+                            sessions or scripts with tracked runs (auto --help)
   very-happy sandbox           Configure and manage OS-level sandboxing
   very-happy notify            Send push notification
   very-happy mcp               Stdio MCP server exposing copy_to_clipboard for a
@@ -18794,4 +19487,4 @@ ${chalk.bold("Examples:")}
   }
 }
 
-export { ALLOWED_SPAWN_PERMISSION_MODES as A, TitleGenerator as B, registerKillSessionHandler as C, DEFAULT_RECENT_LIMIT as D, CLAUDE_ATTACHMENT_KINDS as E, stageClaudeAttachments as F, GEMINI_MODEL_ENV as G, appendStagedAttachmentsToPrompt as H, BasePermissionHandler as I, writeSessionModeFile as J, normalizeAcpPermissionMode as K, removeSessionModeFile as L, MAX_READ_LIMIT as M, TEAM_SKILL as N, GEMINI_API_KEY_ENV as O, PI_TEAMS_EXTENSION as P, GOOGLE_API_KEY_ENV as Q, BaseReasoningProcessor as R, SPAWN_AGENTS as S, TurnWaitTimeoutError as T, MessageBuffer as U, CHANGE_TITLE_INSTRUCTION as V, listSessions as a, resolvePermissionRequest as b, archiveSession as c, sendUserMessage as d, sessionWebUrl as e, DEFAULT_GEMINI_MODEL as f, checkPreviewPath as g, registerAssistantSessionTools as h, readSessionMetadata as i, isValidSpawnOrigin as j, sanitizeSpawnPermissionMode as k, listAccountSessions as l, waitForSessionKey as m, initialMachineMetadata as n, createSessionMetadata as o, setupOfflineReconnection as p, query as q, readSessionTranscript as r, stopSession as s, tmuxSupportsSessionEnv as t, StreamRelay as u, MessageQueue2 as v, waitForTurnEnd as w, hashObject as x, startHappyServer as y, registerAgentAttachmentDownloads as z };
+export { MessageBuffer as $, ALLOWED_SPAWN_PERMISSION_MODES as A, initialMachineMetadata as B, createSessionMetadata as C, DEFAULT_RECENT_LIMIT as D, setupOfflineReconnection as E, StreamRelay as F, GEMINI_MODEL_ENV as G, MessageQueue2 as H, hashObject as I, startHappyServer as J, registerAgentAttachmentDownloads as K, TitleGenerator as L, MAX_READ_LIMIT as M, registerKillSessionHandler as N, CLAUDE_ATTACHMENT_KINDS as O, PI_TEAMS_EXTENSION as P, stageClaudeAttachments as Q, appendStagedAttachmentsToPrompt as R, SPAWN_AGENTS as S, TurnWaitTimeoutError as T, BasePermissionHandler as U, writeSessionModeFile as V, normalizeAcpPermissionMode as W, removeSessionModeFile as X, GEMINI_API_KEY_ENV as Y, GOOGLE_API_KEY_ENV as Z, BaseReasoningProcessor as _, listSessions as a, CHANGE_TITLE_INSTRUCTION as a0, resolvePermissionRequest as b, archiveSession as c, sendUserMessage as d, sessionWebUrl as e, DEFAULT_GEMINI_MODEL as f, describeTrigger as g, describeAction as h, sanitizeSpawnPermissionMode as i, tmuxSupportsSessionEnv as j, readSessionMetadata as k, listAccountSessions as l, resolveSpawnPermissionMode as m, resolveFirstMessageMeta as n, isValidSpawnOrigin as o, parseDuration as p, query as q, readSessionTranscript as r, stopSession as s, triggerFromFlags as t, waitForSessionKey as u, checkPreviewPath as v, waitForTurnEnd as w, registerAssistantSessionTools as x, suggestTitleForPrompt as y, TEAM_SKILL as z };