very-happy-cli 0.2.158 → 0.2.160

package/dist/agentGuidance-DwOWbX55.cjs

@@ -1,2217 +0,0 @@
-'use strict';
-
-var z = require('zod');
-var node_crypto = require('node:crypto');
-var persistence = require('./limits-kqFqhfsh.cjs');
-var promises = require('node:fs/promises');
-var node_fs = require('node:fs');
-var path = require('node:path');
-var os = require('node:os');
-var axios = require('axios');
-var socket_ioClient = require('socket.io-client');
-
-const TeamScopeSchema = z.z.object({
-  serverUrl: z.z.string(),
-  scopeToken: z.z.string().min(1),
-  teamId: z.z.string().min(1),
-  botId: z.z.string().min(1),
-  taskId: z.z.string().optional(),
-  attemptId: z.z.string().optional()
-});
-function teamScopePath(sessionId) {
-  const supplied = process.env.VH_TEAM_SCOPE_FILE;
-  if (supplied) {
-    if (!path.isAbsolute(supplied)) throw new Error("VH_TEAM_SCOPE_FILE must be absolute");
-    return supplied;
-  }
-  if (!sessionId || !/^[a-zA-Z0-9_-]+$/.test(sessionId)) throw new Error("Teams requires a managed session or VH_TEAM_SCOPE_FILE");
-  return path.join(persistence.configuration.happyHomeDir, "teams", "scopes", `${sessionId}.json`);
-}
-async function readTeamScope(path) {
-  let file;
-  try {
-    file = await promises.open(path, node_fs.constants.O_RDONLY | (node_fs.constants.O_NOFOLLOW ?? 0));
-  } catch (error) {
-    if (error.code === "ENOENT") return null;
-    throw new Error("Cannot open team scope");
-  }
-  try {
-    const stat = await file.stat();
-    if (typeof process.getuid === "function" && stat.uid !== process.getuid()) throw new Error("Team scope owner mismatch");
-    if (!stat.isFile() || process.platform !== "win32" && (stat.mode & 63) !== 0) throw new Error("Team scope must be a private 0600 file");
-    const scope = TeamScopeSchema.parse(JSON.parse(await file.readFile("utf8")));
-    scope.serverUrl = persistence.normalizeHttpEndpoint(scope.serverUrl, "team scope");
-    if (scope.serverUrl !== persistence.configuration.serverUrl) throw new Error("Team scope belongs to another server");
-    return scope;
-  } catch {
-    throw new Error("Invalid or unsafe team scope file");
-  } finally {
-    await file.close();
-  }
-}
-async function writeTeamScope(path$1, scope) {
-  await promises.mkdir(path.dirname(path$1), { recursive: true, mode: 448 });
-  const temporary = `${path$1}.${node_crypto.randomUUID()}.new`;
-  const file = await promises.open(temporary, "wx", 384);
-  try {
-    await file.writeFile(JSON.stringify(TeamScopeSchema.parse(scope)));
-    await file.sync();
-  } finally {
-    await file.close();
-  }
-  try {
-    await promises.rename(temporary, path$1);
-  } finally {
-    await promises.unlink(temporary).catch(() => {
-    });
-  }
-}
-
-async function teamRequest(path, method, token, scoped, body) {
-  const response = await fetch(`${persistence.configuration.serverUrl}${path}`, {
-    method,
-    redirect: "error",
-    headers: { "content-type": "application/json", ...scoped ? { "x-happy-team-token": token } : { authorization: `Bearer ${token}` } },
-    body: body === void 0 ? void 0 : JSON.stringify(body),
-    signal: AbortSignal.timeout(25e3)
-  }).catch(() => {
-    throw new Error("Teams connection failed; outcome may be unknown. Reuse the request ID when retrying.");
-  });
-  if (!response.ok) throw new Error(`Teams request failed (HTTP ${response.status})`);
-  try {
-    return await response.json();
-  } catch {
-    throw new Error("Teams returned an invalid response");
-  }
-}
-class TeamConnectionPreflightError extends Error {
-}
-const initializationLocks = /* @__PURE__ */ new Map();
-async function serializeInitialization(path, work) {
-  const previous = initializationLocks.get(path) ?? Promise.resolve();
-  const next = previous.catch(() => {
-  }).then(work);
-  initializationLocks.set(path, next);
-  try {
-    return await next;
-  } finally {
-    if (initializationLocks.get(path) === next) initializationLocks.delete(path);
-  }
-}
-function createTeamsClient(sessionId) {
-  const scopePath = () => teamScopePath(sessionId ?? process.env.HAPPY_SESSION_ID);
-  return {
-    async initialize(input, options) {
-      const path = scopePath();
-      return serializeInitialization(path, async () => {
-        const priorScope = await readTeamScope(path);
-        if (priorScope && !options?.resumeAdoption) throw new Error("This session already has a team scope; use scoped team tools");
-        if (process.env.VH_TEAM_SCOPE_FILE) throw new Error("Assigned team scope is missing or already managed; ask the owner to restore it");
-        const sid = sessionId ?? process.env.HAPPY_SESSION_ID;
-        if (!sid) throw new Error("A managed session identity is required");
-        const machineId = (await persistence.readSettings()).machineId;
-        if (!machineId) throw new TeamConnectionPreflightError("Connect this machine to Very Happy before joining a team");
-        if (input.machineId && input.machineId !== machineId) throw new TeamConnectionPreflightError("Teams must use this session\u2019s local machine");
-        const persisted = persistence.readPersistedSessions()[sid];
-        if (!persisted || persisted.metadata.machineId !== machineId) throw new TeamConnectionPreflightError("Team identity must be a persisted session on this machine");
-        const credentials = await persistence.readCredentialsForConfiguredRelay();
-        if (!credentials) throw new TeamConnectionPreflightError("Sign in to Very Happy before creating or joining a team");
-        if (priorScope && !options?.expectedTeamId) throw new Error("This session already belongs to another team scope");
-        let teamId = input.teamId ?? options?.expectedTeamId;
-        if (!teamId) {
-          const created = await teamRequest("/v1/teams", "POST", credentials.token, false, { name: input.name, machineId, requestId: input.requestId });
-          teamId = created.team.id;
-        } else {
-          const existing = await teamRequest(`/v1/teams/${encodeURIComponent(teamId)}`, "GET", credentials.token, false);
-          if (existing.team?.machineId !== machineId) throw new TeamConnectionPreflightError("Team belongs to another machine");
-        }
-        if (options?.onTeamResolved) await options.onTeamResolved(teamId);
-        if (priorScope) {
-          if (priorScope.teamId !== teamId || priorScope.taskId) throw new Error("This session already belongs to another team scope");
-          const inspected = await teamRequest(`/v1/teams/${encodeURIComponent(teamId)}/agent`, "GET", priorScope.scopeToken, true);
-          const bot = inspected.team?.bots?.find((candidate) => candidate.id === priorScope.botId);
-          if (!bot?.root || bot.managed || bot.sessionId !== sid) throw new Error("Existing scope is not this session\u2019s root identity");
-          return { team: inspected.team, botId: priorScope.botId };
-        }
-        const result = await teamRequest(
-          `/v1/teams/${encodeURIComponent(teamId)}/actions`,
-          "POST",
-          credentials.token,
-          false,
-          { requestId: input.requestId, action: { type: "join", name: input.name, sessionId: sid, ...input.botId ? { botId: input.botId } : {} } }
-        );
-        if (!result.credential?.token || !result.credential?.botId) throw new Error("Team join did not issue a credential");
-        await writeTeamScope(path, { serverUrl: persistence.configuration.serverUrl, teamId, botId: result.credential.botId, scopeToken: result.credential.token });
-        return { team: result.team, botId: result.credential.botId };
-      });
-    },
-    async inspect() {
-      const scope = await readTeamScope(scopePath());
-      if (!scope) throw new Error("Join or create a team first");
-      const { credential: _credential, ...safe } = await teamRequest(`/v1/teams/${encodeURIComponent(scope.teamId)}/agent`, "GET", scope.scopeToken, true);
-      return safe;
-    },
-    async action(action, requestId = node_crypto.randomUUID()) {
-      const scope = await readTeamScope(scopePath());
-      if (!scope) throw new Error("Join or create a team first");
-      const result = await teamRequest(`/v1/teams/${encodeURIComponent(scope.teamId)}/agent`, "POST", scope.scopeToken, true, { requestId, action });
-      const { credential: _credential, ...safe } = result;
-      return safe;
-    }
-  };
-}
-
-const TEAM_TOOL_NAMES = ["team_create", "team_join", "team_inspect", "team_delegate", "team_message", "team_submit", "team_accept", "team_return", "team_cancel", "team_handoff", "team_schedule_create", "team_schedule_pause", "team_schedule_resume", "team_schedule_cancel"];
-const id$1 = z.z.string().min(1).max(128);
-const text = z.z.string().min(1).max(32e3);
-const requestId = id$1.describe("Unique operation ID. Reuse the same ID and arguments after an uncertain response.");
-function registerTeamsTools(server, sessionId, client = createTeamsClient(sessionId)) {
-  const register = (name, description, inputSchema, execute) => {
-    server.registerTool(name, { description, inputSchema, annotations: { readOnlyHint: name === "team_inspect", idempotentHint: true, openWorldHint: false, destructiveHint: ["team_cancel", "team_handoff", "team_return", "team_schedule_cancel"].includes(name) } }, async (args) => {
-      try {
-        return { content: [{ type: "text", text: JSON.stringify(await execute(args)) }], isError: false };
-      } catch (error) {
-        return { content: [{ type: "text", text: error instanceof Error ? error.message : "Teams operation failed" }], isError: true };
-      }
-    });
-  };
-  register(
-    "team_create",
-    "Create an official Very Happy team and join this session as its root bot. Does not grant access outside this account.",
-    { name: id$1, machineId: id$1.optional(), requestId },
-    (args) => client.initialize(args)
-  );
-  register(
-    "team_join",
-    "Join an existing team as a root bot using this session owner\u2019s account. Scoped workers cannot elevate their role.",
-    { teamId: id$1, name: id$1, botId: id$1.optional().describe("Existing root bot to reconnect; preserves its identity"), requestId },
-    (args) => client.initialize(args)
-  );
-  register("team_inspect", "Read your visible team tasks, attempts and messages. Inspect before decisions; submission is not acceptance.", {}, () => client.inspect());
-  const action = (name, description, fields) => register(
-    `team_${name}`,
-    description,
-    { requestId, ...fields },
-    ({ requestId: key, ...args }) => client.action({ type: name, ...args, ...name === "delegate" && args.directory === void 0 ? { directory: process.cwd() } : {} }, key)
-  );
-  action("delegate", "Delegate a goal with acceptance criteria. Use parentTaskId for subdelegation. Existing assigneeBotId or a managed worker may execute it.", {
-    goal: text,
-    acceptance: z.z.array(text).min(1).max(32),
-    parentTaskId: id$1.optional(),
-    assigneeBotId: id$1.optional(),
-    botName: id$1.optional(),
-    directory: z.z.string().min(1).optional(),
-    assistant: z.z.enum(["claude", "codex", "pi-acp"]).optional(),
-    model: z.z.string().trim().min(1).max(256).optional()
-  });
-  action("message", "Send a persistent task-related message. Delivery does not mean the model has read or acted on it.", { taskId: id$1, body: text, recipientBotId: id$1.optional() });
-  action("submit", "Submit evidence for your current attempt and goal version. The owner still has to accept it.", { taskId: id$1, attemptId: id$1, goalVersion: z.z.number().int().positive(), result: text });
-  const current = { attemptId: id$1, goalVersion: z.z.number().int().positive() };
-  action("accept", "Accept a task you own after checking its evidence. Resource cleanup is tracked separately.", { taskId: id$1, ...current });
-  action("return", "Return your task for further work with a concrete reason.", { taskId: id$1, reason: text, ...current });
-  action("cancel", "Cancel an owned task and its dependent work. Cleanup may remain pending.", { taskId: id$1, reason: text, ...current });
-  action("handoff", "Move an owned task to another bot; prior execution authority is superseded.", { taskId: id$1, assigneeBotId: id$1, ...current });
-  register("team_schedule_create", "Create a persistent one-time or fixed-interval reminder for your own root bot. Delivery wakes the bound session; it does not prove task completion. Use epoch milliseconds, and inspect before retrying.", { requestId, name: id$1, botId: id$1, body: text, runAt: z.z.number().int().nonnegative(), intervalMs: z.z.number().int().min(6e4).optional() }, ({ requestId: key, ...args }) => client.action({ type: "schedule-create", ...args }, key));
-  for (const operation of ["pause", "resume", "cancel"]) {
-    register(`team_schedule_${operation}`, `${operation} your root bot\u2019s schedule using its current version from team_inspect. An already in-flight message may still arrive.`, { requestId, scheduleId: id$1, version: z.z.number().int().positive() }, ({ requestId: key, ...args }) => client.action({ type: `schedule-${operation}`, ...args }, key));
-  }
-}
-
-class AutomationsRequestError extends Error {
-  constructor(status, code, runStatus) {
-    super(describeAutomationError(status, code, runStatus));
-    this.status = status;
-    this.code = code;
-    this.runStatus = runStatus;
-  }
-}
-function isAutomationsUnavailable(error) {
-  return error instanceof AutomationsRequestError && error.status === 404 && !error.code.endsWith("_not_found");
-}
-const AUTOMATIONS_UNAVAILABLE_MESSAGE = "Automations are not enabled on this server (set VH_AUTOMATIONS_ENABLED=true on the server, or upgrade it).";
-function describeAutomationError(status, code, runStatus) {
-  if (status === 404 && !code.endsWith("_not_found")) return AUTOMATIONS_UNAVAILABLE_MESSAGE;
-  const known = {
-    automation_not_found: "No automation with that name or id.",
-    run_not_found: "No automation run with that id.",
-    machine_not_found: "That machine is not registered on this account.",
-    session_not_found: "That session does not belong to this account.",
-    automation_name_taken: "An automation with that name already exists.",
-    automation_count_quota_exceeded: "This account already holds the maximum number of automations (active + paused). Delete one you no longer need (`very-happy auto delete <name>`) before creating another.",
-    automation_paused: "That automation is paused; resume it before firing.",
-    stale_automation: "The automation changed since you read it; read it again and retry with the new version.",
-    run_finished: `The run already reached a terminal state${runStatus ? ` (${runStatus})` : ""}. In a continued (sticky) session, pass the runId named in the latest prompt header \u2014 the environment default is the run that started the session.`,
-    claim_mismatch: "Another daemon holds the claim for that run.",
-    run_not_claimed: "The run has not been claimed by its machine yet; cancel it instead of reporting.",
-    status_required: "An explicit report needs status done or failed.",
-    claim_required: "Lease, session and sticky fields are daemon-only; report just the outcome.",
-    sticky_requires_session: "A sticky key needs a session id.",
-    transaction_conflict: "The server was busy; retry the same request.",
-    invalid_cron: "The cron expression is invalid.",
-    invalid_timezone: "The time zone is not a valid IANA zone."
-  };
-  if (known[code]) return known[code];
-  if (status === 400) return "The server rejected the request (HTTP 400): check the arguments, or the server may expect a newer request shape.";
-  return `Automations request failed (HTTP ${status}${code ? `, ${code}` : ""}).`;
-}
-function createAutomationsClient(options) {
-  const doFetch = options.fetch ?? fetch;
-  const base = options.serverUrl.replace(/\/+$/, "");
-  async function request(method, path, body, query) {
-    const url = new URL(`${base}${path}`);
-    for (const [key, value] of Object.entries(query ?? {})) if (value !== void 0) url.searchParams.set(key, value);
-    let response;
-    try {
-      response = await doFetch(url.toString(), {
-        method,
-        redirect: "error",
-        headers: { "content-type": "application/json", authorization: `Bearer ${options.token}`, "x-happy-client": `${options.client ?? "cli-auto"}/${persistence.configuration.currentCliVersion}` },
-        body: body === void 0 ? void 0 : JSON.stringify(body),
-        signal: AbortSignal.timeout(options.timeoutMs ?? 25e3)
-      });
-    } catch {
-      throw new Error("Automations connection failed; the outcome may be unknown. Read the current state before retrying.");
-    }
-    let parsed = null;
-    try {
-      parsed = await response.json();
-    } catch {
-      parsed = null;
-    }
-    if (!response.ok) {
-      const code = typeof parsed?.error === "string" ? parsed.error : "";
-      throw new AutomationsRequestError(response.status, code, typeof parsed?.status === "string" ? parsed.status : void 0);
-    }
-    return parsed;
-  }
-  const enc = encodeURIComponent;
-  return {
-    list: (machineId) => request("GET", "/v1/automations", void 0, { machineId }).then((r) => r.automations),
-    get: (id) => request("GET", `/v1/automations/${enc(id)}`).then((r) => r.automation),
-    getByName: (name) => request("GET", `/v1/automations/by-name/${enc(name)}`).then((r) => r.automation),
-    create: (input) => request("POST", "/v1/automations", input).then((r) => r.automation),
-    update: (id, input) => request("PATCH", `/v1/automations/${enc(id)}`, input).then((r) => r.automation),
-    remove: (id) => request("DELETE", `/v1/automations/${enc(id)}`),
-    pause: (id) => request("POST", `/v1/automations/${enc(id)}/pause`).then((r) => r.automation),
-    resume: (id) => request("POST", `/v1/automations/${enc(id)}/resume`).then((r) => r.automation),
-    run: (id, input = {}) => request("POST", `/v1/automations/${enc(id)}/run`, input).then((r) => r.run),
-    fire: (name, input = {}) => request("POST", `/v1/automations/by-name/${enc(name)}/fire`, input),
-    runs: (query = {}) => request("GET", "/v1/automations/runs", void 0, {
-      automationId: query.automationId,
-      name: query.name,
-      status: query.status,
-      attention: query.attention ? "1" : void 0,
-      limit: query.limit === void 0 ? void 0 : String(query.limit)
-    }).then((r) => r.runs),
-    getRun: (id) => request("GET", `/v1/automations/runs/${enc(id)}`).then((r) => r.run),
-    cancel: (id) => request("POST", `/v1/automations/runs/${enc(id)}/cancel`).then((r) => r.run),
-    /** B-508: `by` records what resolved the flag (server default `owner`; older servers ignore the body). */
-    ack: (id, by) => request("POST", `/v1/automations/runs/${enc(id)}/ack`, by === void 0 ? void 0 : { by }).then((r) => r.run),
-    report: (id, input) => request("POST", `/v1/automations/runs/${enc(id)}/report`, input).then((r) => r.run),
-    claim: (input) => request("POST", "/v1/automations/claim", input),
-    stickies: (id, key) => request("GET", `/v1/automations/${enc(id)}/stickies`, void 0, { key }).then((r) => r.stickies),
-    putSticky: (id, key, sessionId) => request("PUT", `/v1/automations/${enc(id)}/stickies`, { key, sessionId }).then((r) => r.sticky),
-    deleteSticky: (id, key) => request("DELETE", `/v1/automations/${enc(id)}/stickies`, { key }).then((r) => r.removed)
-  };
-}
-async function authenticatedAutomationsClient(client = "cli-auto") {
-  const credentials = await persistence.readCredentialsForConfiguredRelay();
-  if (!credentials) throw new Error("Not authenticated. Run `very-happy auth login` first.");
-  const settings = await persistence.readSettings();
-  return { client: createAutomationsClient({ serverUrl: persistence.configuration.serverUrl, token: credentials.token, client }), machineId: settings.machineId };
-}
-function automationRunIdFromEnv(env = process.env) {
-  const value = env.VH_AUTOMATION_RUN_ID;
-  return value && /^[a-zA-Z0-9_-]{1,128}$/.test(value) ? value : void 0;
-}
-
-const AUTOMATION_TOOL_NAMES = [
-  "automation_list",
-  "automation_get",
-  "automation_create",
-  "automation_update",
-  "automation_pause",
-  "automation_resume",
-  "automation_delete",
-  "automation_run",
-  "automation_fire",
-  "automation_runs",
-  "automation_report",
-  "automation_ack"
-];
-const id = z.z.string().min(1).max(128);
-const ref = { name: persistence.AutomationNameSchema.optional().describe("Automation name"), id: id.optional().describe("Automation id (alternative to name)") };
-const payload = z.z.string().max(65536).optional().describe("Payload text; JSON lets prompts use {{payload.field}}");
-const maxRuntimeMs = z.z.number().int().min(6e4).max(7 * 864e5).optional();
-const AUTOMATION_TOOL_SCHEMAS = {
-  automation_list: { description: "List this account\u2019s automations (name, trigger, action, machine, status, next run). Defaults to every machine.", readOnly: true, inputSchema: { machineId: id.optional().describe("Only this machine id, or 'this' for the current machine") } },
-  automation_get: { description: "Read one automation by name or id, including its version (needed for automation_update).", readOnly: true, inputSchema: ref },
-  automation_create: {
-    description: "Create an automation: a trigger (cron+tz / interval / once / manual) and an action (spawn a session, send into a session, or run a script argv) on one machine. Defaults to the current machine. Prompts and argv may use {{payload}}, {{payload.path}}, {{run.id}}, {{automation.name}}, {{now}}.",
-    inputSchema: {
-      name: persistence.AutomationNameSchema,
-      description: z.z.string().max(4e3).optional(),
-      machineId: id.optional().describe("Target machine id; omit or 'this' for the current machine"),
-      trigger: persistence.AutomationTriggerSchema,
-      action: persistence.AutomationActionSchema,
-      concurrency: persistence.AutomationConcurrencySchema.optional().describe("skip (default): a run while another is active is recorded as skipped; queue: it waits"),
-      maxRuntimeMs,
-      paused: z.z.boolean().optional().describe("Create paused")
-    }
-  },
-  automation_update: {
-    description: "Change an automation (name / description / machine / trigger / action / concurrency / maxRuntimeMs). Requires the current version from automation_get; a stale version is rejected.",
-    inputSchema: {
-      ...ref,
-      version: z.z.number().int().positive(),
-      newName: persistence.AutomationNameSchema.optional(),
-      description: z.z.string().max(4e3).nullable().optional(),
-      machineId: id.optional(),
-      trigger: persistence.AutomationTriggerSchema.optional(),
-      action: persistence.AutomationActionSchema.optional(),
-      concurrency: persistence.AutomationConcurrencySchema.optional(),
-      maxRuntimeMs
-    }
-  },
-  automation_pause: { description: "Pause an automation: no new scheduled runs and fire is refused until resumed.", inputSchema: ref },
-  automation_resume: { description: "Resume a paused automation; the next run is computed from now.", inputSchema: ref },
-  automation_delete: { description: "Delete an automation and its run history. Irreversible.", destructive: true, inputSchema: ref },
-  automation_run: { description: "Queue one run of an automation now (source: manual), optionally with a payload.", inputSchema: { ...ref, payload } },
-  automation_fire: { description: "Trigger an automation by name as an external event, with an optional payload and dedupe key (the same key within 24h returns the original run).", inputSchema: { name: persistence.AutomationNameSchema, payload, dedupeKey: z.z.string().min(1).max(256).optional() } },
-  automation_runs: { description: "List runs, newest first: status, session, summary, error, attention. Filter by automation, status or attention.", readOnly: true, inputSchema: { ...ref, status: z.z.string().min(1).max(64).optional(), attention: z.z.boolean().optional().describe("Only runs flagged for a human"), limit: z.z.number().int().min(1).max(200).optional() } },
-  automation_report: {
-    description: 'Report the result of an automation run. Without runId it targets the run that STARTED this session (VH_AUTOMATION_RUN_ID); in a continued sticky session always pass the runId named in the latest "[Very Happy automation \u2026 run <id>; \u2026]" prompt header. Use status done with a short summary, or failed with the error; set needsAttention when a human must look.',
-    inputSchema: { runId: id.optional(), status: z.z.enum(["done", "failed"]), summary: z.z.string().max(4096).optional(), error: z.z.string().max(4096).optional(), needsAttention: z.z.boolean().optional(), attentionReason: z.z.string().max(512).optional() }
-  },
-  automation_ack: { description: "Clear the attention flag of a run after a human handled it.", inputSchema: { runId: id } }
-};
-async function resolve(context, args) {
-  if (args.id) return context.client.get(args.id);
-  if (args.name) return context.client.getByName(args.name);
-  throw new Error("Give the automation name or id");
-}
-function machineFor(context, requested) {
-  if (requested && requested !== "this") return requested;
-  return context.machineId;
-}
-function requireMachine(context, requested) {
-  const machine = machineFor(context, requested);
-  if (!machine) throw new Error("This machine is not registered with Very Happy; pass machineId explicitly");
-  return machine;
-}
-async function executeAutomationTool(name, args, context) {
-  const { client } = context;
-  switch (name) {
-    case "automation_list":
-      return { automations: await client.list(machineFor(context, args.machineId)) };
-    case "automation_get":
-      return { automation: await resolve(context, args) };
-    case "automation_create": {
-      const input = {
-        name: args.name,
-        machineId: requireMachine(context, args.machineId),
-        trigger: args.trigger,
-        action: args.action,
-        ...args.description !== void 0 ? { description: args.description } : {},
-        ...args.concurrency !== void 0 ? { concurrency: args.concurrency } : {},
-        ...args.maxRuntimeMs !== void 0 ? { maxRuntimeMs: args.maxRuntimeMs } : {},
-        ...args.paused ? { status: "paused" } : {}
-      };
-      return { automation: await client.create(input) };
-    }
-    case "automation_update": {
-      const current = await resolve(context, args);
-      const input = {
-        version: args.version,
-        ...args.newName !== void 0 ? { name: args.newName } : {},
-        ...args.description !== void 0 ? { description: args.description } : {},
-        ...args.machineId !== void 0 ? { machineId: machineFor(context, args.machineId) } : {},
-        ...args.trigger !== void 0 ? { trigger: args.trigger } : {},
-        ...args.action !== void 0 ? { action: args.action } : {},
-        ...args.concurrency !== void 0 ? { concurrency: args.concurrency } : {},
-        ...args.maxRuntimeMs !== void 0 ? { maxRuntimeMs: args.maxRuntimeMs } : {}
-      };
-      return { automation: await client.update(current.id, input) };
-    }
-    case "automation_pause":
-      return { automation: await client.pause((await resolve(context, args)).id) };
-    case "automation_resume":
-      return { automation: await client.resume((await resolve(context, args)).id) };
-    case "automation_delete": {
-      const target = await resolve(context, args);
-      await client.remove(target.id);
-      return { deleted: true, id: target.id, name: target.name };
-    }
-    case "automation_run":
-      return { run: await client.run((await resolve(context, args)).id, args.payload !== void 0 ? { payload: args.payload } : {}) };
-    case "automation_fire":
-      return client.fire(args.name, { ...args.payload !== void 0 ? { payload: args.payload } : {}, ...args.dedupeKey !== void 0 ? { dedupeKey: args.dedupeKey } : {} });
-    case "automation_runs": {
-      const automationId = args.id ?? (args.name ? (await client.getByName(args.name)).id : void 0);
-      return { runs: await client.runs({ automationId, status: args.status, attention: args.attention === true, limit: args.limit }) };
-    }
-    case "automation_report": {
-      const runId = args.runId ?? automationRunIdFromEnv(context.env ?? process.env);
-      if (!runId) throw new Error("No run id: pass runId (this session was not started by an automation)");
-      const report = {
-        status: args.status,
-        ...args.summary !== void 0 ? { summary: args.summary } : {},
-        ...args.error !== void 0 ? { error: args.error } : {},
-        ...args.needsAttention !== void 0 ? { needsAttention: args.needsAttention } : {},
-        ...args.attentionReason !== void 0 ? { attentionReason: args.attentionReason } : {}
-      };
-      return { run: await client.report(runId, report) };
-    }
-    case "automation_ack":
-      return { run: await client.ack(args.runId) };
-  }
-}
-function createAutomationToolExecutor() {
-  let context = null;
-  return async (name, args) => {
-    context ??= authenticatedAutomationsClient("mcp-auto").then(({ client, machineId }) => ({ client, machineId }));
-    let resolved;
-    try {
-      resolved = await context;
-    } catch (error) {
-      context = null;
-      throw error;
-    }
-    return executeAutomationTool(name, args, resolved);
-  };
-}
-function registerAutomationTools(server, execute = createAutomationToolExecutor()) {
-  for (const name of AUTOMATION_TOOL_NAMES) {
-    const spec = AUTOMATION_TOOL_SCHEMAS[name];
-    server.registerTool(name, {
-      description: spec.description,
-      inputSchema: spec.inputSchema,
-      annotations: { readOnlyHint: spec.readOnly === true, idempotentHint: name !== "automation_run" && name !== "automation_create", openWorldHint: false, destructiveHint: spec.destructive === true }
-    }, async (args) => {
-      try {
-        return { content: [{ type: "text", text: JSON.stringify(await execute(name, args ?? {})) }], isError: false };
-      } catch (error) {
-        return { content: [{ type: "text", text: error instanceof Error ? error.message : "Automation operation failed" }], isError: true };
-      }
-    });
-  }
-}
-
-function sessionWebUrl(sessionId) {
-  return `${persistence.configuration.webappUrl.replace(/\/+$/, "")}/session/${sessionId}`;
-}
-async function waitForSessionKey(sessionId, timeoutMs) {
-  const deadline = Date.now() + timeoutMs;
-  while (true) {
-    const entry = persistence.readPersistedSessions()[sessionId];
-    if (entry) return entry;
-    if (Date.now() >= deadline) {
-      throw new Error(
-        `Session ${sessionId} has no encryption key in ${persistence.configuration.sessionsFile}. Either it was not spawned by this machine's daemon, or the daemon is too old to persist session keys.`
-      );
-    }
-    await persistence.delay(200);
-  }
-}
-async function sendUserMessage(sessionId, persisted, text, client, options = {}) {
-  const credentials = await persistence.readCredentialsForConfiguredRelay();
-  if (!credentials) {
-    throw new Error("Not authenticated. Run `very-happy auth login` first.");
-  }
-  const envelope = {
-    role: "user",
-    content: {
-      type: "text",
-      text
-    },
-    meta: {
-      sentFrom: options.sentFrom ?? "cli",
-      ...options.model !== void 0 ? { model: options.model } : {},
-      ...options.permissionMode !== void 0 ? { permissionMode: options.permissionMode } : {},
-      ...options.effort !== void 0 ? { effort: options.effort } : {},
-      ...options.delivery !== void 0 ? { delivery: options.delivery } : {}
-    }
-  };
-  const encrypted = persistence.encodeBase64(persistence.encrypt(
-    persistence.decodeBase64(persisted.encryptionKey),
-    persisted.encryptionVariant,
-    envelope
-  ));
-  await axios.post(
-    `${persistence.configuration.serverUrl}/v3/sessions/${encodeURIComponent(sessionId)}/messages`,
-    { messages: [{ content: encrypted, localId: options.localId ?? node_crypto.randomUUID() }] },
-    {
-      headers: {
-        "Authorization": `Bearer ${credentials.token}`,
-        "Content-Type": "application/json",
-        "X-Happy-Client": `${client}/${persistence.configuration.currentCliVersion}`
-      },
-      timeout: 3e4
-    }
-  );
-}
-
-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;
-  return chars.slice(0, max).join("") + ` \u2026[+${chars.length - max} chars]`;
-}
-function squash(text) {
-  return text.replace(/\s+/g, " ").trim();
-}
-function safeJson(value, max) {
-  try {
-    return truncateText(JSON.stringify(value) ?? "", max);
-  } catch {
-    return "[unserializable]";
-  }
-}
-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, limits.line)}` : null;
-  }
-  if (b.role === "session" && b.content && typeof b.content === "object") {
-    const env = b.content;
-    const ev = env.ev;
-    if (!ev || typeof ev.t !== "string") return null;
-    switch (ev.t) {
-      case "text": {
-        if (ev.thinking) return null;
-        const text = squash(String(ev.text ?? ""));
-        if (text.length === 0) return null;
-        const role = env.role === "user" ? "user" : "assistant";
-        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, limits.args) : "";
-        const detail = title || args;
-        return `[tool] ${name}${detail ? `: ${truncateText(detail, limits.args)}` : ""}`;
-      }
-      case "service": {
-        const text = squash(String(ev.text ?? ""));
-        return text.length > 0 ? `[service] ${truncateText(text, limits.args)}` : null;
-      }
-      case "turn-end": {
-        if (ev.status && ev.status !== "completed") return `[turn ${ev.status}]`;
-        return null;
-      }
-      default:
-        return null;
-    }
-  }
-  if (b.role === "agent" && b.content?.type === "acp" && b.content.data && typeof b.content.data === "object") {
-    const d = b.content.data;
-    switch (d.type) {
-      case "message": {
-        const text = squash(String(d.message ?? ""));
-        return text.length > 0 ? `assistant: ${truncateText(text, limits.line)}` : null;
-      }
-      case "tool-call":
-        return `[tool] ${String(d.name ?? "tool")}: ${safeJson(d.input, limits.args)}`;
-      case "permission-request":
-        return `[permission] ${String(d.toolName ?? "")}: ${truncateText(squash(String(d.description ?? "")), limits.args)}`;
-      default:
-        return null;
-    }
-  }
-  if (b.role === "agent" && b.content?.type === "output") {
-    const msg = b.content.data?.message;
-    if (msg && Array.isArray(msg.content)) {
-      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(" "), limits.line)}`;
-      }
-    }
-    return null;
-  }
-  return null;
-}
-function formatTranscript(bodies, options = {}) {
-  const limits = options.full ? NO_LIMITS : DEFAULT_LIMITS;
-  const lines = [];
-  for (const body of bodies) {
-    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, {
-    auth: {
-      token,
-      clientType: "user-scoped",
-      happyClient: `cli-session-ops/${persistence.configuration.currentCliVersion}`
-    },
-    path: "/v1/updates",
-    transports: ["websocket"],
-    reconnection: false,
-    autoConnect: false
-  });
-  await new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-      socket.close();
-      reject(new Error(`Timed out connecting to ${persistence.configuration.serverUrl}`));
-    }, options.connectTimeoutMs ?? USER_SOCKET_CONNECT_TIMEOUT_MS);
-    socket.once("connect", () => {
-      clearTimeout(timer);
-      resolve();
-    });
-    socket.once("connect_error", (error) => {
-      clearTimeout(timer);
-      socket.close();
-      reject(new Error(`Could not connect to ${persistence.configuration.serverUrl}: ${error.message}`));
-    });
-    socket.connect();
-  });
-  return {
-    async rpcCall(payload, timeoutMs) {
-      const ack = await socket.timeout(timeoutMs).emitWithAck("rpc-call", payload);
-      return ack;
-    },
-    close() {
-      socket.close();
-    }
-  };
-}
-
-const RPC_RATE_LIMIT_ERROR = "RPC rate limit reached";
-const RPC_ACCOUNT_RATE_LIMIT_ERROR = "RPC account rate limit reached";
-const RPC_RATE_RETRY_MIN_DELAY_MS = 2e3;
-const RPC_RATE_RETRY_MAX_DELAY_MS = 6e4;
-const RPC_RATE_MAX_RETRIES = 2;
-function isRpcRateLimitAck(ack) {
-  if (!ack || typeof ack !== "object") return false;
-  const a = ack;
-  if (a.ok !== false) return false;
-  if (a.code === "rpc_rate_limited" || a.code === "rpc_account_rate_limited") return true;
-  return a.error === RPC_RATE_LIMIT_ERROR || a.error === RPC_ACCOUNT_RATE_LIMIT_ERROR;
-}
-function rpcRateRetryDelayMs(attempt, retryAfterMs, random = Math.random()) {
-  if (typeof retryAfterMs === "number" && Number.isFinite(retryAfterMs) && retryAfterMs > 0) {
-    return Math.min(RPC_RATE_RETRY_MAX_DELAY_MS, Math.round(retryAfterMs * (1 + random * 0.5)));
-  }
-  const exponent = Math.max(0, Math.min(attempt, 32) - 1);
-  const ceiling = Math.min(RPC_RATE_RETRY_MIN_DELAY_MS * 2 ** exponent, RPC_RATE_RETRY_MAX_DELAY_MS);
-  return Math.round(RPC_RATE_RETRY_MIN_DELAY_MS + random * (ceiling - RPC_RATE_RETRY_MIN_DELAY_MS));
-}
-
-const PERMISSION_OPS_CLIENT = "session-ops";
-const PERMISSION_RPC_TIMEOUT_MS = 3e4;
-const SETTLE_TIMEOUT_MS = 5e3;
-const SETTLE_POLL_MS = 500;
-function buildPermissionRpcPayload(requestId, verdict) {
-  if (verdict.kind === "approve") {
-    return {
-      id: requestId,
-      approved: true,
-      decision: verdict.forSession ? "approved_for_session" : "approved"
-    };
-  }
-  return {
-    id: requestId,
-    approved: false,
-    decision: "denied",
-    ...verdict.reason ? { reason: verdict.reason } : {}
-  };
-}
-function interpretPermissionAck(ack, decryptResult) {
-  if (!ack.ok) {
-    const message = ack.error ?? "RPC call failed";
-    if (message === "RPC method not available") {
-      return { status: "offline", message: "no running wrapper has registered the permission RPC for this session" };
-    }
-    if (message === "RPC target disconnected") {
-      return { status: "offline", message: "the wrapper disconnected while the permission RPC was in flight" };
-    }
-    if (/timed? ?out/i.test(message)) {
-      return { status: "timeout", message };
-    }
-    if (isRpcRateLimitAck(ack)) {
-      return { status: "rate-limited", message, retryAfterMs: rpcRateRetryDelayMs(1, ack.retryAfterMs, 0) };
-    }
-    return { status: "rejected", message };
-  }
-  let body = null;
-  if (typeof ack.result === "string" && ack.result.length > 0) {
-    try {
-      body = decryptResult(ack.result);
-    } catch {
-      body = null;
-    }
-  }
-  if (body && typeof body === "object" && typeof body.error === "string") {
-    return { status: "handler-error", message: body.error };
-  }
-  return { status: "acknowledged" };
-}
-function pendingRequestsOf(agentState, now) {
-  const requests = agentState?.requests;
-  if (!requests || typeof requests !== "object") return [];
-  return Object.entries(requests).map(([id, request]) => ({
-    id,
-    tool: typeof request?.tool === "string" ? request.tool : "unknown",
-    ...request?.kind ? { kind: request.kind } : {},
-    ...typeof request?.createdAt === "number" ? { createdAt: request.createdAt, waitingMs: Math.max(0, now - request.createdAt) } : {}
-  })).sort((a, b) => (a.createdAt ?? Number.MAX_SAFE_INTEGER) - (b.createdAt ?? Number.MAX_SAFE_INTEGER));
-}
-const RPC_DEADLINE_GRACE_MS = 2e3;
-function withDeadline(promise, ms, message) {
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => reject(new Error(`${message} (timed out)`)), ms);
-    promise.then(
-      (value) => {
-        clearTimeout(timer);
-        resolve(value);
-      },
-      (error) => {
-        clearTimeout(timer);
-        reject(error);
-      }
-    );
-  });
-}
-async function resolvePermissionRequest(sessionId, requestId, verdict, deps = {}) {
-  const now = deps.now ?? Date.now;
-  const persisted = (deps.readPersisted ?? persistence.readPersistedSessions)()[sessionId];
-  if (!persisted) {
-    throw new Error(
-      `No local key for session ${sessionId} \u2014 approve/deny needs the session key from ~/.happy/sessions.json (the RPC payload is encrypted with it), so only sessions this machine's daemon spawned within 14 days can be answered from here.`
-    );
-  }
-  const token = await (deps.bearerToken ?? bearerToken$2)();
-  const fetchState = deps.fetchAgentState ?? fetchDecryptedAgentState;
-  const before = pendingRequestsOf(await fetchState(sessionId, persisted, token), now());
-  if (!before.some((request) => request.id === requestId)) {
-    const hint = before.length > 0 ? `Pending request ids: ${before.map((request) => `${request.id} (${request.tool})`).join(", ")}` : "The session has no pending requests.";
-    throw new Error(`Request ${requestId} is not pending on session ${sessionId}. ${hint}`);
-  }
-  const payload = buildPermissionRpcPayload(requestId, verdict);
-  const key = persistence.decodeBase64(persisted.encryptionKey);
-  const params = persistence.encodeBase64(persistence.encrypt(key, persisted.encryptionVariant, payload));
-  const transport = await (deps.openTransport ?? openUserScopedSocket)(token);
-  const rpcTimeoutMs = deps.rpcTimeoutMs ?? PERMISSION_RPC_TIMEOUT_MS;
-  const sleep = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
-  let ack;
-  try {
-    for (let attempt = 1; ; attempt++) {
-      try {
-        ack = await withDeadline(
-          transport.rpcCall({ method: `${sessionId}:permission`, params }, rpcTimeoutMs),
-          rpcTimeoutMs + RPC_DEADLINE_GRACE_MS,
-          `permission RPC did not settle within ${rpcTimeoutMs}ms`
-        );
-      } catch (error) {
-        ack = { ok: false, error: error instanceof Error ? error.message : "RPC call failed" };
-      }
-      if (!isRpcRateLimitAck(ack) || attempt > RPC_RATE_MAX_RETRIES) break;
-      const waitMs = rpcRateRetryDelayMs(attempt, ack.retryAfterMs, (deps.random ?? Math.random)());
-      deps.onRateLimited?.({ attempt, waitMs, serverError: ack.error ?? "RPC rate limit reached" });
-      await sleep(waitMs);
-    }
-  } finally {
-    transport.close();
-  }
-  const outcome = interpretPermissionAck(ack, (encrypted) => persistence.decrypt(key, persisted.encryptionVariant, persistence.decodeBase64(encrypted)));
-  if (outcome.status !== "acknowledged") {
-    return { sessionId, requestId, payload, outcome };
-  }
-  const deadline = now() + (deps.settleTimeoutMs ?? SETTLE_TIMEOUT_MS);
-  let settled = false;
-  for (; ; ) {
-    const pending = pendingRequestsOf(await fetchState(sessionId, persisted, token), now());
-    if (!pending.some((request) => request.id === requestId)) {
-      settled = true;
-      break;
-    }
-    if (now() >= deadline) break;
-    await sleep(SETTLE_POLL_MS);
-  }
-  return { sessionId, requestId, payload, outcome, settled };
-}
-async function bearerToken$2() {
-  const credentials = await persistence.readCredentialsForConfiguredRelay();
-  if (!credentials) throw new Error("CLI is not authenticated (no ~/.happy/access.key)");
-  return credentials.token;
-}
-async function fetchDecryptedAgentState(sessionId, persisted, token) {
-  const response = await axios.get(
-    `${persistence.configuration.serverUrl}/v1/sessions/${encodeURIComponent(sessionId)}`,
-    {
-      headers: {
-        "Authorization": `Bearer ${token}`,
-        "X-Happy-Client": `${PERMISSION_OPS_CLIENT}/${persistence.configuration.currentCliVersion}`
-      },
-      timeout: 15e3,
-      // 404 is a real answer ("not yours / gone"), not a transport fault.
-      validateStatus: (status) => status >= 200 && status < 300 || status === 404
-    }
-  );
-  if (response.status === 404) {
-    throw new Error(`Session ${sessionId} was not found on this account (it may have been deleted, or the local key belongs to a session on another relay).`);
-  }
-  const raw = response.data?.session?.agentState;
-  if (typeof raw !== "string" || raw.length === 0) return null;
-  return persistence.decrypt(persistence.decodeBase64(persisted.encryptionKey), persisted.encryptionVariant, persistence.decodeBase64(raw));
-}
-
-const SESSION_OPS_CLIENT = "session-ops";
-const DEFAULT_RECENT_LIMIT = 15;
-const MAX_READ_LIMIT = 100;
-function backgroundTasksOf(child) {
-  const raw = child.backgroundTasks;
-  if (!raw || typeof raw !== "object") return void 0;
-  const r = raw;
-  if (typeof r.count !== "number" || !Array.isArray(r.tasks)) return void 0;
-  return {
-    count: r.count,
-    tasks: r.tasks.filter((task) => !!task && typeof task === "object" && typeof task.id === "string"),
-    ...typeof r.reportedAt === "number" ? { reportedAt: r.reportedAt } : {},
-    ...r.stale === true ? { stale: true } : {}
-  };
-}
-function mergeSessionSummaries(live, persisted, options = {}) {
-  const recentLimit = Math.max(0, options.recentLimit ?? DEFAULT_RECENT_LIMIT);
-  const seen = /* @__PURE__ */ new Set();
-  const summaries = [];
-  for (const child of live) {
-    const id = typeof child.happySessionId === "string" ? child.happySessionId : void 0;
-    if (!id || seen.has(id)) continue;
-    seen.add(id);
-    summaries.push(toSummary(id, persisted[id], livenessOf(child)));
-  }
-  const rest = Object.entries(persisted).filter(([id]) => !seen.has(id)).filter(([, entry]) => entry.metadata?.flavor !== "terminal-mirror").sort((a, b) => b[1].savedAt - a[1].savedAt).slice(0, recentLimit);
-  for (const [id, entry] of rest) {
-    summaries.push(toSummary(id, entry, { live: false }));
-  }
-  if (!options.tag) return summaries;
-  const wanted = options.tag;
-  return summaries.filter((summary) => summary.tags?.includes(wanted) === true);
-}
-function livenessOf(child) {
-  const backgroundTasks = backgroundTasksOf(child);
-  return { live: true, pid: typeof child.pid === "number" ? child.pid : void 0, ...backgroundTasks ? { backgroundTasks } : {} };
-}
-function sessionLiveness(live, sessionId) {
-  const child = live.find((entry) => entry.happySessionId === sessionId);
-  return child ? livenessOf(child) : { live: false };
-}
-function toSummary(id, persisted, extra) {
-  const meta = persisted?.metadata;
-  return {
-    id,
-    live: extra.live,
-    ...extra.pid !== void 0 ? { pid: extra.pid } : {},
-    ...extra.backgroundTasks ? { backgroundTasks: extra.backgroundTasks } : {},
-    ...meta?.summary?.text ? { title: meta.summary.text } : {},
-    ...meta?.path ? { cwd: meta.path } : {},
-    ...meta?.flavor ? { flavor: meta.flavor } : {},
-    ...meta?.tags?.length ? { tags: [...meta.tags] } : {},
-    ...meta?.variant ? { variant: meta.variant } : {},
-    url: sessionWebUrl(id),
-    ...persisted?.savedAt !== void 0 ? { savedAt: persisted.savedAt } : {}
-  };
-}
-async function listSessions(options = {}) {
-  const live = await persistence.listDaemonSessions();
-  return mergeSessionSummaries(live, persistence.readPersistedSessions(), options);
-}
-function summarizeAccountSession(row, persisted, liveIds, now) {
-  const base = {
-    id: row.id,
-    live: liveIds.has(row.id),
-    url: sessionWebUrl(row.id),
-    decryptable: false,
-    readable: false,
-    active: row.active === true,
-    archived: typeof row.archivedAt === "number",
-    ...typeof row.activeAt === "number" ? { activeAt: row.activeAt } : {},
-    ...typeof row.updatedAt === "number" ? { updatedAt: row.updatedAt } : {},
-    attention: false
-  };
-  if (!persisted) return base;
-  const key = persistence.decodeBase64(persisted.encryptionKey);
-  let metadata = null;
-  let agentState = null;
-  try {
-    metadata = row.metadata ? persistence.decrypt(key, persisted.encryptionVariant, persistence.decodeBase64(row.metadata)) : null;
-    agentState = row.agentState ? persistence.decrypt(key, persisted.encryptionVariant, persistence.decodeBase64(row.agentState)) : null;
-  } catch {
-    return base;
-  }
-  if (!metadata) return base;
-  const meta = metadata;
-  const pending = pendingRequestsOf(agentState, now);
-  const backgroundTasks = persistence.backgroundTasksReport(agentState?.backgroundTasks, now, { active: row.active === true });
-  return {
-    ...base,
-    decryptable: true,
-    readable: true,
-    backgroundTasks,
-    ...meta.summary?.text ? { title: meta.summary.text } : {},
-    ...meta.path ? { cwd: meta.path } : {},
-    ...meta.flavor ? { flavor: meta.flavor } : {},
-    ...meta.tags?.length ? { tags: [...meta.tags] } : {},
-    ...meta.variant ? { variant: meta.variant } : {},
-    ...meta.machineId ? { machineId: meta.machineId } : {},
-    ...persisted.savedAt !== void 0 ? { savedAt: persisted.savedAt } : {},
-    pending,
-    attention: pending.length > 0
-  };
-}
-function orderAccountSessions(summaries, options = {}) {
-  const oldestWait = (summary) => Math.max(0, ...(summary.pending ?? []).map((request) => request.waitingMs ?? 0));
-  const rank = (summary) => summary.attention ? 0 : summary.live ? 1 : 2;
-  let rows = summaries.filter((summary) => summary.flavor !== "terminal-mirror").slice().sort((a, b) => {
-    const byRank = rank(a) - rank(b);
-    if (byRank !== 0) return byRank;
-    if (a.attention && b.attention) return oldestWait(b) - oldestWait(a);
-    return (b.updatedAt ?? 0) - (a.updatedAt ?? 0);
-  });
-  if (options.tag) {
-    const wanted = options.tag;
-    rows = rows.filter((summary) => summary.tags?.includes(wanted) === true);
-  }
-  const recentLimit = Math.max(0, options.recentLimit ?? DEFAULT_RECENT_LIMIT);
-  let idleKept = 0;
-  return rows.filter((summary) => rank(summary) < 2 || idleKept++ < recentLimit);
-}
-async function listAccountSessions(options = {}) {
-  const token = await bearerToken$1();
-  const response = await axios.get(`${persistence.configuration.serverUrl}/v1/sessions`, {
-    headers: {
-      "Authorization": `Bearer ${token}`,
-      "X-Happy-Client": `${SESSION_OPS_CLIENT}/${persistence.configuration.currentCliVersion}`
-    },
-    timeout: 15e3
-  });
-  const rows = Array.isArray(response.data?.sessions) ? response.data.sessions : [];
-  const persisted = persistence.readPersistedSessions();
-  const live = await persistence.listDaemonSessions();
-  const liveIds = new Set(live.map((child) => child.happySessionId).filter((id) => typeof id === "string"));
-  const now = Date.now();
-  const summaries = rows.filter((row) => typeof row?.id === "string").map((row) => summarizeAccountSession(row, persisted[row.id], liveIds, now)).filter((summary) => options.includeArchived || !summary.archived);
-  return orderAccountSessions(summaries, options);
-}
-async function bearerToken$1() {
-  const credentials = await persistence.readCredentialsForConfiguredRelay();
-  if (!credentials) throw new Error("CLI is not authenticated (no ~/.happy/access.key)");
-  return credentials.token;
-}
-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).`
-    );
-  }
-  return persisted;
-}
-async function readSessionLog(sessionId, persisted, limit) {
-  const token = await bearerToken$1();
-  const response = await axios.get(
-    `${persistence.configuration.serverUrl}/v3/sessions/${encodeURIComponent(sessionId)}/messages`,
-    {
-      params: { before_seq: 2147483647, limit },
-      headers: {
-        "Authorization": `Bearer ${token}`,
-        "X-Happy-Client": `${SESSION_OPS_CLIENT}/${persistence.configuration.currentCliVersion}`
-      },
-      timeout: 15e3
-    }
-  );
-  const messages = Array.isArray(response.data?.messages) ? response.data.messages : [];
-  messages.reverse();
-  const key = persistence.decodeBase64(persisted.encryptionKey);
-  return messages.map((message) => {
-    if (message.content?.t !== "encrypted") return { seq: message.seq, body: null };
-    try {
-      return { seq: message.seq, body: persistence.decrypt(key, persisted.encryptionVariant, persistence.decodeBase64(message.content.c)) };
-    } catch {
-      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 persistence.listDaemonSessions();
-  return {
-    summary: toSummary(sessionId, persisted, sessionLiveness(live, sessionId)),
-    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$1();
-  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));
-}
-async function readSessionState(sessionId, persisted) {
-  const token = await bearerToken$1();
-  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,
-    validateStatus: (status) => status >= 200 && status < 300 || status === 404
-  });
-  if (response.status === 404) return { found: false, active: false };
-  const row = response.data?.session;
-  if (!row || typeof row.id !== "string") throw new Error(`Server returned no session row for ${sessionId}`);
-  const state = {
-    found: true,
-    active: row.active === true,
-    ...typeof row.activeAt === "number" ? { activeAt: row.activeAt } : {},
-    archivedAt: typeof row.archivedAt === "number" ? row.archivedAt : null,
-    ...typeof row.updatedAt === "number" ? { updatedAt: row.updatedAt } : {}
-  };
-  if (persisted && typeof row.metadata === "string" && row.metadata.length > 0) {
-    try {
-      const metadata = persistence.decrypt(persistence.decodeBase64(persisted.encryptionKey), persisted.encryptionVariant, persistence.decodeBase64(row.metadata));
-      if (metadata?.machineId) state.machineId = metadata.machineId;
-    } catch {
-    }
-  }
-  return state;
-}
-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 persistence.stopDaemonSession(sessionId);
-}
-async function archiveSession(sessionId) {
-  const token = await bearerToken$1();
-  await axios.post(
-    `${persistence.configuration.serverUrl}/v1/sessions/${encodeURIComponent(sessionId)}/archive`,
-    {},
-    {
-      headers: {
-        "Authorization": `Bearer ${token}`,
-        "X-Happy-Client": `${SESSION_OPS_CLIENT}/${persistence.configuration.currentCliVersion}`
-      },
-      timeout: 1e4
-    }
-  );
-}
-async function unarchiveSession(sessionId) {
-  const token = await bearerToken$1();
-  await axios.post(
-    `${persistence.configuration.serverUrl}/v1/sessions/${encodeURIComponent(sessionId)}/unarchive`,
-    {},
-    {
-      headers: {
-        "Authorization": `Bearer ${token}`,
-        "X-Happy-Client": `${SESSION_OPS_CLIENT}/${persistence.configuration.currentCliVersion}`
-      },
-      timeout: 1e4
-    }
-  );
-}
-
-const ACTIVE_FRESH_WINDOW_MS = 15 * 60 * 1e3;
-const DEFAULT_RESUME_WAIT_MS = 3e4;
-const DEFAULT_RESUME_POLL_MS = 1e3;
-function classifySessionState(input) {
-  const { liveHere, server, now } = input;
-  if (!server.found) return "not_found";
-  if (typeof server.archivedAt === "number") return "archived";
-  if (liveHere) return "live";
-  if (server.active && typeof server.activeAt === "number" && now - server.activeAt <= ACTIVE_FRESH_WINDOW_MS) return "live";
-  return "offline";
-}
-function explainNotLive(sessionId, status, resumeHint) {
-  switch (status) {
-    case "archived":
-      return `Session ${sessionId} is archived \u2014 no live wrapper will receive this message. ${resumeHint}`;
-    case "offline":
-      return `Session ${sessionId} is offline (its wrapper exited or timed out) \u2014 no live wrapper will receive this message. ${resumeHint}`;
-    case "not_found":
-      return `Session ${sessionId} was not found on this account \u2014 it cannot be messaged or resumed. Spawn a new session instead.`;
-  }
-}
-const CLI_RESUME_HINT = "Use --resume to bring it back on this machine, or spawn a new session.";
-const defaultDeps$1 = {
-  listLive: () => persistence.listDaemonSessions(),
-  readState: (sessionId, persisted) => readSessionState(sessionId, persisted),
-  send: (sessionId, persisted, text, client, options) => sendUserMessage(sessionId, persisted, text, client, options),
-  unarchive: unarchiveSession,
-  archive: archiveSession,
-  resume: persistence.resumeDaemonSession,
-  sleep: (ms) => persistence.delay(ms).then(() => void 0),
-  now: () => Date.now()
-};
-async function deliverToSession(sessionId, persisted, text, client, options = {}, deps = {}) {
-  const d = { ...defaultDeps$1, ...deps };
-  const resumeHint = options.resumeHint ?? CLI_RESUME_HINT;
-  const classify = async () => {
-    const [live, server] = await Promise.all([d.listLive(), d.readState(sessionId, persisted)]);
-    return classifySessionState({ liveHere: sessionLiveness(live, sessionId).live, server, now: d.now() });
-  };
-  let status = await classify();
-  let resumed = false;
-  let resumeOutcome;
-  if (status !== "live") {
-    if (!options.resume || status === "not_found") {
-      return { sessionId, status, delivered: false, resumed: false, stored: false, error: explainNotLive(sessionId, status, resumeHint) };
-    }
-    const wasArchived = status === "archived";
-    if (wasArchived) {
-      try {
-        await d.unarchive(sessionId);
-      } catch (error) {
-        const message = `unarchive failed: ${error instanceof Error ? error.message : String(error)}`;
-        return { sessionId, status, delivered: false, resumed: false, stored: false, error: message, resume: { ok: false, error: message } };
-      }
-    }
-    const outcome = await d.resume(sessionId, {
-      ...typeof options.model === "string" ? { model: options.model } : {},
-      ...options.permissionMode !== void 0 ? { permissionMode: options.permissionMode } : {}
-    });
-    if (!outcome.success) {
-      let message = outcome.error ?? "resume failed";
-      if (wasArchived) {
-        try {
-          await d.archive(sessionId);
-        } catch (error) {
-          message += `; failed to restore archive state: ${error instanceof Error ? error.message : String(error)}`;
-        }
-      }
-      return { sessionId, status, delivered: false, resumed: false, stored: false, error: message, resume: { ok: false, error: message } };
-    }
-    resumed = true;
-    resumeOutcome = { ok: true };
-    status = await waitUntilLive(classify, d, options);
-    if (status !== "live") {
-      const waited = Math.round((options.waitMs ?? DEFAULT_RESUME_WAIT_MS) / 1e3);
-      return {
-        sessionId,
-        status,
-        delivered: false,
-        resumed,
-        stored: false,
-        resume: resumeOutcome,
-        error: `Session ${sessionId} was resumed but no live wrapper showed up within ${waited}s (state: ${status}); message not sent`
-      };
-    }
-  }
-  await d.send(sessionId, persisted, text, client, {
-    ...options.model !== void 0 ? { model: options.model } : {},
-    ...options.sentFrom !== void 0 ? { sentFrom: options.sentFrom } : {}
-  });
-  let after = "live";
-  try {
-    after = await classify();
-  } catch {
-    after = "live";
-  }
-  if (after !== "live") {
-    return {
-      sessionId,
-      status: after,
-      delivered: false,
-      resumed,
-      stored: true,
-      ...resumeOutcome ? { resume: resumeOutcome } : {},
-      error: `Session ${sessionId} went ${after} while sending: the message is stored server-side but no wrapper is attached to read it. ${after === "not_found" ? "Spawn a new session." : resumeHint}`
-    };
-  }
-  return { sessionId, status: "live", delivered: true, resumed, stored: true, ...resumeOutcome ? { resume: resumeOutcome } : {} };
-}
-async function waitUntilLive(classify, d, options) {
-  const waitMs = options.waitMs ?? DEFAULT_RESUME_WAIT_MS;
-  const pollMs = options.pollMs ?? DEFAULT_RESUME_POLL_MS;
-  const deadline = d.now() + waitMs;
-  let status = await classify();
-  while (status !== "live" && d.now() < deadline) {
-    await d.sleep(pollMs);
-    status = await classify();
-  }
-  return status;
-}
-
-const SESSION_PEER_SENT_FROM = "session-peer";
-const CLI_PEER_SENDER_ID = "cli";
-const MESSAGE_FOOTER = "This message comes from another agent session on this machine, not from the user.";
-const MESSAGE_FOOTER_PREFIX = "This message comes from another agent session";
-function messageFooterFor(sender) {
-  return sender.machine ? `${MESSAGE_FOOTER_PREFIX} on machine ${sanitizeHeaderValue(sender.machine, 128)}, not from the user.` : MESSAGE_FOOTER;
-}
-function sanitizeHeaderValue(value, max = 200) {
-  if (!value) return "";
-  const collapsed = value.replace(/\s+/g, " ").trim().slice(0, max);
-  return collapsed.replace(/[%"\];]/g, (ch) => `%${ch.charCodeAt(0).toString(16).toUpperCase().padStart(2, "0")}`);
-}
-function senderFields(sender) {
-  const parts = [];
-  if (sender.flavor) parts.push(`agent ${sanitizeHeaderValue(sender.flavor, 32)}`);
-  if (sender.cwd) parts.push(`cwd ${sanitizeHeaderValue(sender.cwd, 400)}`);
-  if (sender.machine) parts.push(`machine ${sanitizeHeaderValue(sender.machine, 128)}`);
-  return parts.map((part) => `; ${part}`).join("");
-}
-function quotedTitle(sender) {
-  return `"${sanitizeHeaderValue(sender.title, 120)}"`;
-}
-function formatSessionPeerMessage(input) {
-  const header = `[Very Happy session message ${input.id} from ${quotedTitle(input.from)} ${input.from.sessionId}${senderFields(input.from)}${input.replyTo ? `; re ${sanitizeHeaderValue(input.replyTo, 64)}` : ""}]`;
-  const base = messageFooterFor(input.from);
-  const routed = input.from.machine ? " (it is routed to that machine for you)" : "";
-  const footer = input.from.sessionId === CLI_PEER_SENDER_ID ? `${base} It was sent from the command line (\`very-happy sessions message\`), so there is no session to reply to; act on it here.` : `${base} Reply with session_message(to: "${input.from.sessionId}")${routed} \u2014 or \`very-happy sessions message ${input.from.sessionId} "<text>"\` \u2014 only when you have something to add (a question, a decision, a heads-up). Do not reply just to acknowledge or thank; the exchange ends when nothing is left to coordinate.`;
-  return `${header}
-${input.body.trim()}
-
-${footer}`;
-}
-function formatDuration(ms) {
-  const seconds = Math.max(0, Math.round(ms / 1e3));
-  if (seconds < 90) return `${seconds}s`;
-  const minutes = Math.round(seconds / 60);
-  if (minutes < 90) return `${minutes}m`;
-  return `${Math.round(minutes / 60)}h`;
-}
-function formatEditConflictNotice(input) {
-  const paths = input.paths && input.paths.length > 0 ? input.paths : [input.path];
-  const more = paths.length - 1;
-  const header = `[Very Happy edit conflict ${input.id}; file ${sanitizeHeaderValue(paths[0], 600)}${more > 0 ? `; more ${more}` : ""}; peer ${quotedTitle(input.peer)} ${input.peer.sessionId}${senderFields(input.peer)}; peer edited ${formatDuration(input.peerEditedAgoMs)} ago]`;
-  const window = formatDuration(input.windowMs);
-  const mirror = input.peer.flavor === "terminal-mirror";
-  const what = more > 0 ? `the same ${paths.length} files` : "the same file";
-  const advice = mirror ? `The peer is a terminal session (agent terminal-mirror): it cannot be messaged, and the person at that terminal owns those edits \u2014 re-read the file before changing it further and keep your change minimal.` : `No lock is held \u2014 coordinate before continuing: session_message(to: "${input.peer.sessionId}", body: "\u2026") saying what you are changing in ${more > 0 ? "these files" : "that file"} and asking what they are changing. One message that covers everything; do not send one per file.`;
-  const list = more > 0 ? `
-Files:
-${paths.map((p) => `- ${p}`).join("\n")}` : "";
-  return `${header}
-Another session on this machine edited ${what} within the last ${window}. Both sessions received this notice. ${advice}${list}`;
-}
-
-const realFs = {
-  existsSync: node_fs.existsSync,
-  isDirectory: (path) => {
-    try {
-      return node_fs.statSync(path).isDirectory();
-    } catch {
-      return false;
-    }
-  },
-  readFileSync: (path) => node_fs.readFileSync(path, "utf8")
-};
-function resolveRepoIdentity(cwd, fs = realFs) {
-  let dir = path.resolve(cwd);
-  for (let depth = 0; depth < 64; depth++) {
-    const dotGit = path.resolve(dir, ".git");
-    try {
-      if (fs.existsSync(dotGit)) {
-        if (fs.isDirectory(dotGit)) return { root: dir, common: dotGit };
-        const gitdir = fs.readFileSync(dotGit).match(/^gitdir:\s*(.+?)\s*$/m)?.[1];
-        if (gitdir) {
-          const absolute = path.isAbsolute(gitdir) ? gitdir : path.resolve(dir, gitdir);
-          const worktree = absolute.match(/^(.*[\\/]\.git)[\\/]worktrees[\\/][^\\/]+[\\/]?$/);
-          return { root: dir, common: worktree ? worktree[1] : absolute };
-        }
-        return { root: dir, common: dotGit };
-      }
-    } catch {
-    }
-    const parent = path.dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return { root: null, common: null };
-}
-const PEER_SCOPES$1 = ["repo", "cwd", "machine"];
-function isPeerInScope(scope, self, other) {
-  if (scope === "machine") return true;
-  if (scope === "cwd") return path.resolve(self.cwd) === path.resolve(other.cwd);
-  if (self.repo.common && other.repo.common) return self.repo.common === other.repo.common;
-  return path.resolve(self.cwd) === path.resolve(other.cwd);
-}
-
-const REMOTE_SESSION_OPS_MIN_CLI_VERSION = "0.2.157";
-const REMOTE_OPS_PROTOCOL_VERSION = 1;
-const REMOTE_TEXT_MAX_BYTES = 64 * 1024;
-const REMOTE_TRANSCRIPT_MAX_BYTES = 200 * 1024;
-const REMOTE_CALLS_PER_MINUTE = 60;
-const REMOTE_WRITE_CALLS_PER_MINUTE = 30;
-const REMOTE_LOCATE_MAX_IDS = 200;
-const REMOTE_OP_DEADLINE_MS = 25e3;
-const REMOTE_SEND_COMMIT_DEADLINE_MS = 18e3;
-const REMOTE_RESUME_WAIT_MS = 1e4;
-const REMOTE_WAIT_POLL_MS = 5e3;
-const REMOTE_ANSWER_MAX_BYTES = 64 * 1024;
-const REMOTE_TITLE_MAX_BYTES = 1024;
-const REMOTE_SENT_FROM_ALLOWED = ["cli", "assistant", "automation"];
-const LOCAL_ID_RE = /^[a-zA-Z0-9_.:-]{1,128}$/;
-function remoteError(code, message) {
-  return { ok: false, error: { code, message } };
-}
-const SESSION_ID_RE = /^[a-zA-Z0-9_-]{1,128}$/;
-const PEER_SCOPES = ["repo", "cwd", "machine"];
-function isSessionId(value) {
-  return typeof value === "string" && SESSION_ID_RE.test(value);
-}
-function utf8Bytes(text) {
-  return Buffer.byteLength(text, "utf8");
-}
-function sanitizeSender(raw) {
-  if (!raw || typeof raw !== "object") return null;
-  const r = raw;
-  if (typeof r.sessionId !== "string" || r.sessionId.length === 0 || r.sessionId.length > 128) return null;
-  const optional = (key, max) => typeof r[key] === "string" && r[key].length > 0 ? { [key]: r[key].slice(0, max) } : {};
-  return {
-    sessionId: r.sessionId,
-    ...optional("title", 200),
-    ...optional("flavor", 32),
-    ...optional("cwd", 1024),
-    ...optional("machine", 128)
-  };
-}
-function guardRemoteSessionOpsRequest(method, raw, options) {
-  if (!options.enabled) {
-    return remoteError("disabled", 'Remote session operations are turned off on this machine (settings.json remoteSessionOps = "off")');
-  }
-  if (!raw || typeof raw !== "object") return remoteError("bad_request", "Request must be an object");
-  const r = raw;
-  if (r.v !== REMOTE_OPS_PROTOCOL_VERSION) return remoteError("bad_request", `Unsupported protocol version ${String(r.v)} (this daemon speaks v${REMOTE_OPS_PROTOCOL_VERSION})`);
-  const from = r.from;
-  if (!from || typeof from !== "object" || typeof from.host !== "string" || from.host.length === 0 || typeof from.cli !== "string") {
-    return remoteError("bad_request", "from.host and from.cli are required");
-  }
-  const caller = {
-    host: from.host.slice(0, 128),
-    cli: from.cli.slice(0, 32),
-    ...typeof from.machineId === "string" && from.machineId.length > 0 ? { machineId: from.machineId.slice(0, 128) } : {},
-    ...isSessionId(from.sessionId) ? { sessionId: from.sessionId } : {}
-  };
-  const args = r.args && typeof r.args === "object" ? r.args : {};
-  const limit = typeof args.limit === "number" && Number.isFinite(args.limit) && args.limit >= 1 ? Math.floor(args.limit) : void 0;
-  let clean;
-  switch (method) {
-    case "sessions.list": {
-      if (args.ids !== void 0) {
-        if (!Array.isArray(args.ids) || !args.ids.every(isSessionId)) return remoteError("bad_request", "ids must be an array of session ids");
-        if (args.ids.length > REMOTE_LOCATE_MAX_IDS) return remoteError("too_large", `ids: at most ${REMOTE_LOCATE_MAX_IDS} per call`);
-      }
-      const out = {
-        ...args.ids !== void 0 ? { ids: args.ids } : {},
-        ...args.all === true ? { all: true } : {},
-        ...typeof args.tag === "string" && args.tag.length > 0 ? { tag: args.tag.slice(0, 128) } : {},
-        ...limit !== void 0 ? { limit } : {}
-      };
-      clean = out;
-      break;
-    }
-    case "sessions.read": {
-      if (!isSessionId(args.sessionId)) return remoteError("bad_request", "sessionId is required");
-      const out = { sessionId: args.sessionId, ...limit !== void 0 ? { limit } : {}, ...args.full === true ? { full: true } : {} };
-      clean = out;
-      break;
-    }
-    case "sessions.send": {
-      if (!isSessionId(args.sessionId)) return remoteError("bad_request", "sessionId is required");
-      if (typeof args.text !== "string" || args.text.trim().length === 0) return remoteError("bad_request", "text must be non-empty");
-      if (utf8Bytes(args.text) > REMOTE_TEXT_MAX_BYTES) return remoteError("too_large", `text exceeds ${REMOTE_TEXT_MAX_BYTES} bytes`);
-      if (args.localId !== void 0 && (typeof args.localId !== "string" || !LOCAL_ID_RE.test(args.localId))) return remoteError("bad_request", "localId must be a short id");
-      const out = {
-        sessionId: args.sessionId,
-        text: args.text,
-        ...args.resume === true ? { resume: true } : {},
-        ...args.model === null || typeof args.model === "string" && args.model.length <= 128 ? { model: args.model } : {},
-        ...REMOTE_SENT_FROM_ALLOWED.includes(args.sentFrom) ? { sentFrom: args.sentFrom } : {},
-        ...typeof args.localId === "string" ? { localId: args.localId } : {}
-      };
-      clean = out;
-      break;
-    }
-    case "sessions.peers": {
-      if (args.scope !== void 0 && !PEER_SCOPES.includes(args.scope)) return remoteError("bad_request", `scope must be one of ${PEER_SCOPES.join(", ")}`);
-      const out = {
-        ...args.scope !== void 0 ? { scope: args.scope } : {},
-        ...typeof args.cwd === "string" && args.cwd.length > 0 ? { cwd: args.cwd.slice(0, 4096) } : {}
-      };
-      clean = out;
-      break;
-    }
-    case "sessions.message": {
-      if (!isSessionId(args.to)) return remoteError("bad_request", "to is required");
-      if (typeof args.body !== "string" || args.body.trim().length === 0) return remoteError("bad_request", "body must be non-empty");
-      if (utf8Bytes(args.body) > REMOTE_TEXT_MAX_BYTES) return remoteError("too_large", `body exceeds ${REMOTE_TEXT_MAX_BYTES} bytes`);
-      const sender = sanitizeSender(args.from);
-      if (!sender) return remoteError("bad_request", "from.sessionId (the sender) is required");
-      const out = {
-        to: args.to,
-        body: args.body,
-        ...typeof args.replyTo === "string" && args.replyTo.length > 0 ? { replyTo: args.replyTo.slice(0, 64) } : {},
-        // The recipient's header names the machine the call came
-        // from, as the caller identified itself — never a value the
-        // sender picked for someone else.
-        from: { ...sender, machine: caller.host }
-      };
-      clean = out;
-      break;
-    }
-  }
-  return { ok: true, request: { v: REMOTE_OPS_PROTOCOL_VERSION, from: caller, args: clean } };
-}
-class RemoteCallBudget {
-  constructor(perMinute = REMOTE_CALLS_PER_MINUTE, now = Date.now) {
-    this.perMinute = perMinute;
-    this.now = now;
-    this.tokens = perMinute;
-    this.lastRefill = now();
-  }
-  tokens;
-  lastRefill;
-  /** Take one token; false = over budget (with ms until the next token). */
-  take() {
-    if (this.perMinute <= 0) return { ok: true };
-    const t = this.now();
-    const refill = (t - this.lastRefill) / 6e4 * this.perMinute;
-    if (refill > 0) {
-      this.tokens = Math.min(this.perMinute, this.tokens + refill);
-      this.lastRefill = t;
-    }
-    if (this.tokens >= 1) {
-      this.tokens -= 1;
-      return { ok: true };
-    }
-    return { ok: false, retryAfterMs: Math.ceil((1 - this.tokens) / this.perMinute * 6e4) };
-  }
-}
-function sanitizeAuditValue(value, max = 64) {
-  if (typeof value !== "string" || value.length === 0) return "?";
-  return value.slice(0, max).replace(/[^\x20-\x7e]/g, "?");
-}
-function formatRemoteAuditLine(input) {
-  const from = input.from;
-  const opt = (value) => value === void 0 ? "-" : sanitizeAuditValue(value);
-  return `[REMOTE SESSION OPS] ${sanitizeAuditValue(input.method)} from machine=${sanitizeAuditValue(from?.machineId)} host=${sanitizeAuditValue(from?.host)} cli=${sanitizeAuditValue(from?.cli, 32)} session=${opt(from?.sessionId)} target=${opt(input.sessionId)} \u2192 ${input.outcome} (${Math.max(0, Math.round(input.durationMs))}ms)`;
-}
-function capRemoteText(text, maxBytes, keep = "head") {
-  if (utf8Bytes(text) <= maxBytes) return text;
-  const buffer = Buffer.from(text, "utf8");
-  const marker = "\u2026";
-  const room = Math.max(0, maxBytes - Buffer.byteLength(marker));
-  const slice = keep === "head" ? buffer.subarray(0, room) : buffer.subarray(buffer.length - room);
-  const clean = slice.toString("utf8").replace(/^�+|�+$/g, "");
-  return keep === "head" ? clean + marker : marker + clean;
-}
-function capRemoteTranscript(transcript, maxBytes = REMOTE_TRANSCRIPT_MAX_BYTES) {
-  if (utf8Bytes(transcript) <= maxBytes) return { transcript, truncated: false };
-  const buffer = Buffer.from(transcript, "utf8");
-  const marker = "\u2026 [truncated by the remote machine: transcript exceeded the RPC budget; use --limit] \u2026\n";
-  const tail = buffer.subarray(buffer.length - (maxBytes - Buffer.byteLength(marker))).toString("utf8");
-  return { transcript: marker + tail.replace(/^�+/, ""), truncated: true };
-}
-function parseHappyClientVersion(value) {
-  if (typeof value !== "string") return null;
-  const match = value.match(/(\d+)\.(\d+)\.(\d+)/);
-  return match ? `${match[1]}.${match[2]}.${match[3]}` : null;
-}
-function compareVersions(a, b) {
-  const pa = a.split(".").map((n) => Number.parseInt(n, 10) || 0);
-  const pb = b.split(".").map((n) => Number.parseInt(n, 10) || 0);
-  for (let i = 0; i < 3; i++) {
-    const d = (pa[i] ?? 0) - (pb[i] ?? 0);
-    if (d !== 0) return d;
-  }
-  return 0;
-}
-function supportsRemoteSessionOps(cliVersion) {
-  if (!cliVersion) return null;
-  return compareVersions(cliVersion, REMOTE_SESSION_OPS_MIN_CLI_VERSION) >= 0;
-}
-
-const REMOTE_CLIENT_TAG = "session-ops";
-const REMOTE_RPC_TIMEOUT_MS = 3e4;
-const REMOTE_LOCATE_MAX_MACHINES = 8;
-class RemoteSessionOpsError extends Error {
-  constructor(code, message, machineId, ambiguous = false) {
-    super(message);
-    this.code = code;
-    this.machineId = machineId;
-    this.ambiguous = ambiguous;
-  }
-}
-async function bearerToken() {
-  const credentials = await persistence.readCredentialsForConfiguredRelay();
-  if (!credentials) throw new Error("CLI is not authenticated (no ~/.happy/access.key)");
-  return credentials.token;
-}
-async function listAccountMachines() {
-  const token = await bearerToken();
-  const response = await axios.get(`${persistence.configuration.serverUrl}/v1/machines`, {
-    headers: { "Authorization": `Bearer ${token}`, "X-Happy-Client": `${REMOTE_CLIENT_TAG}/${persistence.configuration.currentCliVersion}` },
-    timeout: 15e3
-  });
-  const rows = Array.isArray(response.data) ? response.data : [];
-  return rows.filter((row) => !!row && typeof row === "object" && typeof row.id === "string").map((row) => ({
-    id: row.id,
-    active: row.active === true,
-    ...typeof row.activeAt === "number" ? { activeAt: row.activeAt } : {},
-    cliVersion: parseHappyClientVersion(row.lastHappyClient)
-  }));
-}
-async function callerIdentity(env = process.env) {
-  const settings = await persistence.readSettings().catch(() => null);
-  const sessionId = env.VH_PEER_SESSION_ID;
-  return {
-    ...settings?.machineId ? { machineId: settings.machineId } : {},
-    host: os.hostname(),
-    cli: persistence.configuration.currentCliVersion,
-    ...sessionId && /^[a-zA-Z0-9_-]{1,128}$/.test(sessionId) ? { sessionId } : {}
-  };
-}
-const defaultDeps = {
-  listMachines: listAccountMachines,
-  selfMachineId: async () => (await persistence.readSettings().catch(() => null))?.machineId,
-  openTransport: async () => {
-    const socket = await openUserScopedSocket(await bearerToken());
-    return {
-      call: (method, paramsJson) => socket.rpcCall({ method, params: paramsJson }, REMOTE_RPC_TIMEOUT_MS),
-      close: () => socket.close()
-    };
-  },
-  caller: () => callerIdentity(),
-  sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
-  now: () => Date.now()
-};
-function withDefaults(deps) {
-  return { ...defaultDeps, ...deps };
-}
-function pickRemoteCandidates(machines, selfId) {
-  const candidates = [];
-  const skipped = [];
-  for (const machine of machines) {
-    if (selfId && machine.id === selfId) {
-      skipped.push({ machine, reason: "self" });
-      continue;
-    }
-    if (!machine.active) {
-      skipped.push({ machine, reason: "offline" });
-      continue;
-    }
-    if (supportsRemoteSessionOps(machine.cliVersion) === false) {
-      skipped.push({ machine, reason: "too_old" });
-      continue;
-    }
-    candidates.push(machine);
-  }
-  candidates.sort((a, b) => (b.activeAt ?? 0) - (a.activeAt ?? 0));
-  return { candidates: candidates.slice(0, REMOTE_LOCATE_MAX_MACHINES), skipped };
-}
-function describeAge(activeAt, now) {
-  if (activeAt === void 0) return "never seen";
-  const minutes = Math.round((now - activeAt) / 6e4);
-  if (minutes < 2) return "seen just now";
-  if (minutes < 120) return `last seen ${minutes}m ago`;
-  if (minutes < 48 * 60) return `last seen ${Math.round(minutes / 60)}h ago`;
-  return `last seen ${Math.round(minutes / 1440)}d ago`;
-}
-async function resolveExplicitMachine(machineId, deps) {
-  const machines = await deps.listMachines();
-  const machine = machines.find((row) => row.id === machineId);
-  if (!machine) throw new RemoteSessionOpsError("unknown_machine", `Machine ${machineId} is not on this account`, machineId);
-  if (!machine.active) throw new RemoteSessionOpsError("offline", `Machine ${machineId} is offline (${describeAge(machine.activeAt, deps.now())}); its sessions cannot be reached until its daemon reconnects`, machineId);
-  if (supportsRemoteSessionOps(machine.cliVersion) === false) {
-    throw new RemoteSessionOpsError("too_old", `Machine ${machineId} runs CLI ${machine.cliVersion}; cross-machine session operations need \u2265 ${REMOTE_SESSION_OPS_MIN_CLI_VERSION} on the target`, machineId);
-  }
-  return machine;
-}
-async function callRemoteSessionOp(transport, machineId, method, args, from) {
-  const params = JSON.stringify({ v: REMOTE_OPS_PROTOCOL_VERSION, from, args });
-  let ack;
-  try {
-    ack = await transport.call(`${machineId}:${method}`, params);
-  } catch (error) {
-    const reason = error instanceof Error ? error.message : String(error);
-    throw new RemoteSessionOpsError("unreachable", `Machine ${machineId} did not answer ${method} (${reason})`, machineId, true);
-  }
-  if (!ack?.ok) {
-    const reason = ack?.error ?? "no ack";
-    if (/not available/i.test(reason)) {
-      throw new RemoteSessionOpsError("unreachable", `Machine ${machineId} did not answer ${method}: its daemon is offline, restarting, or runs a CLI older than ${REMOTE_SESSION_OPS_MIN_CLI_VERSION}`, machineId);
-    }
-    throw new RemoteSessionOpsError("unreachable", `Machine ${machineId}: ${reason}`, machineId, true);
-  }
-  let envelope;
-  try {
-    envelope = typeof ack.result === "string" ? JSON.parse(ack.result) : ack.result;
-  } catch {
-    throw new RemoteSessionOpsError("unreachable", `Machine ${machineId} returned an unreadable ${method} response`, machineId);
-  }
-  if (!envelope || typeof envelope !== "object") throw new RemoteSessionOpsError("unreachable", `Machine ${machineId} returned an empty ${method} response`, machineId);
-  if ("ok" in envelope) {
-    if (envelope.ok) return envelope.result;
-    throw new RemoteSessionOpsError(envelope.error.code, `Machine ${machineId}: ${envelope.error.message}`, machineId);
-  }
-  throw new RemoteSessionOpsError("internal", `Machine ${machineId}: ${envelope.error ?? "remote handler failed"}`, machineId);
-}
-async function locateRemoteSession(transport, sessionId, options, deps) {
-  const from = await deps.caller();
-  if (options.machineId) {
-    const machine = await resolveExplicitMachine(options.machineId, deps);
-    const listing = await callRemoteSessionOp(transport, machine.id, "sessions.list", { ids: [sessionId] }, from);
-    if (!listing.sessions.some((row) => row.id === sessionId)) {
-      throw new RemoteSessionOpsError("no_local_key", `Machine ${machine.id} (${listing.host}) has no key for session ${sessionId}: it was not spawned there (or is older than 14 days)`, machine.id);
-    }
-    return { machine, host: listing.host };
-  }
-  const { candidates, skipped } = pickRemoteCandidates(await deps.listMachines(), await deps.selfMachineId());
-  const failures = [];
-  for (const machine of candidates) {
-    try {
-      const listing = await callRemoteSessionOp(transport, machine.id, "sessions.list", { ids: [sessionId] }, from);
-      if (listing.sessions.some((row) => row.id === sessionId)) return { machine, host: listing.host };
-      failures.push(`${listing.host || machine.id}: not there`);
-    } catch (error) {
-      failures.push(`${machine.id}: ${error instanceof RemoteSessionOpsError ? error.code : error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-  const skippedText = skipped.filter((s) => s.reason !== "self").map((s) => `${s.machine.id}: ${s.reason}`);
-  const detail = [...failures, ...skippedText];
-  throw new RemoteSessionOpsError(
-    "not_located",
-    `Session ${sessionId} is not on this machine and no online machine of this account reports it${detail.length ? ` (${detail.join("; ")})` : " (no other machines are online)"}. Pass --machine <id> to name one, or bring its machine online.`
-  );
-}
-async function withRemoteTransport(deps, fn) {
-  const transport = await deps.openTransport();
-  try {
-    return await fn(transport);
-  } finally {
-    try {
-      transport.close();
-    } catch {
-    }
-  }
-}
-async function readRemoteTranscript(sessionId, options = {}, overrides = {}) {
-  const deps = withDefaults(overrides);
-  return withRemoteTransport(deps, async (transport) => {
-    const located = await locateRemoteSession(transport, sessionId, { machineId: options.machineId }, deps);
-    return callRemoteSessionOp(transport, located.machine.id, "sessions.read", {
-      sessionId,
-      ...options.limit !== void 0 ? { limit: options.limit } : {},
-      ...options.full ? { full: true } : {}
-    }, await deps.caller());
-  });
-}
-async function waitForRemoteTurnEnd(sessionId, options, overrides = {}) {
-  const deps = withDefaults(overrides);
-  const pollMs = options.pollMs ?? REMOTE_WAIT_POLL_MS;
-  return withRemoteTransport(deps, async (transport) => {
-    const located = await locateRemoteSession(transport, sessionId, { machineId: options.machineId }, deps);
-    const from = await deps.caller();
-    const deadline = deps.now() + options.timeoutMs;
-    const args = { sessionId, ...options.limit !== void 0 ? { limit: options.limit } : {}, ...options.full ? { full: true } : {} };
-    while (true) {
-      const read = await callRemoteSessionOp(transport, located.machine.id, "sessions.read", args, from);
-      if (read.turn.ended) return { read, timedOut: false };
-      if (deps.now() + pollMs > deadline) return { read, timedOut: true };
-      await deps.sleep(pollMs);
-    }
-  });
-}
-async function sendRemoteMessage(sessionId, text, options = {}, overrides = {}) {
-  const deps = withDefaults(overrides);
-  return withRemoteTransport(deps, async (transport) => {
-    const located = await locateRemoteSession(transport, sessionId, { machineId: options.machineId }, deps);
-    const from = await deps.caller();
-    const localId = options.localId ?? `remote-send-${node_crypto.randomUUID()}`;
-    const args = {
-      sessionId,
-      text,
-      localId,
-      ...options.resume ? { resume: true } : {},
-      ...options.model !== void 0 ? { model: options.model } : {},
-      ...options.sentFrom !== void 0 ? { sentFrom: options.sentFrom } : {}
-    };
-    const attempt = () => callRemoteSessionOp(transport, located.machine.id, "sessions.send", args, from);
-    let result;
-    try {
-      result = await attempt();
-    } catch (error) {
-      const retryable = error instanceof RemoteSessionOpsError && (error.ambiguous || error.code === "timeout");
-      if (!retryable) throw error;
-      result = await attempt();
-    }
-    return { ...result, machine: { id: located.machine.id, host: located.host } };
-  });
-}
-async function sendRemotePeerMessage(args, options = {}, overrides = {}) {
-  const deps = withDefaults(overrides);
-  return withRemoteTransport(deps, async (transport) => {
-    const located = await locateRemoteSession(transport, args.to, { machineId: options.machineId }, deps);
-    const caller = await deps.caller();
-    const result = await callRemoteSessionOp(transport, located.machine.id, "sessions.message", {
-      to: args.to,
-      body: args.body,
-      ...args.replyTo ? { replyTo: args.replyTo } : {},
-      from: { ...args.from, machine: args.from.machine ?? caller.host }
-    }, caller);
-    return { ...result, machine: { id: located.machine.id, host: located.host } };
-  });
-}
-async function listRemotePeers(machineId, options = {}, overrides = {}) {
-  const deps = withDefaults(overrides);
-  return withRemoteTransport(deps, async (transport) => {
-    const machine = await resolveExplicitMachine(machineId, deps);
-    return callRemoteSessionOp(transport, machine.id, "sessions.peers", {
-      ...options.scope ? { scope: options.scope } : {},
-      ...options.cwd ? { cwd: options.cwd } : {}
-    }, await deps.caller());
-  });
-}
-async function listRemoteSessions(machineId, options = {}, overrides = {}) {
-  const deps = withDefaults(overrides);
-  return withRemoteTransport(deps, async (transport) => {
-    const machine = await resolveExplicitMachine(machineId, deps);
-    return callRemoteSessionOp(transport, machine.id, "sessions.list", {
-      ...options.tag ? { tag: options.tag } : {},
-      ...options.limit !== void 0 ? { limit: options.limit } : {}
-    }, await deps.caller());
-  });
-}
-async function fillForeignAccountRows(rows, overrides = {}) {
-  const deps = withDefaults(overrides);
-  const pending = new Set(rows.filter((row) => !row.decryptable).map((row) => row.id));
-  const asked = [];
-  if (pending.size === 0) return { rows, asked, skipped: [] };
-  const { candidates, skipped } = pickRemoteCandidates(await deps.listMachines(), await deps.selfMachineId());
-  const filled = /* @__PURE__ */ new Map();
-  if (candidates.length > 0) {
-    await withRemoteTransport(deps, async (transport) => {
-      const from = await deps.caller();
-      for (const machine of candidates) {
-        if (pending.size === 0) break;
-        try {
-          const listing = await callRemoteSessionOp(transport, machine.id, "sessions.list", { ids: [...pending], all: true }, from);
-          let count = 0;
-          for (const row of listing.sessions) {
-            if (!pending.has(row.id)) continue;
-            pending.delete(row.id);
-            count++;
-            filled.set(row.id, { ...row, decryptable: false, readable: true, via: machine.id, machine: { id: machine.id, host: listing.host } });
-          }
-          asked.push({ machineId: machine.id, host: listing.host, filled: count });
-        } catch (error) {
-          asked.push({ machineId: machine.id, filled: 0, error: error instanceof Error ? error.message : String(error) });
-        }
-      }
-    });
-  }
-  return {
-    rows: rows.map((row) => filled.get(row.id) ?? row),
-    asked,
-    skipped: skipped.filter((s) => s.reason !== "self").map((s) => ({ machineId: s.machine.id, reason: s.reason }))
-  };
-}
-
-const SESSION_PEER_TOOL_NAMES = ["session_message", "session_peers"];
-const SESSION_PEER_TOOL_SCHEMAS = {
-  session_message: {
-    title: "Message Another Session",
-    readOnly: false,
-    description: "Send a message to another agent session (find ids with session_peers). It lands in that session's chat with your title, session id and cwd, and tells the peer how to reply to you. Use it to coordinate when you both edit the same files: say what you are changing and ask what they are changing. Returns as soon as the message is queued; the reply arrives later as a message from that session. Sessions on this machine are reached directly; a session spawned by another machine of this account is routed to that machine's daemon (it must be online). Terminal-mirror sessions cannot receive messages.",
-    inputSchema: {
-      to: z.z.string().min(1).max(128).describe("Target session id (from session_peers, or a peer's message header)"),
-      body: z.z.string().min(1).max(16e3).describe("The message text"),
-      replyTo: z.z.string().min(1).max(64).optional().describe("Id of the peer message you are answering (from its header), if any"),
-      machineId: z.z.string().min(1).max(128).optional().describe("Machine id the target session runs on, when known (skips the lookup across the account's machines)")
-    }
-  },
-  session_peers: {
-    title: "List Peer Sessions",
-    readOnly: true,
-    description: 'List the other agent sessions running on this machine and the files each edited in the last 30 minutes. Default scope "repo": sessions in the same git repository, including its other worktrees (sameWorktree says whether they share your checkout). "cwd": the same directory only. "machine": every live session here. With machineId, list the live sessions on that other machine of this account instead (scope "machine" unless you pass a cwd that exists there).',
-    inputSchema: {
-      scope: z.z.enum(["repo", "cwd", "machine"]).optional().describe("repo (default) | cwd | machine"),
-      machineId: z.z.string().min(1).max(128).optional().describe("Another machine of this account (from the web's machine list) to list instead of this one"),
-      cwd: z.z.string().min(1).max(4096).optional().describe("With machineId: a directory on that machine to compute repo/cwd scope from")
-    }
-  }
-};
-const PEER_MESSAGE_RATE_LIMIT = 8;
-const PEER_MESSAGE_RATE_WINDOW_MS = 10 * 6e4;
-async function listPeerSessions(context, scope = "repo") {
-  const self = context.self();
-  const repoOf = context.repoOf ?? resolveRepoIdentity;
-  const selfRepo = repoOf(self.cwd);
-  const sessions = await (context.listPeers ?? persistence.listDaemonPeers)();
-  const peers = sessions.filter((session) => session.sessionId !== self.sessionId).filter((session) => {
-    const cwd = session.cwd ?? "";
-    if (!cwd) return scope === "machine";
-    return isPeerInScope(scope, { cwd: self.cwd, repo: selfRepo }, { cwd, repo: repoOf(cwd) });
-  }).map((session) => ({
-    ...session,
-    url: sessionWebUrl(session.sessionId),
-    sameWorktree: !!session.cwd && !!selfRepo.root && repoOf(session.cwd).root === selfRepo.root
-  }));
-  return { self: { sessionId: self.sessionId, cwd: self.cwd, repoRoot: selfRepo.root, scope }, scope, peers };
-}
-function defaultDeliver(to, persisted, text, localId) {
-  return deliverToSession(to, persisted, text, "session-message", {
-    sentFrom: SESSION_PEER_SENT_FROM,
-    resumeHint: "It has to be running to read a peer message; spawn a new session or ask the person."
-  }, {
-    send: (sessionId, key, body, client, options) => sendUserMessage(sessionId, key, body, client, { ...options, localId })
-  });
-}
-function checkPeerSendBudget(sentTo, to, now, limit = PEER_MESSAGE_RATE_LIMIT, windowMs = PEER_MESSAGE_RATE_WINDOW_MS) {
-  const recent = (sentTo.get(to) ?? []).filter((t) => now - t <= windowMs);
-  sentTo.set(to, recent);
-  return { ok: recent.length < limit, count: recent.length };
-}
-async function sendPeerMessage(context, args) {
-  const self = context.self();
-  if (!persistence.isValidSessionId(args.to)) throw new Error("Invalid session id");
-  if (args.to === self.sessionId) throw new Error("That is this session; message a peer instead");
-  const body = typeof args.body === "string" ? args.body.trim() : "";
-  if (!body) throw new Error("body must be non-empty");
-  const now = (context.now ?? Date.now)();
-  const persisted = (context.readPersisted ?? persistence.readPersistedSessions)()[args.to];
-  if (!persisted || args.machineId) {
-    const remote = context.remoteMessage === void 0 ? sendRemotePeerMessage : context.remoteMessage;
-    if (remote === null) {
-      throw new Error(`Session ${args.to} is not on this machine (no local key)`);
-    }
-    if (context.sentTo) {
-      const budget = checkPeerSendBudget(context.sentTo, args.to, now);
-      if (!budget.ok) throw new Error(replyLoopRefusal(budget.count, args.to));
-    }
-    const result2 = await remote({ to: args.to, body, replyTo: args.replyTo, from: self, machineId: args.machineId });
-    context.sentTo?.get(args.to)?.push(now);
-    return result2;
-  }
-  const live = (await (context.listPeers ?? persistence.listDaemonPeers)()).find((session) => session.sessionId === args.to);
-  if (!live) throw new Error(`Session ${args.to} is not running on this machine; nothing would read the message`);
-  if (live.kind === "mirror") throw new Error(`Session ${args.to} is a terminal mirror (a person typing claude in a terminal); it cannot receive messages`);
-  if (context.sentTo) {
-    const budget = checkPeerSendBudget(context.sentTo, args.to, now);
-    if (!budget.ok) throw new Error(replyLoopRefusal(budget.count, args.to));
-  }
-  const messageId = node_crypto.randomUUID().slice(0, 8);
-  const text = formatSessionPeerMessage({ id: messageId, from: self, body, replyTo: args.replyTo });
-  const result = await (context.deliver ?? defaultDeliver)(args.to, persisted, text, `session-message-${messageId}`);
-  context.sentTo?.get(args.to)?.push(now);
-  return {
-    delivered: result.delivered,
-    stored: result.stored,
-    status: result.status,
-    messageId,
-    to: args.to,
-    url: sessionWebUrl(args.to),
-    ...result.error ? { error: result.error } : {}
-  };
-}
-function replyLoopRefusal(count, to) {
-  return `Refused: this session already sent ${count} messages to ${to} in the last ${Math.round(PEER_MESSAGE_RATE_WINDOW_MS / 6e4)} minutes. That is a reply loop, not coordination \u2014 STOP replying to that session now; do not send acknowledgements or thanks. Continue your own work.`;
-}
-async function executeSessionPeerTool(name, args, context) {
-  switch (name) {
-    case "session_message":
-      return sendPeerMessage(context, {
-        to: String(args?.to ?? ""),
-        body: String(args?.body ?? ""),
-        ...args?.replyTo ? { replyTo: String(args.replyTo) } : {},
-        ...args?.machineId ? { machineId: String(args.machineId) } : {}
-      });
-    case "session_peers": {
-      const scope = args?.scope;
-      if (scope !== void 0 && !PEER_SCOPES$1.includes(scope)) throw new Error(`scope must be one of ${PEER_SCOPES$1.join(", ")}`);
-      if (args?.machineId) {
-        return (context.remotePeers ?? listRemotePeers)(String(args.machineId), {
-          ...scope !== void 0 ? { scope } : {},
-          ...typeof args.cwd === "string" && args.cwd ? { cwd: args.cwd } : {}
-        });
-      }
-      return listPeerSessions(context, scope ?? "repo");
-    }
-  }
-}
-function cliPeerSelf(env, cwd, persisted) {
-  const sessionId = env.VH_PEER_SESSION_ID;
-  if (sessionId && persistence.isValidSessionId(sessionId)) {
-    const meta = persisted[sessionId]?.metadata;
-    return { sessionId, title: meta?.summary?.text, flavor: meta?.flavor, cwd: meta?.path ?? cwd };
-  }
-  let user = "user";
-  try {
-    user = os.userInfo().username;
-  } catch {
-  }
-  return { sessionId: CLI_PEER_SENDER_ID, title: `cli ${user}@${os.hostname()}`, flavor: "cli", cwd };
-}
-function createSessionPeerToolExecutor(client) {
-  const context = {
-    self: () => {
-      const meta = client.getMetadata();
-      return { sessionId: client.sessionId, title: meta?.summary?.text, flavor: meta?.flavor, cwd: meta?.path ?? process.cwd() };
-    },
-    // One budget per session process: the reply-loop guard.
-    sentTo: /* @__PURE__ */ new Map()
-  };
-  return (name, args) => executeSessionPeerTool(name, args, context);
-}
-function registerSessionPeerTools(server, execute) {
-  for (const name of SESSION_PEER_TOOL_NAMES) {
-    const spec = SESSION_PEER_TOOL_SCHEMAS[name];
-    server.registerTool(name, {
-      description: spec.description,
-      title: spec.title,
-      inputSchema: spec.inputSchema,
-      annotations: { readOnlyHint: spec.readOnly, idempotentHint: spec.readOnly, openWorldHint: false, destructiveHint: false }
-    }, async (args) => {
-      try {
-        return { content: [{ type: "text", text: JSON.stringify(await execute(name, args ?? {})) }], isError: false };
-      } catch (error) {
-        return { content: [{ type: "text", text: error instanceof Error ? error.message : "Session peer operation failed" }], isError: true };
-      }
-    });
-  }
-}
-
-function trimIdent(text) {
-  const lines = text.split("\n");
-  while (lines.length > 0 && lines[0].trim() === "") {
-    lines.shift();
-  }
-  while (lines.length > 0 && lines[lines.length - 1].trim() === "") {
-    lines.pop();
-  }
-  const minSpaces = lines.reduce((min, line) => {
-    if (line.trim() === "") {
-      return min;
-    }
-    const leadingSpaces = line.match(/^\s*/)[0].length;
-    return Math.min(min, leadingSpaces);
-  }, Infinity);
-  const trimmedLines = lines.map((line) => line.slice(minSpaces));
-  return trimmedLines.join("\n");
-}
-
-const AGENT_GUIDANCE = (() => trimIdent(`
-    You are running inside Happy: the user is reading this session in a web client (often a phone), NOT in the terminal where you run. Two consequences:
-
-    - Terminal output is not a good delivery channel. When the user asks for a piece of text ("copy that", "give me X", "\u590D\u5236\u7ED9\u6211", "\u53D1\u6211"), hand it over with mcp__happy__copy_to_clipboard instead of printing it for them to select by hand.
-    - When you produce or want to show a FILE (a document you wrote, a report, an image, a PDF, a diff), call mcp__happy__open_preview with its path instead of cat-ing it. Their client opens the rendered file.
-
-    Judgement, not reflex: use these when the user's goal is to RECEIVE something. If they are asking a question you can just answer, answer it. Do not preview a file you only read for your own reasoning, and do not preview the same file repeatedly within a turn.
-
-    If you are working on a task the user is tracking, call mcp__happy__report_progress at meaningful milestones (started / blocked / needs review / done) so their board reflects reality. Do not report every tool call.
-`))();
-const PREVIEW_TOOL_NAME = "open_preview";
-const PREVIEW_TOOL_TITLE = "Open File Preview for the User";
-const PREVIEW_TOOL_DESCRIPTION = 'Open a file in the preview panel of every web client the user currently has open. Use this whenever you produce or want to show the user a file: a document or report you just wrote, a generated image or diagram, a PDF, a data file, or a source file you want them to look at. Trigger phrases include: "write me a doc", "show me that file", "let me see it", "\u5199\u4E2A\u6587\u6863", "\u7ED9\u6211\u770B\u770B\u8FD9\u4E2A\u6587\u4EF6", "\u6253\u5F00\u770B\u4E0B". Pass an absolute path (or one starting with ~). The file is read on this machine and rendered in their browser \u2014 markdown is rendered, images and PDFs are displayed, other text is syntax-highlighted. Prefer this over printing file contents to the terminal, which the user is probably not looking at. NOTE: this only requests that their client open the file; it cannot confirm the user actually looked at it, so do not assume they have seen it.';
-const REPORT_PROGRESS_TOOL_NAME = "report_progress";
-const REPORT_PROGRESS_TOOL_TITLE = "Report Progress to the Task Board";
-const REPORT_PROGRESS_TOOL_DESCRIPTION = `Report what you are doing to the user's task board, so they can see the state of this session at a glance without reading the transcript. Call it at meaningful milestones only: when you start substantive work, when you get blocked and need the user, when something is ready for their review, and when you are done. Do NOT call it after every tool call or every file edit \u2014 it is a status line, not a log. Set attention to "blocked" when you cannot proceed without the user, "review" when you want them to look at something, and "none" for ordinary progress. Keep progress to one short line describing the current state (the user reads it on a card).`;
-
-exports.AGENT_GUIDANCE = AGENT_GUIDANCE;
-exports.AUTOMATIONS_UNAVAILABLE_MESSAGE = AUTOMATIONS_UNAVAILABLE_MESSAGE;
-exports.AUTOMATION_TOOL_NAMES = AUTOMATION_TOOL_NAMES;
-exports.AutomationsRequestError = AutomationsRequestError;
-exports.CLI_PEER_SENDER_ID = CLI_PEER_SENDER_ID;
-exports.DEFAULT_RECENT_LIMIT = DEFAULT_RECENT_LIMIT;
-exports.MAX_READ_LIMIT = MAX_READ_LIMIT;
-exports.PEER_SCOPES = PEER_SCOPES$1;
-exports.PREVIEW_TOOL_DESCRIPTION = PREVIEW_TOOL_DESCRIPTION;
-exports.PREVIEW_TOOL_NAME = PREVIEW_TOOL_NAME;
-exports.PREVIEW_TOOL_TITLE = PREVIEW_TOOL_TITLE;
-exports.REMOTE_ANSWER_MAX_BYTES = REMOTE_ANSWER_MAX_BYTES;
-exports.REMOTE_OP_DEADLINE_MS = REMOTE_OP_DEADLINE_MS;
-exports.REMOTE_RESUME_WAIT_MS = REMOTE_RESUME_WAIT_MS;
-exports.REMOTE_SEND_COMMIT_DEADLINE_MS = REMOTE_SEND_COMMIT_DEADLINE_MS;
-exports.REMOTE_TITLE_MAX_BYTES = REMOTE_TITLE_MAX_BYTES;
-exports.REMOTE_WRITE_CALLS_PER_MINUTE = REMOTE_WRITE_CALLS_PER_MINUTE;
-exports.REPORT_PROGRESS_TOOL_DESCRIPTION = REPORT_PROGRESS_TOOL_DESCRIPTION;
-exports.REPORT_PROGRESS_TOOL_NAME = REPORT_PROGRESS_TOOL_NAME;
-exports.REPORT_PROGRESS_TOOL_TITLE = REPORT_PROGRESS_TOOL_TITLE;
-exports.RemoteCallBudget = RemoteCallBudget;
-exports.RemoteSessionOpsError = RemoteSessionOpsError;
-exports.SESSION_PEER_SENT_FROM = SESSION_PEER_SENT_FROM;
-exports.SESSION_PEER_TOOL_NAMES = SESSION_PEER_TOOL_NAMES;
-exports.TEAM_TOOL_NAMES = TEAM_TOOL_NAMES;
-exports.TURN_WINDOW = TURN_WINDOW;
-exports.TeamConnectionPreflightError = TeamConnectionPreflightError;
-exports.TurnWaitTimeoutError = TurnWaitTimeoutError;
-exports.analyzeLatestTurn = analyzeLatestTurn;
-exports.archiveSession = archiveSession;
-exports.authenticatedAutomationsClient = authenticatedAutomationsClient;
-exports.automationRunIdFromEnv = automationRunIdFromEnv;
-exports.capRemoteText = capRemoteText;
-exports.capRemoteTranscript = capRemoteTranscript;
-exports.cliPeerSelf = cliPeerSelf;
-exports.createAutomationsClient = createAutomationsClient;
-exports.createSessionPeerToolExecutor = createSessionPeerToolExecutor;
-exports.createTeamsClient = createTeamsClient;
-exports.deliverToSession = deliverToSession;
-exports.fillForeignAccountRows = fillForeignAccountRows;
-exports.formatEditConflictNotice = formatEditConflictNotice;
-exports.formatRemoteAuditLine = formatRemoteAuditLine;
-exports.guardRemoteSessionOpsRequest = guardRemoteSessionOpsRequest;
-exports.isAutomationsUnavailable = isAutomationsUnavailable;
-exports.listAccountSessions = listAccountSessions;
-exports.listPeerSessions = listPeerSessions;
-exports.listRemotePeers = listRemotePeers;
-exports.listRemoteSessions = listRemoteSessions;
-exports.listSessions = listSessions;
-exports.readRemoteTranscript = readRemoteTranscript;
-exports.readSessionLog = readSessionLog;
-exports.readSessionMetadata = readSessionMetadata;
-exports.readSessionTranscript = readSessionTranscript;
-exports.readTeamScope = readTeamScope;
-exports.registerAutomationTools = registerAutomationTools;
-exports.registerSessionPeerTools = registerSessionPeerTools;
-exports.registerTeamsTools = registerTeamsTools;
-exports.remoteError = remoteError;
-exports.resolvePermissionRequest = resolvePermissionRequest;
-exports.sendPeerMessage = sendPeerMessage;
-exports.sendRemoteMessage = sendRemoteMessage;
-exports.sendUserMessage = sendUserMessage;
-exports.sessionWebUrl = sessionWebUrl;
-exports.stopSession = stopSession;
-exports.teamRequest = teamRequest;
-exports.teamScopePath = teamScopePath;
-exports.trimIdent = trimIdent;
-exports.userPromptText = userPromptText;
-exports.waitForRemoteTurnEnd = waitForRemoteTurnEnd;
-exports.waitForSessionKey = waitForSessionKey;
-exports.waitForTurnEnd = waitForTurnEnd;