very-happy-cli 0.2.159 → 0.2.161

package/dist/tmuxSocket-D-Xt6Vn-.cjs

@@ -0,0 +1,24 @@
+'use strict';
+
+function shellescape(s) {
+  return "'" + s.replace(/'/g, "'\\''") + "'";
+}
+
+const VH_TMUX_SOCKET_ENV = "VH_TMUX_SOCKET";
+function tmuxSocketFlags(env = process.env) {
+  const socket = env[VH_TMUX_SOCKET_ENV];
+  return socket ? ["-S", socket] : [];
+}
+function tmuxArgs(args, env = process.env) {
+  return [...tmuxSocketFlags(env), ...args];
+}
+function scrubTmuxClientEnv(env) {
+  delete env.TMUX;
+  delete env.TMUX_PANE;
+  return env;
+}
+
+exports.VH_TMUX_SOCKET_ENV = VH_TMUX_SOCKET_ENV;
+exports.scrubTmuxClientEnv = scrubTmuxClientEnv;
+exports.shellescape = shellescape;
+exports.tmuxArgs = tmuxArgs;

package/dist/{todo-DqyRI4wP.cjs → todo-B-KB7oAB.cjs}

@@ -1,31 +1,34 @@
 'use strict';
 
-var persistence = require('./limits-BH5CV5vR.cjs');
-var agentGuidance = require('./agentGuidance-BRDN1NoZ.cjs');
+var configuration = require('./configuration-v9f8LM9T.cjs');
+var index = require('./index-DA7yINuk.cjs');
+var persistence = require('./persistence-CBNMzSa8.cjs');
+var context = require('./context-B45vMtSZ.cjs');
+require('node:fs');
+require('node:os');
+require('node:path');
+require('./package-Cl5BEP5x.cjs');
+require('node:fs/promises');
 require('zod');
 require('@paralleldrive/cuid2');
-require('node:fs/promises');
-require('node:fs');
+require('./authRelay-BdYkC1Po.cjs');
 require('node:crypto');
 require('tweetnacl');
+require('./logger-Bc8-u1w0.cjs');
 require('chalk');
 require('node:util');
-require('node:os');
-require('node:path');
-require('axios');
-require('socket.io-client');
 
 async function authenticatedBuiltinTodoClient() {
   if (process.env.VH_TEAM_SCOPE_FILE !== void 0) {
     throw new Error("Scoped Teams sessions cannot access account Todos; ask the owner session.");
   }
   const sessionId = process.env.HAPPY_SESSION_ID;
-  if (sessionId && await agentGuidance.readTeamScope(agentGuidance.teamScopePath(sessionId))) {
+  if (sessionId && await context.readTeamScope(context.teamScopePath(sessionId))) {
     throw new Error("Scoped Teams sessions cannot access account Todos; ask the owner session.");
   }
   const credentials = await persistence.readCredentialsForConfiguredRelay();
   if (!credentials) throw new Error("Sign in to Very Happy with `very-happy auth login` before accessing Todos.");
-  return persistence.createBuiltinTodoClient(credentials, { serverUrl: persistence.configuration.serverUrl, clientId: "very-happy-cli-todo" });
+  return index.createBuiltinTodoClient(credentials, { serverUrl: configuration.configuration.serverUrl, clientId: "very-happy-cli-todo" });
 }
 
 const TODO_HELP = `very-happy todo \u2014 account-owned built-in Todos (JSON output)
@@ -89,7 +92,7 @@ async function handleTodoCommand(args) {
     return;
   }
   if (command.action === "skill") {
-    console.log(persistence.BUILTIN_TODO_SKILL);
+    console.log(index.BUILTIN_TODO_SKILL);
     return;
   }
   const client = await authenticatedBuiltinTodoClient();
@@ -108,7 +111,7 @@ async function handleTodoCommand(args) {
       } else result = await client.update(record, command.action === "edit" ? { ...command.title !== void 0 ? { title: command.title } : {}, ...command.note !== void 0 ? { note: command.note } : {} } : { status: command.action === "complete" ? "done" : "open" });
     }
   }
-  console.log(JSON.stringify({ serverUrl: persistence.configuration.serverUrl, result }));
+  console.log(JSON.stringify({ serverUrl: configuration.configuration.serverUrl, result }));
 }
 
 exports.TODO_HELP = TODO_HELP;

package/dist/{todo-Cknp5D4U.mjs → todo-C5KBVbUw.mjs}

@@ -1,17 +1,20 @@
-import { h as readCredentialsForConfiguredRelay, j as createBuiltinTodoClient, c as configuration, B as BUILTIN_TODO_SKILL } from './limits-CjRj8IX5.mjs';
-import { C as readTeamScope, E as teamScopePath } from './agentGuidance-KgvYuF3R.mjs';
+import { c as configuration } from './configuration-DoWFJUPm.mjs';
+import { f as createBuiltinTodoClient, B as BUILTIN_TODO_SKILL } from './index-qdS1friN.mjs';
+import { readCredentialsForConfiguredRelay } from './persistence-oET5n61f.mjs';
+import { r as readTeamScope, t as teamScopePath } from './context-C9GHPLEm.mjs';
+import 'node:fs';
+import 'node:os';
+import 'node:path';
+import './package-uOg9SCKi.mjs';
+import 'node:fs/promises';
 import 'zod';
 import '@paralleldrive/cuid2';
-import 'node:fs/promises';
-import 'node:fs';
+import './authRelay-DSAvg1uv.mjs';
 import 'node:crypto';
 import 'tweetnacl';
+import './logger-fXoNzNuB.mjs';
 import 'chalk';
 import 'node:util';
-import 'node:os';
-import 'node:path';
-import 'axios';
-import 'socket.io-client';
 
 async function authenticatedBuiltinTodoClient() {
   if (process.env.VH_TEAM_SCOPE_FILE !== void 0) {

package/dist/tools-BZabNIid.mjs

@@ -0,0 +1,177 @@
+import { z } from 'zod';
+import { a as AutomationNameSchema, b as AutomationConcurrencySchema, c as AutomationActionSchema, d as AutomationTriggerSchema } from './index-qdS1friN.mjs';
+import { a as authenticatedAutomationsClient, b as automationRunIdFromEnv } from './client-CXb1VJui.mjs';
+
+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.string().min(1).max(128);
+const ref = { name: AutomationNameSchema.optional().describe("Automation name"), id: id.optional().describe("Automation id (alternative to name)") };
+const payload = z.string().max(65536).optional().describe("Payload text; JSON lets prompts use {{payload.field}}");
+const maxRuntimeMs = 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: AutomationNameSchema,
+      description: z.string().max(4e3).optional(),
+      machineId: id.optional().describe("Target machine id; omit or 'this' for the current machine"),
+      trigger: AutomationTriggerSchema,
+      action: AutomationActionSchema,
+      concurrency: AutomationConcurrencySchema.optional().describe("skip (default): a run while another is active is recorded as skipped; queue: it waits"),
+      maxRuntimeMs,
+      paused: 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.number().int().positive(),
+      newName: AutomationNameSchema.optional(),
+      description: z.string().max(4e3).nullable().optional(),
+      machineId: id.optional(),
+      trigger: AutomationTriggerSchema.optional(),
+      action: AutomationActionSchema.optional(),
+      concurrency: 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: AutomationNameSchema, payload, dedupeKey: 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.string().min(1).max(64).optional(), attention: z.boolean().optional().describe("Only runs flagged for a human"), limit: 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.enum(["done", "failed"]), summary: z.string().max(4096).optional(), error: z.string().max(4096).optional(), needsAttention: z.boolean().optional(), attentionReason: 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 };
+      }
+    });
+  }
+}
+
+export { AUTOMATION_TOOL_NAMES as A, registerAutomationTools as r };

package/dist/tools-BmQQUATY.mjs

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+import { c as createTeamsClient } from './client-Brn-UwVk.mjs';
+
+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 = z.string().min(1).max(128);
+const text = z.string().min(1).max(32e3);
+const requestId = id.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, machineId: id.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, name: id, botId: id.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.array(text).min(1).max(32),
+    parentTaskId: id.optional(),
+    assigneeBotId: id.optional(),
+    botName: id.optional(),
+    directory: z.string().min(1).optional(),
+    assistant: z.enum(["claude", "codex", "pi-acp"]).optional(),
+    model: 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, body: text, recipientBotId: id.optional() });
+  action("submit", "Submit evidence for your current attempt and goal version. The owner still has to accept it.", { taskId: id, attemptId: id, goalVersion: z.number().int().positive(), result: text });
+  const current = { attemptId: id, goalVersion: z.number().int().positive() };
+  action("accept", "Accept a task you own after checking its evidence. Resource cleanup is tracked separately.", { taskId: id, ...current });
+  action("return", "Return your task for further work with a concrete reason.", { taskId: id, reason: text, ...current });
+  action("cancel", "Cancel an owned task and its dependent work. Cleanup may remain pending.", { taskId: id, reason: text, ...current });
+  action("handoff", "Move an owned task to another bot; prior execution authority is superseded.", { taskId: id, assigneeBotId: id, ...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, botId: id, body: text, runAt: z.number().int().nonnegative(), intervalMs: 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, version: z.number().int().positive() }, ({ requestId: key, ...args }) => client.action({ type: `schedule-${operation}`, ...args }, key));
+  }
+}
+
+export { TEAM_TOOL_NAMES as T, registerTeamsTools as r };

package/dist/tools-CsSovyNp.cjs

@@ -0,0 +1,180 @@
+'use strict';
+
+var z = require('zod');
+var index = require('./index-DA7yINuk.cjs');
+var client = require('./client-DOBWJL3u.cjs');
+
+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: index.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: index.AutomationNameSchema,
+      description: z.z.string().max(4e3).optional(),
+      machineId: id.optional().describe("Target machine id; omit or 'this' for the current machine"),
+      trigger: index.AutomationTriggerSchema,
+      action: index.AutomationActionSchema,
+      concurrency: index.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: index.AutomationNameSchema.optional(),
+      description: z.z.string().max(4e3).nullable().optional(),
+      machineId: id.optional(),
+      trigger: index.AutomationTriggerSchema.optional(),
+      action: index.AutomationActionSchema.optional(),
+      concurrency: index.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: index.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: client$1 } = context;
+  switch (name) {
+    case "automation_list":
+      return { automations: await client$1.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$1.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$1.update(current.id, input) };
+    }
+    case "automation_pause":
+      return { automation: await client$1.pause((await resolve(context, args)).id) };
+    case "automation_resume":
+      return { automation: await client$1.resume((await resolve(context, args)).id) };
+    case "automation_delete": {
+      const target = await resolve(context, args);
+      await client$1.remove(target.id);
+      return { deleted: true, id: target.id, name: target.name };
+    }
+    case "automation_run":
+      return { run: await client$1.run((await resolve(context, args)).id, args.payload !== void 0 ? { payload: args.payload } : {}) };
+    case "automation_fire":
+      return client$1.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$1.getByName(args.name)).id : void 0);
+      return { runs: await client$1.runs({ automationId, status: args.status, attention: args.attention === true, limit: args.limit }) };
+    }
+    case "automation_report": {
+      const runId = args.runId ?? client.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$1.report(runId, report) };
+    }
+    case "automation_ack":
+      return { run: await client$1.ack(args.runId) };
+  }
+}
+function createAutomationToolExecutor() {
+  let context = null;
+  return async (name, args) => {
+    context ??= client.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 };
+      }
+    });
+  }
+}
+
+exports.AUTOMATION_TOOL_NAMES = AUTOMATION_TOOL_NAMES;
+exports.registerAutomationTools = registerAutomationTools;

package/dist/tools-lMDra4Pv.cjs

@@ -0,0 +1,63 @@
+'use strict';
+
+var z = require('zod');
+var client = require('./client-C_axwRry.cjs');
+
+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 = z.z.string().min(1).max(128);
+const text = z.z.string().min(1).max(32e3);
+const requestId = id.describe("Unique operation ID. Reuse the same ID and arguments after an uncertain response.");
+function registerTeamsTools(server, sessionId, client$1 = 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, machineId: id.optional(), requestId },
+    (args) => client$1.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, name: id, botId: id.optional().describe("Existing root bot to reconnect; preserves its identity"), requestId },
+    (args) => client$1.initialize(args)
+  );
+  register("team_inspect", "Read your visible team tasks, attempts and messages. Inspect before decisions; submission is not acceptance.", {}, () => client$1.inspect());
+  const action = (name, description, fields) => register(
+    `team_${name}`,
+    description,
+    { requestId, ...fields },
+    ({ requestId: key, ...args }) => client$1.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.optional(),
+    assigneeBotId: id.optional(),
+    botName: id.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, body: text, recipientBotId: id.optional() });
+  action("submit", "Submit evidence for your current attempt and goal version. The owner still has to accept it.", { taskId: id, attemptId: id, goalVersion: z.z.number().int().positive(), result: text });
+  const current = { attemptId: id, goalVersion: z.z.number().int().positive() };
+  action("accept", "Accept a task you own after checking its evidence. Resource cleanup is tracked separately.", { taskId: id, ...current });
+  action("return", "Return your task for further work with a concrete reason.", { taskId: id, reason: text, ...current });
+  action("cancel", "Cancel an owned task and its dependent work. Cleanup may remain pending.", { taskId: id, reason: text, ...current });
+  action("handoff", "Move an owned task to another bot; prior execution authority is superseded.", { taskId: id, assigneeBotId: id, ...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, botId: id, body: text, runAt: z.z.number().int().nonnegative(), intervalMs: z.z.number().int().min(6e4).optional() }, ({ requestId: key, ...args }) => client$1.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, version: z.z.number().int().positive() }, ({ requestId: key, ...args }) => client$1.action({ type: `schedule-${operation}`, ...args }, key));
+  }
+}
+
+exports.TEAM_TOOL_NAMES = TEAM_TOOL_NAMES;
+exports.registerTeamsTools = registerTeamsTools;

package/dist/trimIdent-4gvk9Wk6.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+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");
+}
+
+exports.trimIdent = trimIdent;

package/dist/trimIdent-BAjmv_TG.mjs

@@ -0,0 +1,20 @@
+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");
+}
+
+export { trimIdent as t };