very-happy-cli 0.2.150 → 0.2.152

package/dist/{index-K6mUS0jF.cjs → index-ZIW1jrYm.cjs}

@@ -3,14 +3,14 @@
 var chalk = require('chalk');
 var os = require('node:os');
 var node_crypto = require('node:crypto');
-var index = require('./types-D2Gkpe0N.cjs');
-var persistence = require('./limits-Dyma1REp.cjs');
+var index = require('./types-CN28qJl7.cjs');
+var persistence = require('./limits-BNTWyUaZ.cjs');
 var spawn = require('cross-spawn');
 var path = require('node:path');
 var node_readline = require('node:readline');
 var node_fs = require('node:fs');
 var projectPath = require('./projectPath-ChLhdOyt.cjs');
-var agentGuidance = require('./agentGuidance-Dla-BXO8.cjs');
+var agentGuidance = require('./agentGuidance-CqBn77AI.cjs');
 var promises = require('node:fs/promises');
 var fs = require('fs/promises');
 var ink = require('ink');
@@ -478,17 +478,23 @@ function readClaudeSettings() {
 }
 function shouldIncludeCoAuthoredBy() {
   const settings = readClaudeSettings();
-  if (!settings || settings.includeCoAuthoredBy === void 0) {
+  if (!settings) {
+    return true;
+  }
+  if (settings.attribution?.commit === "") {
+    return false;
+  }
+  if (settings.includeCoAuthoredBy === void 0) {
     return true;
   }
   return settings.includeCoAuthoredBy;
 }
 
 const BASE_SYSTEM_PROMPT = (() => agentGuidance.trimIdent(`
-    ALWAYS when you start a new chat - you must call a tool "mcp__happy__change_title" to set a chat title. When you think chat title is not relevant anymore - call the tool again to change it. When chat name is too generic and you have a change to make it more specific - call the tool again to change it. This title is needed to easily find the chat in the future. Help human.
-`))() + "\n\n" + agentGuidance.AGENT_GUIDANCE + "\n\n" + index.BUILTIN_TODO_DISCOVERY;
+    This chat is titled automatically from the user's first message. Call "mcp__happy__change_title" only when the topic has clearly moved on or the current title is too generic to find this chat later. Do not call it as a ritual at the start of a chat, and not for a quick question you can just answer.
+`))() + "\n\n" + agentGuidance.AGENT_GUIDANCE + "\n\n" + persistence.BUILTIN_TODO_DISCOVERY;
 const CO_AUTHORED_CREDITS = (() => agentGuidance.trimIdent(`
-    When making commit messages, instead of just giving co-credit to Claude, also give credit to Happy like so:
+    When you yourself create a git commit, instead of just giving co-credit to Claude, also give credit to Happy like so:
 
     <main commit message>
 
@@ -496,6 +502,8 @@ const CO_AUTHORED_CREDITS = (() => agentGuidance.trimIdent(`
     via [Very Happy](https://github.com/Mereithhh/very-happy)
 
     Co-Authored-By: Claude <noreply@anthropic.com>
+
+    Do not add these lines to commit message text you only draft for the user.
 `))();
 const systemPrompt = (() => {
   const includeCoAuthored = shouldIncludeCoAuthoredBy();
@@ -892,7 +900,7 @@ async function createSessionScanner(opts) {
   let processedMessageKeys = /* @__PURE__ */ new Set();
   let deadSessions = /* @__PURE__ */ new Set();
   if (opts.sessionId) {
-    let messages = await readSessionLog(projectDir, opts.sessionId);
+    let messages = await readSessionLog$1(projectDir, opts.sessionId);
     persistence.logger.debug(`[SESSION_SCANNER] Marking ${messages.length} existing messages as processed from session ${opts.sessionId}`);
     for (let m of messages) {
       processedMessageKeys.add(messageKey(m));
@@ -915,7 +923,7 @@ async function createSessionScanner(opts) {
       }
     }
     for (let session of sessions) {
-      const sessionMessages = await readSessionLog(projectDir, session);
+      const sessionMessages = await readSessionLog$1(projectDir, session);
       let skipped = 0;
       let sent = 0;
       for (let file of sessionMessages) {
@@ -992,7 +1000,7 @@ async function createSessionScanner(opts) {
         return;
       }
       if (options?.treatExistingAsProcessed) {
-        const existing = await readSessionLog(projectDir, sessionId);
+        const existing = await readSessionLog$1(projectDir, sessionId);
         persistence.logger.debug(`[SESSION_SCANNER] Pre-marking ${existing.length} existing messages as processed for new session ${sessionId}`);
         for (const m of existing) {
           processedMessageKeys.add(messageKey(m));
@@ -1020,7 +1028,7 @@ function messageKey(message) {
     throw Error();
   }
 }
-async function readSessionLog(projectDir, sessionId) {
+async function readSessionLog$1(projectDir, sessionId) {
   const expectedSessionFile = path.join(projectDir, `${sessionId}.jsonl`);
   persistence.logger.debug(`[SESSION_SCANNER] Reading session file: ${expectedSessionFile}`);
   let file;
@@ -3499,7 +3507,7 @@ class StreamRelay {
     }
     this.pending.text += text;
     this.pending.bytes += Buffer.byteLength(text, "utf8");
-    if (this.pending.bytes >= STREAM_FLUSH_MAX_BYTES || this.pending.text.length >= index.STREAM_DELTA_MAX_CHARS) {
+    if (this.pending.bytes >= STREAM_FLUSH_MAX_BYTES || this.pending.text.length >= persistence.STREAM_DELTA_MAX_CHARS) {
       this.flushPending();
       return;
     }
@@ -5394,8 +5402,8 @@ ${typeLabels[type] || type}:`));
   }
   console.log(chalk.gray("  An external claude command is only needed for native terminal/mirror use."));
   try {
-    const { resolveAgentHomesForCli } = await Promise.resolve().then(function () { return require('./agentHome-rylNIkix.cjs'); });
-    const { describeAgentHome } = await Promise.resolve().then(function () { return require('./types-D2Gkpe0N.cjs'); }).then(function (n) { return n.index; });
+    const { resolveAgentHomesForCli } = await Promise.resolve().then(function () { return require('./agentHome-CpJjrQZc.cjs'); });
+    const { describeAgentHome } = await Promise.resolve().then(function () { return require('./types-CN28qJl7.cjs'); }).then(function (n) { return n.index; });
     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)}`));
@@ -5506,7 +5514,7 @@ async function registryVersion(name) {
   return typeof data.version === "string" ? stableVersion(data.version) : null;
 }
 async function detectAgentVersions(deps = { probe: probeAgentVersion, registryVersion }, now = Date.now()) {
-  const agents = await Promise.all(index.AGENT_VERSION_SOURCES.map(async (source) => {
+  const agents = await Promise.all(persistence.AGENT_VERSION_SOURCES.map(async (source) => {
     const local = source.command ? await deps.probe(source.command).catch(() => ({ version: null, missing: false })) : { version: stableVersion(persistence.packageJson.dependencies["@anthropic-ai/claude-agent-sdk"]), missing: false };
     if (local.missing) return { id: source.id, installed: null, latest: null, status: "not-installed" };
     const latest = await deps.registryVersion(source.package).catch(() => null);
@@ -6106,7 +6114,9 @@ async function sendUserMessage(sessionId, persisted, text, client, options = {})
     },
     meta: {
       sentFrom: options.sentFrom ?? "cli",
-      ...options.model ? { model: options.model } : {}
+      ...options.model !== void 0 ? { model: options.model } : {},
+      ...options.permissionMode !== void 0 ? { permissionMode: options.permissionMode } : {},
+      ...options.effort !== void 0 ? { effort: options.effort } : {}
     }
   };
   const encrypted = persistence.encodeBase64(persistence.encrypt(
@@ -6220,7 +6230,7 @@ const DENIED_BASENAME_PATTERNS = [
 const DENIED_PATH_SUFFIXES = [
   `${path.sep}.git${path.sep}config`
 ];
-function expandHome(input, home) {
+function expandHome$1(input, home) {
   if (input === "~") return home;
   if (input.startsWith(`~${path.sep}`) || input.startsWith("~/")) {
     return path.resolve(home, input.slice(2));
@@ -6243,7 +6253,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 = path.isAbsolute(expanded) ? path.resolve(expanded) : path.resolve(cwd, expanded);
   for (const dir of DENIED_HOME_DIRS) {
     if (isUnder(resolved, path.resolve(home, dir))) {
@@ -6417,13 +6427,22 @@ function startDaemonControlServer({
           permissionMode: z.z.string().optional(),
           // B-069: spawn-origin tag ('assistant' = session_spawn). Recorded on
           // the TrackedSession; old clients never send it.
-          spawnedBy: z.z.string().optional()
+          spawnedBy: z.z.string().optional(),
+          // B-492: `very-happy spawn --fork` — same fields the web's fork flow
+          // sends over the machine RPC. Old CLIs never send them.
+          resumeClaudeSessionId: z.z.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i).optional(),
+          resumeCodexThreadId: z.z.string().min(1).max(200).optional(),
+          parentSessionId: z.z.string().min(1).max(200).optional()
         }),
         response: {
           200: z.z.object({
             success: z.z.boolean(),
             sessionId: z.z.string().optional(),
-            approvedNewDirectoryCreation: z.z.boolean().optional()
+            approvedNewDirectoryCreation: z.z.boolean().optional(),
+            // B-492: true when resumeClaudeSessionId / resumeCodexThreadId was
+            // honoured. A caller that asked for a fork and does not get this
+            // back is talking to an older daemon that spawned a fresh session.
+            resumed: z.z.boolean().optional()
           }),
           409: z.z.object({
             success: z.z.boolean(),
@@ -6438,13 +6457,14 @@ function startDaemonControlServer({
         }
       }
     }, async (request, reply) => {
-      const { directory, sessionId, agent, environmentVariables, variant, forceNew, permissionMode, spawnedBy } = request.body;
+      const { directory, sessionId, agent, environmentVariables, variant, forceNew, permissionMode, spawnedBy, resumeClaudeSessionId, resumeCodexThreadId, parentSessionId } = request.body;
       if (!directory && variant !== "assistant") {
         reply.code(500);
         return { success: false, error: "directory is required" };
       }
       persistence.logger.debug(`[CONTROL SERVER] Spawn session request: dir=${directory}, sessionId=${sessionId || "new"}, agent=${agent || "default"}, variant=${variant || "none"}, forceNew=${forceNew === true}, spawnedBy=${spawnedBy || "unset"}`);
-      const result = await spawnSession({ directory, sessionId, agent, environmentVariables, variant, forceNew, permissionMode, spawnedBy });
+      const result = await spawnSession({ directory, sessionId, agent, environmentVariables, variant, forceNew, permissionMode, spawnedBy, resumeClaudeSessionId, resumeCodexThreadId, parentSessionId });
+      const resumed = Boolean(resumeClaudeSessionId || resumeCodexThreadId);
       switch (result.type) {
         case "success":
           if (!result.sessionId) {
@@ -6457,7 +6477,8 @@ function startDaemonControlServer({
           return {
             success: true,
             sessionId: result.sessionId,
-            approvedNewDirectoryCreation: true
+            approvedNewDirectoryCreation: true,
+            ...resumed ? { resumed: true } : {}
           };
         case "requestToApproveDirectoryCreation":
           reply.code(409);
@@ -8123,7 +8144,7 @@ function parseJsonObject(text) {
     return null;
   }
 }
-function resolveSdkClaudeBinary(platform = process.platform, arch = process.arch, resolver = (s) => node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-K6mUS0jF.cjs', document.baseURI).href))).resolve(s)) {
+function resolveSdkClaudeBinary(platform = process.platform, arch = process.arch, resolver = (s) => node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-ZIW1jrYm.cjs', document.baseURI).href))).resolve(s)) {
   const platformArch = `${platform}-${arch}`;
   const candidates = [
     `@anthropic-ai/claude-agent-sdk-${platformArch}/claude`,
@@ -9389,6 +9410,8 @@ ${goal}`;
 
 const MAX_LINE_CHARS = 500;
 const MAX_ARGS_CHARS = 160;
+const DEFAULT_LIMITS = { line: MAX_LINE_CHARS, args: MAX_ARGS_CHARS };
+const NO_LIMITS = { line: Number.POSITIVE_INFINITY, args: Number.POSITIVE_INFINITY };
 function truncateText(text, max = MAX_LINE_CHARS) {
   const chars = Array.from(text);
   if (chars.length <= max) return text;
@@ -9404,12 +9427,12 @@ function safeJson(value, max) {
     return "[unserializable]";
   }
 }
-function formatMessageBody(body) {
+function formatMessageBody(body, limits = DEFAULT_LIMITS) {
   if (!body || typeof body !== "object") return null;
   const b = body;
   if (b.role === "user" && b.content?.type === "text" && typeof b.content.text === "string") {
     const text = squash(b.content.text);
-    return text.length > 0 ? `user: ${truncateText(text)}` : null;
+    return text.length > 0 ? `user: ${truncateText(text, limits.line)}` : null;
   }
   if (b.role === "session" && b.content && typeof b.content === "object") {
     const env = b.content;
@@ -9421,18 +9444,18 @@ function formatMessageBody(body) {
         const text = squash(String(ev.text ?? ""));
         if (text.length === 0) return null;
         const role = env.role === "user" ? "user" : "assistant";
-        return `${role}: ${truncateText(text)}`;
+        return `${role}: ${truncateText(text, limits.line)}`;
       }
       case "tool-call-start": {
         const name = String(ev.name ?? "tool");
         const title = squash(String(ev.title ?? ""));
-        const args = ev.args ? safeJson(ev.args, MAX_ARGS_CHARS) : "";
+        const args = ev.args ? safeJson(ev.args, limits.args) : "";
         const detail = title || args;
-        return `[tool] ${name}${detail ? `: ${truncateText(detail, MAX_ARGS_CHARS)}` : ""}`;
+        return `[tool] ${name}${detail ? `: ${truncateText(detail, limits.args)}` : ""}`;
       }
       case "service": {
         const text = squash(String(ev.text ?? ""));
-        return text.length > 0 ? `[service] ${truncateText(text, MAX_ARGS_CHARS)}` : null;
+        return text.length > 0 ? `[service] ${truncateText(text, limits.args)}` : null;
       }
       case "turn-end": {
         if (ev.status && ev.status !== "completed") return `[turn ${ev.status}]`;
@@ -9447,12 +9470,12 @@ function formatMessageBody(body) {
     switch (d.type) {
       case "message": {
         const text = squash(String(d.message ?? ""));
-        return text.length > 0 ? `assistant: ${truncateText(text)}` : null;
+        return text.length > 0 ? `assistant: ${truncateText(text, limits.line)}` : null;
       }
       case "tool-call":
-        return `[tool] ${String(d.name ?? "tool")}: ${safeJson(d.input, MAX_ARGS_CHARS)}`;
+        return `[tool] ${String(d.name ?? "tool")}: ${safeJson(d.input, limits.args)}`;
       case "permission-request":
-        return `[permission] ${String(d.toolName ?? "")}: ${truncateText(squash(String(d.description ?? "")), MAX_ARGS_CHARS)}`;
+        return `[permission] ${String(d.toolName ?? "")}: ${truncateText(squash(String(d.description ?? "")), limits.args)}`;
       default:
         return null;
     }
@@ -9463,22 +9486,118 @@ function formatMessageBody(body) {
       const texts = msg.content.filter((c) => c?.type === "text" && typeof c.text === "string").map((c) => squash(c.text)).filter((t) => t.length > 0);
       if (texts.length > 0) {
         const role = msg.role === "user" ? "user" : "assistant";
-        return `${role}: ${truncateText(texts.join(" "))}`;
+        return `${role}: ${truncateText(texts.join(" "), limits.line)}`;
       }
     }
     return null;
   }
   return null;
 }
-function formatTranscript(bodies) {
+function formatTranscript(bodies, options = {}) {
+  const limits = options.full ? NO_LIMITS : DEFAULT_LIMITS;
   const lines = [];
   for (const body of bodies) {
-    const line = formatMessageBody(body);
+    const line = formatMessageBody(body, limits);
     if (line !== null) lines.push(line);
   }
   return lines.join("\n");
 }
 
+function asRecord(value) {
+  return value && typeof value === "object" ? value : null;
+}
+function sessionEnvelope(body) {
+  const b = asRecord(body);
+  if (!b || b.role !== "session") return null;
+  const env = asRecord(b.content);
+  if (!env) return null;
+  const ev = asRecord(env.ev);
+  return ev && typeof ev.t === "string" ? { role: env.role, ev } : null;
+}
+function isUserPrompt(body) {
+  const b = asRecord(body);
+  return !!b && b.role === "user" && b.content?.type === "text" && typeof b.content.text === "string";
+}
+function agentPiece(body) {
+  const env = sessionEnvelope(body);
+  if (env && env.role !== "user") {
+    if (env.ev.t === "text" && !env.ev.thinking) {
+      const text = String(env.ev.text ?? "");
+      return text.trim().length > 0 ? { kind: "text", text } : null;
+    }
+    if (env.ev.t === "tool-call-start") return { kind: "tool" };
+    return null;
+  }
+  const b = asRecord(body);
+  if (b?.role === "agent" && b.content?.type === "acp") {
+    const d = asRecord(b.content.data);
+    if (d?.type === "message") {
+      const text = String(d.message ?? "");
+      return text.trim().length > 0 ? { kind: "text", text } : null;
+    }
+    if (d?.type === "tool-call") return { kind: "tool" };
+  }
+  return null;
+}
+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) && (!options.anchor || options.anchor(entries[i].body))) {
+      userIndex = i;
+      break;
+    }
+  }
+  let ended = false;
+  let status = null;
+  let error = null;
+  let texts = [];
+  let lastMarker = null;
+  let startedAfterPrompt = false;
+  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";
+      startedAfterPrompt = true;
+      ended = false;
+      status = null;
+      error = null;
+      texts = [];
+      continue;
+    }
+    if (env?.ev?.t === "turn-end") {
+      lastMarker = "end";
+      if (userIndex >= 0 && emitsStarts && !startedAfterPrompt) continue;
+      ended = true;
+      status = typeof env.ev.status === "string" ? env.ev.status : null;
+      error = typeof env.ev.error === "string" ? env.ev.error : null;
+      continue;
+    }
+    const piece = agentPiece(body);
+    if (!piece) continue;
+    if (piece.kind === "tool") texts = [];
+    else texts.push(piece.text);
+  }
+  if (userIndex < 0) ended = lastMarker === "end";
+  return {
+    userSeq: userIndex >= 0 ? entries[userIndex].seq : null,
+    ended,
+    status: ended ? status : null,
+    error: ended ? error : null,
+    answer: texts.join("\n\n").trim(),
+    lastSeq
+  };
+}
+
 const USER_SOCKET_CONNECT_TIMEOUT_MS = 15e3;
 async function openUserScopedSocket(token, options = {}) {
   const socket = socket_ioClient.io(persistence.configuration.serverUrl, {
@@ -9824,19 +9943,21 @@ async function bearerToken() {
   if (!credentials) throw new Error("CLI is not authenticated (no ~/.happy/access.key)");
   return credentials.token;
 }
-async function readSessionTranscript(sessionId, limit) {
+function requirePersisted(sessionId) {
   const persisted = persistence.readPersistedSessions()[sessionId];
   if (!persisted) {
     throw new Error(
       `No local key for session ${sessionId} \u2014 it was not spawned by this machine's daemon (or is older than 14 days).`
     );
   }
-  const bounded = Math.max(1, Math.min(MAX_READ_LIMIT, Math.floor(limit)));
+  return persisted;
+}
+async function readSessionLog(sessionId, persisted, limit) {
   const token = await bearerToken();
   const response = await axios.get(
     `${persistence.configuration.serverUrl}/v3/sessions/${encodeURIComponent(sessionId)}/messages`,
     {
-      params: { before_seq: 2147483647, limit: bounded },
+      params: { before_seq: 2147483647, limit },
       headers: {
         "Authorization": `Bearer ${token}`,
         "X-Happy-Client": `${SESSION_OPS_CLIENT}/${persistence.configuration.currentCliVersion}`
@@ -9847,21 +9968,62 @@ async function readSessionTranscript(sessionId, limit) {
   const messages = Array.isArray(response.data?.messages) ? response.data.messages : [];
   messages.reverse();
   const key = persistence.decodeBase64(persisted.encryptionKey);
-  const live = await index.listDaemonSessions();
-  const bodies = messages.map((message) => {
-    if (message.content?.t !== "encrypted") return null;
+  return messages.map((message) => {
+    if (message.content?.t !== "encrypted") return { seq: message.seq, body: null };
     try {
-      return persistence.decrypt(key, persisted.encryptionVariant, persistence.decodeBase64(message.content.c));
+      return { seq: message.seq, body: persistence.decrypt(key, persisted.encryptionVariant, persistence.decodeBase64(message.content.c)) };
     } catch {
-      return null;
+      return { seq: message.seq, body: null };
     }
   });
+}
+const TURN_WINDOW = 500;
+async function readSessionTranscript(sessionId, limit, options = {}) {
+  const persisted = requirePersisted(sessionId);
+  const bounded = Math.max(1, Math.min(MAX_READ_LIMIT, Math.floor(limit)));
+  const entries = await readSessionLog(sessionId, persisted, Math.max(bounded, TURN_WINDOW));
+  const shown = entries.slice(-bounded);
+  const live = await index.listDaemonSessions();
   return {
     summary: toSummary(sessionId, persisted, sessionLiveness(live, sessionId)),
-    messageCount: messages.length,
-    transcript: formatTranscript(bodies)
+    messageCount: shown.length,
+    transcript: formatTranscript(shown.map((entry) => entry.body), { full: options.full }),
+    turn: analyzeLatestTurn(entries)
   };
 }
+async function readSessionMetadata(sessionId, persisted) {
+  const token = await bearerToken();
+  const response = await axios.get(`${persistence.configuration.serverUrl}/v1/sessions/${encodeURIComponent(sessionId)}`, {
+    headers: {
+      "Authorization": `Bearer ${token}`,
+      "X-Happy-Client": `${SESSION_OPS_CLIENT}/${persistence.configuration.currentCliVersion}`
+    },
+    timeout: 15e3
+  });
+  const ciphertext = response.data?.session?.metadata;
+  if (typeof ciphertext !== "string" || ciphertext.length === 0) return null;
+  return persistence.decrypt(persistence.decodeBase64(persisted.encryptionKey), persisted.encryptionVariant, persistence.decodeBase64(ciphertext));
+}
+class TurnWaitTimeoutError extends Error {
+  constructor(sessionId, timeoutMs, turn) {
+    super(`Session ${sessionId}: the latest turn did not end within ${Math.round(timeoutMs / 1e3)}s`);
+    this.sessionId = sessionId;
+    this.timeoutMs = timeoutMs;
+    this.turn = turn;
+  }
+}
+async function waitForTurnEnd(sessionId, options) {
+  const persisted = requirePersisted(sessionId);
+  const pollMs = options.pollMs ?? 3e3;
+  const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const deadline = Date.now() + options.timeoutMs;
+  while (true) {
+    const turn = analyzeLatestTurn(await readSessionLog(sessionId, persisted, TURN_WINDOW));
+    if (turn.ended) return turn;
+    if (Date.now() + pollMs > deadline) throw new TurnWaitTimeoutError(sessionId, options.timeoutMs, turn);
+    await sleep(pollMs);
+  }
+}
 async function stopSession(sessionId) {
   return await index.stopDaemonSession(sessionId);
 }
@@ -9894,7 +10056,7 @@ function readReceipt(home, id) {
     throw error;
   }
 }
-function writeReceipt(home, receipt) {
+function writeReceipt$1(home, receipt) {
   persistence.ensurePrivateDirectorySync(path.join(home, "teams", "effects"));
   const target = receiptPath(home, receipt.operationId);
   const tmp = `${target}.${process.pid}.tmp`;
@@ -9971,7 +10133,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);
@@ -9988,7 +10150,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 {
@@ -10001,7 +10163,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");
@@ -10011,17 +10173,17 @@ function createTeamWorker(deps) {
           const scopeFile = path.join(scopes, `${op.id}.json`);
           persistence.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(persistence.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;
@@ -10036,14 +10198,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);
@@ -10173,6 +10335,643 @@ Use the teams tools to inspect current task state before acting. This message is
   } };
 }
 
+function resolveSpawnPermissionMode(agent, explicit) {
+  return explicit ?? persistence.getAgentCodeDefaults(agent ?? "claude").permissionMode;
+}
+function outboundPermissionMode(agent, mode) {
+  const key = persistence.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 (persistence.normalizeAgentKey(input.agent ?? "claude") !== "claude") return meta;
+  if (meta.model === void 0) {
+    const model = persistence.getAgentCodeDefaults("claude").modelMode;
+    const runnable = !persistence.isClaudeOpus55Model(model) || persistence.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 path.join(home, "automation-receipts.json");
+}
+function readReceipts(home) {
+  let raw;
+  try {
+    raw = node_fs.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);
+  persistence.ensurePrivateDirectorySync(path.dirname(target));
+  const tmp = `${target}.${process.pid}.tmp`;
+  persistence.writePrivateFileSync(tmp, JSON.stringify({ version: 1, receipts: kept }));
+  const file = node_fs.openSync(tmp, "r");
+  try {
+    node_fs.fsyncSync(file);
+  } finally {
+    node_fs.closeSync(file);
+  }
+  node_fs.renameSync(tmp, target);
+  if (process.platform !== "win32") {
+    const directory = node_fs.openSync(path.dirname(target), "r");
+    try {
+      node_fs.fsyncSync(directory);
+    } finally {
+      node_fs.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(persistence.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 = node_child_process.spawn(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 = persistence.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 = persistence.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$1) {
+  if (path$1 === "~") return os.homedir();
+  if (path$1.startsWith("~/")) return path.join(os.homedir(), path$1.slice(2));
+  return path$1;
+}
+function isSettledByServer(error) {
+  if (!(error instanceof agentGuidance.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 ?? persistence.configuration.happyHomeDir;
+  const client = deps.client ?? agentGuidance.createAutomationsClient({ serverUrl: deps.serverUrl ?? persistence.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, persistence.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, persistence.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 (!path.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 = persistence.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, persistence.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, persistence.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: persistence.AUTOMATION_DEFAULT_LEASE_MS, ...item.pendingRunning ? { status: "running", ...item.pendingRunning } : {} };
+        try {
+          const run = await client.report(item.runId, body);
+          item.pendingRunning = void 0;
+          if (persistence.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: persistence.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 (agentGuidance.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 agentGuidance.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;
 }
@@ -10333,6 +11132,7 @@ async function startDaemon() {
     const turnActivity = new index.TurnActivityTracker();
     const sessionIdToFinishedSession = /* @__PURE__ */ new Map();
     let teamWorker;
+    let automationRunner;
     const persisted = persistence.readPersistedSessions();
     const liveHappyProcesses = await findAllHappyProcesses();
     for (const [id, s] of Object.entries(persisted)) {
@@ -11187,6 +11987,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);
@@ -11206,6 +12007,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;
@@ -11444,7 +12246,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) {
@@ -11454,10 +12256,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;
             persistence.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();
@@ -11509,6 +12312,14 @@ async function startDaemon() {
       live: (id) => [...pidToTrackedSession.values()].some((s) => s.happySessionId === id && isPidAlive(s.pid)),
       log: (message) => persistence.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) => persistence.logger.debug(`[DAEMON RUN] ${message}`)
+    });
     void apiMachine.updateMachineMetadata((current) => ({
       ...current ?? initialMachineMetadata,
       teamsVersion: 1,
@@ -11517,6 +12328,7 @@ async function startDaemon() {
     const cleanupAndShutdown = async (source, errorMessage) => {
       persistence.logger.debug(`[DAEMON RUN] Starting proper cleanup (source: ${source}, errorMessage: ${errorMessage})...`);
       teamWorker?.stop();
+      automationRunner?.stop({ killScripts: true });
       if (restartOnStaleVersionAndHeartbeat) {
         clearInterval(restartOnStaleVersionAndHeartbeat);
         persistence.logger.debug("[DAEMON RUN] Health check interval cleared");
@@ -12021,6 +12833,7 @@ function createMcpServer(handlers, options, sessionId) {
     version: "1.0.0"
   });
   agentGuidance.registerTeamsTools(mcp, sessionId);
+  agentGuidance.registerAutomationTools(mcp);
   mcp.registerTool("change_title", {
     description: "Change the title of the current chat session",
     title: "Change Chat Title",
@@ -12215,7 +13028,7 @@ async function startHappyServer(client, options) {
             return;
           }
         }
-        const usage = index.ContextUsageSchema.parse({ ...JSON.parse(body), updatedAt: Date.now() });
+        const usage = persistence.ContextUsageSchema.parse({ ...JSON.parse(body), updatedAt: Date.now() });
         options.onContextUsage(usage);
         res.writeHead(204).end();
       } catch {
@@ -12263,6 +13076,7 @@ async function startHappyServer(client, options) {
       agentGuidance.PREVIEW_TOOL_NAME,
       agentGuidance.REPORT_PROGRESS_TOOL_NAME,
       ...agentGuidance.TEAM_TOOL_NAMES,
+      ...agentGuidance.AUTOMATION_TOOL_NAMES,
       ...options?.assistant && !process.env.VH_TEAM_SCOPE_FILE ? ASSISTANT_TOOL_NAMES : []
     ],
     stop: () => {
@@ -12599,7 +13413,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 Promise.resolve().then(function () { return require('./index-DvfCUuDK.cjs'); });
+    const { query } = await Promise.resolve().then(function () { return require('./index-CRaJ9k2p.cjs'); });
     return runSideQuestion(query, input);
   });
   const run = async (input, live) => {
@@ -12718,7 +13532,7 @@ const MAX_TITLE_CHARS = 60;
 const GENERATION_TIMEOUT_MS = 3e4;
 function resolveClaudeBinary() {
   try {
-    const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-K6mUS0jF.cjs', document.baseURI).href)));
+    const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-ZIW1jrYm.cjs', document.baseURI).href)));
     const utilsPath = path.resolve(path.join(projectPath.projectPath(), "scripts", "claude_version_utils.cjs"));
     const { getClaudeCliPath } = require$1(utilsPath);
     const path$1 = getClaudeCliPath();
@@ -14947,9 +15761,9 @@ function resolveLocalSignupBootstrap(configuredMode, configuredInviteCodes, gene
   };
 }
 
-const __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-K6mUS0jF.cjs', document.baseURI).href)));
+const __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-ZIW1jrYm.cjs', document.baseURI).href)));
 const __dirname$1 = path.dirname(__filename$1);
-const require_ = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-K6mUS0jF.cjs', document.baseURI).href)));
+const require_ = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-ZIW1jrYm.cjs', document.baseURI).href)));
 const PRISMA_QUERY_ENGINE_FILES = {
   "arm64-darwin": "libquery_engine-darwin-arm64.dylib.node",
   "x64-darwin": "libquery_engine-darwin.dylib.node",
@@ -15384,14 +16198,14 @@ function maybeEmitSubagentStart(subagent, opts, startedSubagents, activeSubagent
   if (!subagent || startedSubagents.has(subagent)) {
     return;
   }
-  envelopes.push(index.createEnvelope("agent", { t: "start" }, { ...opts, subagent }));
+  envelopes.push(persistence.createEnvelope("agent", { t: "start" }, { ...opts, subagent }));
   startedSubagents.add(subagent);
   activeSubagents.add(subagent);
 }
 function emitSubagentStops(opts, startedSubagents, activeSubagents) {
   const envelopes = [];
   for (const subagent of activeSubagents) {
-    envelopes.push(index.createEnvelope("agent", { t: "stop" }, { ...opts, subagent }));
+    envelopes.push(persistence.createEnvelope("agent", { t: "stop" }, { ...opts, subagent }));
   }
   activeSubagents.clear();
   startedSubagents.clear();
@@ -15487,7 +16301,7 @@ function turnStatus(turn) {
 function emitHistoricalToolCall(envelopes, turn, item, name, title, args, output) {
   const time = turnTimestampMs(turn);
   const opts = { turn: turn.id, time, codexItemId: item.id };
-  envelopes.push(index.createEnvelope("agent", {
+  envelopes.push(persistence.createEnvelope("agent", {
     t: "tool-call-start",
     call: item.id,
     name,
@@ -15499,7 +16313,7 @@ function emitHistoricalToolCall(envelopes, turn, item, name, title, args, output
     id: `${item.id}:start`
   }));
   if (output && output.trim().length > 0) {
-    envelopes.push(index.createEnvelope("agent", {
+    envelopes.push(persistence.createEnvelope("agent", {
       t: "text",
       text: output,
       thinking: true
@@ -15509,7 +16323,7 @@ function emitHistoricalToolCall(envelopes, turn, item, name, title, args, output
     }));
   }
   if ("status" in item && (item.status === "inProgress" || item.status === "running")) return;
-  envelopes.push(index.createEnvelope("agent", {
+  envelopes.push(persistence.createEnvelope("agent", {
     t: "tool-call-end",
     call: item.id
   }, {
@@ -15531,7 +16345,7 @@ function mapCodexCollaborationItem(item, opts = {}, source = "history") {
     agentsStates: item.agentsStates ?? {}
   };
   const startId = source === "live" ? `${item.id}:${item.status ?? "unknown"}:start` : `${item.id}:start`;
-  const envelopes = [index.createEnvelope("agent", {
+  const envelopes = [persistence.createEnvelope("agent", {
     t: "tool-call-start",
     call: item.id,
     name: "CodexCollaboration",
@@ -15540,7 +16354,7 @@ function mapCodexCollaborationItem(item, opts = {}, source = "history") {
     args
   }, { ...opts, id: startId })];
   if (item.status === "completed" || item.status === "failed" || item.status === "interrupted") {
-    envelopes.push(index.createEnvelope("agent", {
+    envelopes.push(persistence.createEnvelope("agent", {
       t: "tool-call-end",
       call: item.id,
       result: { text: JSON.stringify(args, null, 2), isError: item.status !== "completed" }
@@ -15553,7 +16367,7 @@ function mapCodexThreadToSessionEnvelopes(thread) {
   for (const turn of thread.turns ?? []) {
     const startedAt = turnTimestampMs(turn);
     const completedAt = completedTimestampMs(turn);
-    envelopes.push(index.createEnvelope("agent", { t: "turn-start" }, {
+    envelopes.push(persistence.createEnvelope("agent", { t: "turn-start" }, {
       id: `${turn.id}:start`,
       turn: turn.id,
       time: startedAt
@@ -15568,7 +16382,7 @@ function mapCodexThreadToSessionEnvelopes(thread) {
         case "userMessage": {
           const text = textFromInputItems(item.content);
           if (text) {
-            envelopes.push(index.createEnvelope("user", { t: "text", text }, {
+            envelopes.push(persistence.createEnvelope("user", { t: "text", text }, {
               id: item.id,
               time: startedAt,
               codexItemId: item.id
@@ -15579,7 +16393,7 @@ function mapCodexThreadToSessionEnvelopes(thread) {
         case "agentMessage": {
           const text = typeof item.text === "string" ? item.text.trim() : "";
           if (text.length > 0) {
-            envelopes.push(index.createEnvelope("agent", { t: "text", text }, {
+            envelopes.push(persistence.createEnvelope("agent", { t: "text", text }, {
               id: item.id,
               turn: turn.id,
               time: completedAt,
@@ -15591,7 +16405,7 @@ function mapCodexThreadToSessionEnvelopes(thread) {
         case "reasoning": {
           const text = reasoningText(item);
           if (text) {
-            envelopes.push(index.createEnvelope("agent", { t: "text", text, thinking: true }, {
+            envelopes.push(persistence.createEnvelope("agent", { t: "text", text, thinking: true }, {
               id: item.id,
               turn: turn.id,
               time: startedAt,
@@ -15646,7 +16460,7 @@ function mapCodexThreadToSessionEnvelopes(thread) {
         }
       }
     }
-    envelopes.push(index.createEnvelope("agent", { t: "turn-end", status: turnStatus(turn) }, {
+    envelopes.push(persistence.createEnvelope("agent", { t: "turn-end", status: turnStatus(turn) }, {
       id: `${turn.id}:end`,
       turn: turn.id,
       time: completedAt
@@ -15701,7 +16515,7 @@ function mapCodexMcpMessageToSessionEnvelopes(message, state) {
   }
   if (type === "task_started") {
     const turnId = cuid2.createId();
-    const turnStart = index.createEnvelope("agent", { t: "turn-start" }, { turn: turnId });
+    const turnStart = persistence.createEnvelope("agent", { t: "turn-start" }, { turn: turnId });
     startedSubagents.clear();
     activeSubagents.clear();
     providerSubagentToSessionSubagent.clear();
@@ -15732,7 +16546,7 @@ function mapCodexMcpMessageToSessionEnvelopes(message, state) {
       providerSubagentToSessionSubagent,
       envelopes: [
         ...emitSubagentStops(lifecycleOpts, startedSubagents, activeSubagents),
-        index.createEnvelope("agent", {
+        persistence.createEnvelope("agent", {
           t: "turn-end",
           status: pickTurnEndStatus(message, type)
         }, lifecycleOpts)
@@ -15762,7 +16576,7 @@ function mapCodexMcpMessageToSessionEnvelopes(message, state) {
     }
     const envelopes = [];
     maybeEmitSubagentStart(subagent, opts, startedSubagents, activeSubagents, envelopes);
-    envelopes.push(index.createEnvelope("agent", { t: "text", text: message.message }, opts));
+    envelopes.push(persistence.createEnvelope("agent", { t: "text", text: message.message }, opts));
     return {
       currentTurnId: state.currentTurnId,
       startedSubagents,
@@ -15784,7 +16598,7 @@ function mapCodexMcpMessageToSessionEnvelopes(message, state) {
     }
     const envelopes = [];
     maybeEmitSubagentStart(subagent, opts, startedSubagents, activeSubagents, envelopes);
-    envelopes.push(index.createEnvelope("agent", { t: "text", text, thinking: true }, opts));
+    envelopes.push(persistence.createEnvelope("agent", { t: "text", text, thinking: true }, opts));
     return {
       currentTurnId: state.currentTurnId,
       startedSubagents,
@@ -15801,7 +16615,7 @@ function mapCodexMcpMessageToSessionEnvelopes(message, state) {
     const envelopes = [];
     maybeEmitSubagentStart(subagent, opts, startedSubagents, activeSubagents, envelopes);
     envelopes.push(
-      index.createEnvelope("agent", {
+      persistence.createEnvelope("agent", {
         t: "tool-call-start",
         call,
         name: "CodexBash",
@@ -15822,7 +16636,7 @@ function mapCodexMcpMessageToSessionEnvelopes(message, state) {
     const call = pickCallId(message);
     const envelopes = [];
     maybeEmitSubagentStart(subagent, opts, startedSubagents, activeSubagents, envelopes);
-    envelopes.push(index.createEnvelope("agent", { t: "tool-call-end", call }, opts));
+    envelopes.push(persistence.createEnvelope("agent", { t: "tool-call-end", call }, opts));
     return {
       currentTurnId: state.currentTurnId,
       startedSubagents,
@@ -15838,7 +16652,7 @@ function mapCodexMcpMessageToSessionEnvelopes(message, state) {
     const envelopes = [];
     maybeEmitSubagentStart(subagent, opts, startedSubagents, activeSubagents, envelopes);
     envelopes.push(
-      index.createEnvelope("agent", {
+      persistence.createEnvelope("agent", {
         t: "tool-call-start",
         call,
         name: "CodexPatch",
@@ -15862,7 +16676,7 @@ function mapCodexMcpMessageToSessionEnvelopes(message, state) {
     const call = pickCallId(message);
     const envelopes = [];
     maybeEmitSubagentStart(subagent, opts, startedSubagents, activeSubagents, envelopes);
-    envelopes.push(index.createEnvelope("agent", { t: "tool-call-end", call }, opts));
+    envelopes.push(persistence.createEnvelope("agent", { t: "tool-call-end", call }, opts));
     return {
       currentTurnId: state.currentTurnId,
       startedSubagents,
@@ -15883,7 +16697,7 @@ function mapCodexProcessorMessageToSessionEnvelopes(message, state) {
   const toolLikeMessage = message;
   const opts = buildEnvelopeOptions(state.currentTurnId);
   if (message.type === "reasoning") {
-    return [index.createEnvelope("agent", {
+    return [persistence.createEnvelope("agent", {
       t: "text",
       text: message.message,
       thinking: true
@@ -15891,7 +16705,7 @@ function mapCodexProcessorMessageToSessionEnvelopes(message, state) {
   }
   if (message.type === "tool-call") {
     const title = typeof toolLikeMessage.input?.title === "string" ? toolLikeMessage.input.title : `${toolLikeMessage.name || "Tool"} call`;
-    return [index.createEnvelope("agent", {
+    return [persistence.createEnvelope("agent", {
       t: "tool-call-start",
       call: toolLikeMessage.callId,
       name: toolLikeMessage.name || "unknown",
@@ -15904,13 +16718,13 @@ function mapCodexProcessorMessageToSessionEnvelopes(message, state) {
     const envelopes = [];
     const content = toolLikeMessage.output?.content;
     if (typeof content === "string" && content.trim().length > 0) {
-      envelopes.push(index.createEnvelope("agent", {
+      envelopes.push(persistence.createEnvelope("agent", {
         t: "text",
         text: content,
         thinking: true
       }, opts));
     }
-    envelopes.push(index.createEnvelope("agent", {
+    envelopes.push(persistence.createEnvelope("agent", {
       t: "tool-call-end",
       call: toolLikeMessage.callId
     }, opts));
@@ -16906,7 +17720,7 @@ function buildCodexTurnPrompt(opts) {
   parts.push(opts.message);
   if (opts.includeTitleInstruction) {
     parts.push(CHANGE_TITLE_INSTRUCTION);
-    parts.push(index.BUILTIN_TODO_DISCOVERY);
+    parts.push(persistence.BUILTIN_TODO_DISCOVERY);
   }
   return parts.join("\n\n");
 }
@@ -17887,7 +18701,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 Promise.resolve().then(function () { return require('./installTerminalHooks-NIbsQ1wi.cjs'); });
+      const { installTerminalHooks, parseTerminalHooksArgs, TERMINAL_HOOKS_HELP } = await Promise.resolve().then(function () { return require('./installTerminalHooks-BoDxpaBO.cjs'); });
       const command = parseTerminalHooksArgs(args.slice(1));
       if (command.action === "help") {
         console.log(TERMINAL_HOOKS_HELP);
@@ -17904,7 +18718,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 Promise.resolve().then(function () { return require('./agentHome-rylNIkix.cjs'); });
+      const { parseAgentHomeArgs, runAgentHomeCommand } = await Promise.resolve().then(function () { return require('./agentHome-CpJjrQZc.cjs'); });
       await runAgentHomeCommand(parseAgentHomeArgs(args.slice(1)));
       process.exit(0);
     } catch (error) {
@@ -17913,7 +18727,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     }
   } else if (subcommand === "spawn") {
     try {
-      const { handleSpawnCommand } = await Promise.resolve().then(function () { return require('./spawn-DqzG1bTH.cjs'); });
+      const { handleSpawnCommand } = await Promise.resolve().then(function () { return require('./spawn-DA8WAFmm.cjs'); });
       await handleSpawnCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -17925,7 +18739,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "sessions") {
     try {
-      const { handleSessionsCommand } = await Promise.resolve().then(function () { return require('./sessions-CpIdDhH7.cjs'); });
+      const { handleSessionsCommand } = await Promise.resolve().then(function () { return require('./sessions-Tad8elmy.cjs'); });
       await handleSessionsCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -17937,7 +18751,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "send") {
     try {
-      const { handleSendCommand } = await Promise.resolve().then(function () { return require('./send-qXWGilm8.cjs'); });
+      const { handleSendCommand } = await Promise.resolve().then(function () { return require('./send-wl9ei8yG.cjs'); });
       await handleSendCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -18043,9 +18857,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 Promise.resolve().then(function () { return require('./config-CgPu2wtS.cjs'); });
-        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await Promise.resolve().then(function () { return require('./limits-Dyma1REp.cjs'); }).then(function (n) { return n.persistence; });
-        const { ApiClient: ApiClient2 } = await Promise.resolve().then(function () { return require('./types-D2Gkpe0N.cjs'); }).then(function (n) { return n.api; });
+        const { saveGoogleCloudProjectToConfig } = await Promise.resolve().then(function () { return require('./config-DeJgSMh-.cjs'); });
+        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await Promise.resolve().then(function () { return require('./limits-BNTWyUaZ.cjs'); }).then(function (n) { return n.persistence; });
+        const { ApiClient: ApiClient2 } = await Promise.resolve().then(function () { return require('./types-CN28qJl7.cjs'); }).then(function (n) { return n.api; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentialsForConfiguredRelay2();
@@ -18076,7 +18890,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 Promise.resolve().then(function () { return require('./config-CgPu2wtS.cjs'); });
+        const { readGeminiLocalConfig } = await Promise.resolve().then(function () { return require('./config-DeJgSMh-.cjs'); });
         const config = readGeminiLocalConfig();
         if (config.googleCloudProject) {
           console.log(`Current Google Cloud Project: ${config.googleCloudProject}`);
@@ -18116,7 +18930,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
       process.exit(0);
     }
     try {
-      const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini-BMYCU16c.cjs'); });
+      const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini-Bgg1BzDK.cjs'); });
       let startedBy = void 0;
       for (let i = 1; i < args.length; i++) {
         if (args[i] === "--started-by") {
@@ -18139,7 +18953,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 Promise.resolve().then(function () { return require('./piTerminal-DHxGB3Ic.cjs'); });
+        const { runPiTerminal } = await Promise.resolve().then(function () { return require('./piTerminal-B7K75aXB.cjs'); });
         process.exitCode = await runPiTerminal(args.slice(2));
       } catch (error) {
         console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -18156,7 +18970,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
       }
     };
     try {
-      const { runAcp, resolveAcpAgentConfig } = await Promise.resolve().then(function () { return require('./index-DEVkDRas.cjs'); });
+      const { runAcp, resolveAcpAgentConfig } = await Promise.resolve().then(function () { return require('./index-imt4mC41.cjs'); });
       const parsed = parsePiRunnerArgs(args.slice(1));
       const resolved = resolveAcpAgentConfig(["pi", ...parsed.passthrough]);
       const { credentials } = await authAndSetupMachineIfNeeded();
@@ -18184,7 +18998,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 Promise.resolve().then(function () { return require('./index-DEVkDRas.cjs'); });
+      const { runAcp, resolveAcpAgentConfig } = await Promise.resolve().then(function () { return require('./index-imt4mC41.cjs'); });
       let startedBy = void 0;
       let verbose = false;
       const acpArgs = [];
@@ -18224,7 +19038,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "openclaw") {
     try {
-      const { runOpenClaw } = await Promise.resolve().then(function () { return require('./runOpenClaw-Qs4eFtcS.cjs'); });
+      const { runOpenClaw } = await Promise.resolve().then(function () { return require('./runOpenClaw-B9qWHybc.cjs'); });
       let startedBy = void 0;
       let verbose = false;
       let gatewayUrl;
@@ -18275,7 +19089,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "todo") {
     try {
-      const { handleTodoCommand } = await Promise.resolve().then(function () { return require('./todo-D7SDXL0c.cjs'); });
+      const { handleTodoCommand } = await Promise.resolve().then(function () { return require('./todo-mCMoGjJk.cjs'); });
       await handleTodoCommand(args.slice(1));
     } catch (error) {
       console.error(JSON.stringify({ error: error instanceof Error ? error.message : "Todo command failed" }));
@@ -18284,16 +19098,28 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "teams") {
     try {
-      const { handleTeamsCommand } = await Promise.resolve().then(function () { return require('./teams-ByEgUzsH.cjs'); });
+      const { handleTeamsCommand } = await Promise.resolve().then(function () { return require('./teams-qVLrFcdd.cjs'); });
       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 Promise.resolve().then(function () { return require('./auto-DncmTDvw.cjs'); });
+      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 Promise.resolve().then(function () { return require('./mcp-_TVUSg8W.cjs'); });
+      const { handleMcpCommand } = await Promise.resolve().then(function () { return require('./mcp-CCKCKL6l.cjs'); });
       await handleMcpCommand(args[1] === "--terminal-tools");
     } catch (error) {
       process.stderr.write(`[very-happy mcp] Fatal: ${error instanceof Error ? error.message : String(error)}
@@ -18527,6 +19353,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
@@ -18679,23 +19507,30 @@ exports.SPAWN_AGENTS = SPAWN_AGENTS;
 exports.StreamRelay = StreamRelay;
 exports.TEAM_SKILL = TEAM_SKILL;
 exports.TitleGenerator = TitleGenerator;
+exports.TurnWaitTimeoutError = TurnWaitTimeoutError;
 exports.appendStagedAttachmentsToPrompt = appendStagedAttachmentsToPrompt;
 exports.archiveSession = archiveSession;
 exports.checkPreviewPath = checkPreviewPath;
 exports.createSessionMetadata = createSessionMetadata;
+exports.describeAction = describeAction;
+exports.describeTrigger = describeTrigger;
 exports.hashObject = hashObject;
 exports.initialMachineMetadata = initialMachineMetadata;
 exports.isValidSpawnOrigin = isValidSpawnOrigin;
 exports.listAccountSessions = listAccountSessions;
 exports.listSessions = listSessions;
 exports.normalizeAcpPermissionMode = normalizeAcpPermissionMode;
+exports.parseDuration = parseDuration;
 exports.query = query;
+exports.readSessionMetadata = readSessionMetadata;
 exports.readSessionTranscript = readSessionTranscript;
 exports.registerAgentAttachmentDownloads = registerAgentAttachmentDownloads;
 exports.registerAssistantSessionTools = registerAssistantSessionTools;
 exports.registerKillSessionHandler = registerKillSessionHandler;
 exports.removeSessionModeFile = removeSessionModeFile;
+exports.resolveFirstMessageMeta = resolveFirstMessageMeta;
 exports.resolvePermissionRequest = resolvePermissionRequest;
+exports.resolveSpawnPermissionMode = resolveSpawnPermissionMode;
 exports.sanitizeSpawnPermissionMode = sanitizeSpawnPermissionMode;
 exports.sendUserMessage = sendUserMessage;
 exports.sessionWebUrl = sessionWebUrl;
@@ -18704,5 +19539,7 @@ exports.stageClaudeAttachments = stageClaudeAttachments;
 exports.startHappyServer = startHappyServer;
 exports.stopSession = stopSession;
 exports.tmuxSupportsSessionEnv = tmuxSupportsSessionEnv;
+exports.triggerFromFlags = triggerFromFlags;
 exports.waitForSessionKey = waitForSessionKey;
+exports.waitForTurnEnd = waitForTurnEnd;
 exports.writeSessionModeFile = writeSessionModeFile;