very-happy-cli 0.2.151 → 0.2.153

package/dist/{index-CqtfRzug.cjs → index-DHrwHxHf.cjs}

@@ -3,14 +3,14 @@
 var chalk = require('chalk');
 var os = require('node:os');
 var node_crypto = require('node:crypto');
-var index = require('./types-CPubg05Z.cjs');
-var persistence = require('./limits-DwcY3kyi.cjs');
+var index = require('./types-CUCU7Vw8.cjs');
+var persistence = require('./limits-DY_sFA3J.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-BXa9ikrZ.cjs');
+var terminalTitleSuggest = require('./terminalTitleSuggest-Dji8I0Jy.cjs');
+var agentGuidance = require('./agentGuidance-BM4kMNyr.cjs');
 var promises = require('node:fs/promises');
 var fs = require('fs/promises');
 var ink = require('ink');
@@ -492,7 +492,7 @@ function shouldIncludeCoAuthoredBy() {
 
 const BASE_SYSTEM_PROMPT = (() => agentGuidance.trimIdent(`
     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" + index.BUILTIN_TODO_DISCOVERY;
+`))() + "\n\n" + agentGuidance.AGENT_GUIDANCE + "\n\n" + persistence.BUILTIN_TODO_DISCOVERY;
 const CO_AUTHORED_CREDITS = (() => agentGuidance.trimIdent(`
     When you yourself create a git commit, instead of just giving co-credit to Claude, also give credit to Happy like so:
 
@@ -522,7 +522,7 @@ class ExitCodeError extends Error {
     this.exitCode = exitCode;
   }
 }
-const claudeCliPath = path.resolve(path.join(projectPath.projectPath(), "scripts", "claude_local_launcher.cjs"));
+const claudeCliPath = path.resolve(path.join(terminalTitleSuggest.projectPath(), "scripts", "claude_local_launcher.cjs"));
 function quoteShellArg(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -3507,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;
     }
@@ -4878,8 +4878,8 @@ function createSessionMetadata(opts) {
     ...opts.teamOperationId ? { teamOperationId: opts.teamOperationId } : {},
     homeDir: os.homedir(),
     happyHomeDir: persistence.configuration.happyHomeDir,
-    happyLibDir: projectPath.projectPath(),
-    happyToolsDir: path.resolve(projectPath.projectPath(), "tools", "unpacked"),
+    happyLibDir: terminalTitleSuggest.projectPath(),
+    happyToolsDir: path.resolve(terminalTitleSuggest.projectPath(), "tools", "unpacked"),
     startedFromDaemon: opts.startedBy === "daemon",
     hostPid: process.pid,
     startedBy: opts.startedBy || "terminal",
@@ -5206,7 +5206,7 @@ function printCliUpdateStatus(state) {
     console.log(chalk.yellow("  \u25B3 A newer CLI is available."));
   }
   if (summary.installCommand) console.log(`  Update: ${summary.installCommand}`);
-  const facts = gatherInstallLocationFacts(projectPath.projectPath());
+  const facts = gatherInstallLocationFacts(terminalTitleSuggest.projectPath());
   for (const warning of facts ? installLocationWarnings(facts, state?.cliUpdate?.recommendedVersion ?? void 0) : []) {
     console.log(chalk.yellow(`  \u26A0 ${warning}`));
   }
@@ -5338,7 +5338,7 @@ ${typeLabels[type] || type}:`));
     console.log(chalk.yellow("No log files found"));
   }
   console.log(chalk.bold("\n\u{1F527} Daemon Spawn Diagnostics"));
-  const projectRoot = projectPath.projectPath();
+  const projectRoot = terminalTitleSuggest.projectPath();
   const wrapperPath = path.join(projectRoot, "bin", "very-happy.mjs");
   const cliEntrypoint = path.join(projectRoot, "dist", "index.mjs");
   console.log(`Project Root: ${chalk.blue(projectRoot)}`);
@@ -5402,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-D6MSfwnp.cjs'); });
-    const { describeAgentHome } = await Promise.resolve().then(function () { return require('./types-CPubg05Z.cjs'); }).then(function (n) { return n.index; });
+    const { resolveAgentHomesForCli } = await Promise.resolve().then(function () { return require('./agentHome-BJ7bde35.cjs'); });
+    const { describeAgentHome } = await Promise.resolve().then(function () { return require('./types-CUCU7Vw8.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)}`));
@@ -5514,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);
@@ -5953,7 +5953,7 @@ function getRuntime() {
 const isBun = () => getRuntime() === "bun";
 
 function spawnHappyCLI(args, options = {}) {
-  const projectRoot = projectPath.projectPath();
+  const projectRoot = terminalTitleSuggest.projectPath();
   const entrypoint = path.join(projectRoot, "dist", "index.mjs");
   let directory;
   if ("cwd" in options) {
@@ -6230,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));
@@ -6253,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))) {
@@ -7784,7 +7784,7 @@ const defaults = {
   npm: runNpm,
   fs: { lstat: promises.lstat, readlink: promises.readlink, unlink: promises.unlink, rm: promises.rm, readFile: promises.readFile, symlink: promises.symlink, access: promises.access },
   platform: process.platform,
-  runningPackageDir: projectPath.projectPath()
+  runningPackageDir: terminalTitleSuggest.projectPath()
 };
 async function runningVersion(deps) {
   if (!deps.runningPackageDir) return null;
@@ -8144,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-CqtfRzug.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-DHrwHxHf.cjs', document.baseURI).href))).resolve(s)) {
   const platformArch = `${platform}-${arch}`;
   const candidates = [
     `@anthropic-ai/claude-agent-sdk-${platformArch}/claude`,
@@ -8857,8 +8857,8 @@ function createMirrorManager(deps) {
       machineId: deps.machineId,
       homeDir: os.homedir(),
       happyHomeDir: persistence.configuration.happyHomeDir,
-      happyLibDir: projectPath.projectPath(),
-      happyToolsDir: path.resolve(projectPath.projectPath(), "tools", "unpacked"),
+      happyLibDir: terminalTitleSuggest.projectPath(),
+      happyToolsDir: path.resolve(terminalTitleSuggest.projectPath(), "tools", "unpacked"),
       startedBy: "terminal",
       lifecycleState: "running",
       lifecycleStateSince: Date.now(),
@@ -9380,6 +9380,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,
@@ -9539,11 +9553,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;
     }
@@ -9557,6 +9574,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";
@@ -10049,7 +10070,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`;
@@ -10126,7 +10147,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);
@@ -10143,7 +10164,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 {
@@ -10156,7 +10177,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");
@@ -10166,17 +10187,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;
@@ -10191,14 +10212,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);
@@ -10328,6 +10349,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;
 }
@@ -10349,7 +11007,7 @@ const initialMachineMetadata = {
   happyCliVersion: persistence.packageJson.version,
   homeDir: os$1.homedir(),
   happyHomeDir: persistence.configuration.happyHomeDir,
-  happyLibDir: projectPath.projectPath(),
+  happyLibDir: terminalTitleSuggest.projectPath(),
   cliAvailability: startupCliAvailability,
   resumeSupport: { ...index.detectResumeSupport(), rpcAvailable: true }
 };
@@ -10488,6 +11146,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)) {
@@ -10806,7 +11465,7 @@ async function startDaemon() {
           const sessionDesc = tmuxSessionName || "current/most recent session";
           persistence.logger.debug(`[DAEMON RUN] Attempting to spawn session in tmux: ${sessionDesc}`);
           const tmux = getTmuxUtilities(tmuxSessionName);
-          const cliPath = path$1.join(projectPath.projectPath(), "dist", "index.mjs");
+          const cliPath = path$1.join(terminalTitleSuggest.projectPath(), "dist", "index.mjs");
           const agent = options.agent ?? "claude";
           if (!isSpawnAgent(agent)) {
             return {
@@ -11342,6 +12001,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);
@@ -11361,6 +12021,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;
@@ -11457,7 +12118,7 @@ async function startDaemon() {
     };
     persistence.writeDaemonState(fileState);
     persistence.logger.debug("[DAEMON RUN] Daemon state written");
-    const bundlePath = path$1.join(projectPath.projectPath(), "dist", "index.mjs");
+    const bundlePath = path$1.join(terminalTitleSuggest.projectPath(), "dist", "index.mjs");
     let initialBundleMtimeMs = 0;
     try {
       initialBundleMtimeMs = fs$1.statSync(bundlePath).mtimeMs;
@@ -11513,7 +12174,7 @@ async function startDaemon() {
     });
     const claudeAuthService = new ClaudeAuthService({
       happyHomeDir: persistence.configuration.happyHomeDir,
-      happyLibDir: projectPath.projectPath(),
+      happyLibDir: terminalTitleSuggest.projectPath(),
       credentialSource: daemonClaudeCredentials.source,
       getCredentialStore: () => claudeCredentialStoreSetting,
       setCredentialStore: async (store) => {
@@ -11599,7 +12260,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) {
@@ -11609,10 +12270,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();
@@ -11664,6 +12326,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,
@@ -11672,6 +12342,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");
@@ -12176,6 +12847,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",
@@ -12370,7 +13042,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 {
@@ -12418,6 +13090,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: () => {
@@ -12517,7 +13190,7 @@ function generateHookSettingsFile(port) {
   node_fs.mkdirSync(hooksDir, { recursive: true });
   const filename = `session-hook-${process.pid}.json`;
   const filepath = path.join(hooksDir, filename);
-  const forwarderScript = path.resolve(projectPath.projectPath(), "scripts", "session_hook_forwarder.cjs");
+  const forwarderScript = path.resolve(terminalTitleSuggest.projectPath(), "scripts", "session_hook_forwarder.cjs");
   const hookCommand = `node "${forwarderScript}" ${port}`;
   const settings = {
     hooks: {
@@ -12754,7 +13427,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-vyRqLjDv.cjs'); });
+    const { query } = await Promise.resolve().then(function () { return require('./index-D49WvbDT.cjs'); });
     return runSideQuestion(query, input);
   });
   const run = async (input, live) => {
@@ -12873,8 +13546,8 @@ 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-CqtfRzug.cjs', document.baseURI).href)));
-    const utilsPath = path.resolve(path.join(projectPath.projectPath(), "scripts", "claude_version_utils.cjs"));
+    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-DHrwHxHf.cjs', document.baseURI).href)));
+    const utilsPath = path.resolve(path.join(terminalTitleSuggest.projectPath(), "scripts", "claude_version_utils.cjs"));
     const { getClaudeCliPath } = require$1(utilsPath);
     const path$1 = getClaudeCliPath();
     if (typeof path$1 === "string" && path$1.length > 0) return path$1;
@@ -12931,7 +13604,12 @@ function runClaudeOneShot(binary, prompt) {
     try {
       child = node_child_process.spawn(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) {
       persistence.logger.debug("[titleGenerator] spawn failed", { error: String(error) });
@@ -12966,6 +13644,18 @@ function runClaudeOneShot(binary, prompt) {
     });
   });
 }
+async function suggestTitleForPrompt(prompt) {
+  const binary = resolveClaudeBinary();
+  if (!binary) {
+    persistence.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) persistence.logger.debug("[titleGenerator] empty/unusable title output; skipping");
+  return title;
+}
 class TitleGenerator {
   constructor(session) {
     this.session = session;
@@ -12989,23 +13679,12 @@ class TitleGenerator {
     });
   }
   async generate(firstUserMessage) {
-    const binary = resolveClaudeBinary();
-    if (!binary) {
-      persistence.logger.debug("[titleGenerator] no claude binary; skipping auto-title");
-      return;
-    }
     if (this.session.getMetadata()?.summary?.text) {
       persistence.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) {
-      persistence.logger.debug("[titleGenerator] empty/unusable title output; skipping");
-      return;
-    }
+    const title = await suggestTitleForPrompt(firstUserMessage);
+    if (!title) return;
     if (this.session.getMetadata()?.summary?.text) {
       persistence.logger.debug("[titleGenerator] summary set during generation; not overwriting");
       return;
@@ -13320,8 +13999,8 @@ async function runClaude(credentials, options = {}) {
     machineId,
     homeDir: os.homedir(),
     happyHomeDir: persistence.configuration.happyHomeDir,
-    happyLibDir: projectPath.projectPath(),
-    happyToolsDir: path.resolve(projectPath.projectPath(), "tools", "unpacked"),
+    happyLibDir: terminalTitleSuggest.projectPath(),
+    happyToolsDir: path.resolve(terminalTitleSuggest.projectPath(), "tools", "unpacked"),
     startedFromDaemon: options.startedBy === "daemon",
     hostPid: process.pid,
     startedBy: options.startedBy || "terminal",
@@ -15102,9 +15781,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-CqtfRzug.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-DHrwHxHf.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-CqtfRzug.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-DHrwHxHf.cjs', document.baseURI).href)));
 const PRISMA_QUERY_ENGINE_FILES = {
   "arm64-darwin": "libquery_engine-darwin-arm64.dylib.node",
   "x64-darwin": "libquery_engine-darwin.dylib.node",
@@ -15539,14 +16218,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();
@@ -15642,7 +16321,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,
@@ -15654,7 +16333,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
@@ -15664,7 +16343,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
   }, {
@@ -15686,7 +16365,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",
@@ -15695,7 +16374,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" }
@@ -15708,7 +16387,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
@@ -15723,7 +16402,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
@@ -15734,7 +16413,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,
@@ -15746,7 +16425,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,
@@ -15801,7 +16480,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
@@ -15856,7 +16535,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();
@@ -15887,7 +16566,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)
@@ -15917,7 +16596,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,
@@ -15939,7 +16618,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,
@@ -15956,7 +16635,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",
@@ -15977,7 +16656,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,
@@ -15993,7 +16672,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",
@@ -16017,7 +16696,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,
@@ -16038,7 +16717,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
@@ -16046,7 +16725,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",
@@ -16059,13 +16738,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));
@@ -17061,7 +17740,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");
 }
@@ -17620,7 +18299,7 @@ async function runCodex(opts) {
     }
   });
   const happyServer = await startHappyServer(session);
-  const bridgeEntrypoint = path.join(projectPath.projectPath(), "bin", "very-happy-mcp.mjs");
+  const bridgeEntrypoint = path.join(terminalTitleSuggest.projectPath(), "bin", "very-happy-mcp.mjs");
   const mcpServers = {
     happy: {
       command: process.execPath,
@@ -18033,7 +18712,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 Promise.resolve().then(function () { return require('./installPiTools-BKnXjrVu.cjs'); });
+      const { handleInstallPiTools } = await Promise.resolve().then(function () { return require('./installPiTools-DuZ6jZvX.cjs'); });
       await handleInstallPiTools(args.slice(1));
     } catch (error) {
       console.error(error instanceof Error ? error.message : "Pi tools installation failed");
@@ -18042,7 +18721,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-Bf_adbl3.cjs'); });
+      const { installTerminalHooks, parseTerminalHooksArgs, TERMINAL_HOOKS_HELP } = await Promise.resolve().then(function () { return require('./installTerminalHooks-BF0kL0ae.cjs'); });
       const command = parseTerminalHooksArgs(args.slice(1));
       if (command.action === "help") {
         console.log(TERMINAL_HOOKS_HELP);
@@ -18059,7 +18738,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-D6MSfwnp.cjs'); });
+      const { parseAgentHomeArgs, runAgentHomeCommand } = await Promise.resolve().then(function () { return require('./agentHome-BJ7bde35.cjs'); });
       await runAgentHomeCommand(parseAgentHomeArgs(args.slice(1)));
       process.exit(0);
     } catch (error) {
@@ -18068,7 +18747,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-DH6_p4-f.cjs'); });
+      const { handleSpawnCommand } = await Promise.resolve().then(function () { return require('./spawn-od9V23cc.cjs'); });
       await handleSpawnCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -18080,7 +18759,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-B3vP18kz.cjs'); });
+      const { handleSessionsCommand } = await Promise.resolve().then(function () { return require('./sessions-qULzUzlI.cjs'); });
       await handleSessionsCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -18092,7 +18771,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-aUkjhey7.cjs'); });
+      const { handleSendCommand } = await Promise.resolve().then(function () { return require('./send-9075kHZP.cjs'); });
       await handleSendCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -18198,9 +18877,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-Cadw1sAk.cjs'); });
-        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await Promise.resolve().then(function () { return require('./limits-DwcY3kyi.cjs'); }).then(function (n) { return n.persistence; });
-        const { ApiClient: ApiClient2 } = await Promise.resolve().then(function () { return require('./types-CPubg05Z.cjs'); }).then(function (n) { return n.api; });
+        const { saveGoogleCloudProjectToConfig } = await Promise.resolve().then(function () { return require('./config-D23kF0_u.cjs'); });
+        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await Promise.resolve().then(function () { return require('./limits-DY_sFA3J.cjs'); }).then(function (n) { return n.persistence; });
+        const { ApiClient: ApiClient2 } = await Promise.resolve().then(function () { return require('./types-CUCU7Vw8.cjs'); }).then(function (n) { return n.api; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentialsForConfiguredRelay2();
@@ -18231,7 +18910,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-Cadw1sAk.cjs'); });
+        const { readGeminiLocalConfig } = await Promise.resolve().then(function () { return require('./config-D23kF0_u.cjs'); });
         const config = readGeminiLocalConfig();
         if (config.googleCloudProject) {
           console.log(`Current Google Cloud Project: ${config.googleCloudProject}`);
@@ -18271,7 +18950,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-DuwdVV1O.cjs'); });
+      const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini-CtOEFvhf.cjs'); });
       let startedBy = void 0;
       for (let i = 1; i < args.length; i++) {
         if (args[i] === "--started-by") {
@@ -18294,7 +18973,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-kDSd_r9X.cjs'); });
+        const { runPiTerminal } = await Promise.resolve().then(function () { return require('./piTerminal-qdJ9KZVL.cjs'); });
         process.exitCode = await runPiTerminal(args.slice(2));
       } catch (error) {
         console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -18311,7 +18990,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-BKGspSWk.cjs'); });
+      const { runAcp, resolveAcpAgentConfig } = await Promise.resolve().then(function () { return require('./index-DEOVn46R.cjs'); });
       const parsed = parsePiRunnerArgs(args.slice(1));
       const resolved = resolveAcpAgentConfig(["pi", ...parsed.passthrough]);
       const { credentials } = await authAndSetupMachineIfNeeded();
@@ -18339,7 +19018,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-BKGspSWk.cjs'); });
+      const { runAcp, resolveAcpAgentConfig } = await Promise.resolve().then(function () { return require('./index-DEOVn46R.cjs'); });
       let startedBy = void 0;
       let verbose = false;
       const acpArgs = [];
@@ -18379,7 +19058,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-BsvtCE_H.cjs'); });
+      const { runOpenClaw } = await Promise.resolve().then(function () { return require('./runOpenClaw-DoqZXBvL.cjs'); });
       let startedBy = void 0;
       let verbose = false;
       let gatewayUrl;
@@ -18430,7 +19109,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-Bcc2XxGh.cjs'); });
+      const { handleTodoCommand } = await Promise.resolve().then(function () { return require('./todo-BCT_ZPuV.cjs'); });
       await handleTodoCommand(args.slice(1));
     } catch (error) {
       console.error(JSON.stringify({ error: error instanceof Error ? error.message : "Todo command failed" }));
@@ -18439,16 +19118,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-BW8D1n3o.cjs'); });
+      const { handleTeamsCommand } = await Promise.resolve().then(function () { return require('./teams-CrCzU-AV.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-C-90ojIH.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-CMxEZ6-0.cjs'); });
+      const { handleMcpCommand } = await Promise.resolve().then(function () { return require('./mcp-JpqI2POW.cjs'); });
       await handleMcpCommand(args[1] === "--terminal-tools");
     } catch (error) {
       process.stderr.write(`[very-happy mcp] Fatal: ${error instanceof Error ? error.message : String(error)}
@@ -18682,6 +19373,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
@@ -18839,12 +19532,15 @@ 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;
@@ -18852,7 +19548,9 @@ 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;
@@ -18860,7 +19558,9 @@ exports.setupOfflineReconnection = setupOfflineReconnection;
 exports.stageClaudeAttachments = stageClaudeAttachments;
 exports.startHappyServer = startHappyServer;
 exports.stopSession = stopSession;
+exports.suggestTitleForPrompt = suggestTitleForPrompt;
 exports.tmuxSupportsSessionEnv = tmuxSupportsSessionEnv;
+exports.triggerFromFlags = triggerFromFlags;
 exports.waitForSessionKey = waitForSessionKey;
 exports.waitForTurnEnd = waitForTurnEnd;
 exports.writeSessionModeFile = writeSessionModeFile;