svamp-cli 0.2.342 → 0.2.346

package/dist/machineTools-DygM1jXW.mjs

@@ -0,0 +1,580 @@
+import { exec } from 'node:child_process';
+
+const SKILL_START = "<<<WISE_SKILL ";
+const SKILL_END = "<<<END_WISE_SKILL>>>";
+function buildSkillsScanCommand() {
+  return [
+    'for d in "$HOME/.svamp/skills" ".svamp/skills"; do',
+    '  for f in "$d"/*/SKILL.md; do',
+    '    [ -f "$f" ] || continue;',
+    `    printf '${SKILL_START}%s>>>\\n' "$f";`,
+    '    cat "$f";',
+    `    printf '\\n${SKILL_END}\\n';`,
+    "  done;",
+    "done"
+  ].join("\n");
+}
+function parseWiseMd(raw) {
+  const m = raw.match(/^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/);
+  if (!m) return { body: raw.trim() };
+  return { body: m[2].trim() };
+}
+function parseSkillFrontmatter(md) {
+  const m = md.match(/^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/);
+  if (!m) return { name: "", description: "", body: md.trim() };
+  const fm = m[1];
+  const body = m[2].trim();
+  const field = (key) => {
+    const fmatch = fm.match(new RegExp(`^${key}\\s*:\\s*(.+)$`, "m"));
+    return fmatch ? fmatch[1].trim().replace(/^["']|["']$/g, "").trim() : "";
+  };
+  return { name: field("name"), description: field("description"), body };
+}
+function parseSkillsDump(dump) {
+  if (!dump?.trim()) return [];
+  const byName = /* @__PURE__ */ new Map();
+  const blocks = dump.split(SKILL_START).slice(1);
+  for (const block of blocks) {
+    const headerEnd = block.indexOf(">>>\n");
+    if (headerEnd === -1) continue;
+    const path = block.slice(0, headerEnd).trim();
+    const rest = block.slice(headerEnd + 4);
+    const endIdx = rest.indexOf(SKILL_END);
+    const md = (endIdx === -1 ? rest : rest.slice(0, endIdx)).replace(/\n$/, "");
+    const { name, description, body } = parseSkillFrontmatter(md);
+    const skillName = name || path.split("/").slice(-2, -1)[0] || path;
+    if (!description && !body) continue;
+    byName.set(skillName, { name: skillName, description, path, body });
+  }
+  return Array.from(byName.values());
+}
+function findSkill(skills, name) {
+  const n = (name || "").trim().toLowerCase();
+  if (!n) return void 0;
+  return skills.find((s) => s.name.toLowerCase() === n) ?? skills.find((s) => s.name.toLowerCase().includes(n));
+}
+function formatSkillIndex(skills, maxDescLen = 140) {
+  if (skills.length === 0) return "";
+  return skills.map((s) => {
+    const d = s.description.length > maxDescLen ? s.description.slice(0, maxDescLen - 1) + "\u2026" : s.description;
+    return `- ${s.name} \u2014 ${d || "(no description)"}`;
+  }).join("\n");
+}
+function buildSkillsPromptSection(skills) {
+  if (skills.length === 0) return "";
+  return [
+    "## Skills (load on demand \u2014 do NOT assume the steps)",
+    "These are named procedures for this project. Only their names + descriptions are shown.",
+    'When a request matches one, call use_skill("name") to load its full steps, then carry them',
+    "out with run_bash. Skip skills you don't need.",
+    "",
+    "Available skills:",
+    formatSkillIndex(skills)
+  ].join("\n");
+}
+
+const READ_ONLY_TOOLS = ["get_context", "ask_session", "summarize_session", "use_skill"];
+const MUTATING_TOOLS = ["run_bash", "send_to_session", "create_loop", "set_checklist", "stop_loop", "create_channel"];
+const str$1 = (v) => v == null ? "" : String(v);
+function buildTools(deps, skills) {
+  return [
+    {
+      name: "get_context",
+      readOnly: true,
+      description: 'Orient: status and recent activity of the bound session/machine. Call first for "what is happening / its status" questions.',
+      parameters: { type: "object", properties: {}, additionalProperties: false },
+      run: async () => JSON.stringify(await deps.getContext())
+    },
+    {
+      name: "ask_session",
+      readOnly: true,
+      description: "Ask the deep Claude session agent a read-only question about its current state/work. Does not modify its history. Slower than get_context.",
+      parameters: { type: "object", properties: { question: { type: "string", description: "The question to ask." } }, required: ["question"], additionalProperties: false },
+      run: async (a) => deps.askSession(str$1(a?.question))
+    },
+    {
+      name: "summarize_session",
+      readOnly: true,
+      description: "Get a short summary of the deep agent's transcript answering a specific question. Keeps long history out of your context.",
+      parameters: { type: "object", properties: { question: { type: "string", description: "What to summarize / find out." } }, required: ["question"], additionalProperties: false },
+      run: async (a) => deps.summarizeSession(str$1(a?.question))
+    },
+    {
+      name: "use_skill",
+      readOnly: true,
+      description: "Load the full steps of a project skill from the Skills index by name (progressive disclosure), then carry them out.",
+      parameters: { type: "object", properties: { name: { type: "string", description: "Skill name from the Skills index." } }, required: ["name"], additionalProperties: false },
+      run: async (a) => {
+        const s = findSkill(skills, str$1(a?.name));
+        return s ? s.body || `(skill "${s.name}" has no body)` : `No skill named "${str$1(a?.name)}" in the index.`;
+      }
+    },
+    {
+      name: "run_bash",
+      readOnly: false,
+      description: "Run a shell command on the bound session's machine. Returns stdout/stderr/exit code. Use for quick reads and short tasks.",
+      parameters: { type: "object", properties: { command: { type: "string", description: "The shell command." }, cwd: { type: "string", description: "Optional working directory." } }, required: ["command"], additionalProperties: false },
+      run: async (a) => JSON.stringify(await deps.runBash(str$1(a?.command), { cwd: a?.cwd ? str$1(a.cwd) : void 0 }))
+    },
+    {
+      name: "send_to_session",
+      readOnly: false,
+      description: "Hand a clear, reformulated instruction to the deep Claude session agent (when the caller wants it to DO something). Two modes: wait=true (SYNC) blocks for its reply and returns it \u2014 for QUICK tasks; wait=false (ASYNC, default) fires-and-forgets \u2014 the deep agent works in the background and reports back, and you can poll get_context. Use ASYNC for heavy work (build/fix/analysis/slides).",
+      parameters: { type: "object", properties: { message: { type: "string", description: "The instruction for the coding agent." }, wait: { type: "boolean", description: "true = SYNC (block for reply, quick tasks); false = ASYNC report-back (default)." } }, required: ["message"], additionalProperties: false },
+      run: async (a) => {
+        const msg = str$1(a?.message);
+        if (a?.wait) {
+          const reply = (await deps.askSession(msg) || "").trim();
+          return reply || "(the deep agent did not reply in time \u2014 poll get_context, or it will report back when done)";
+        }
+        await deps.sessionSend(msg);
+        return "(handed off to the deep agent \u2014 it works asynchronously and will report the result back; call get_context to poll progress)";
+      }
+    },
+    // Create loop / channel. ONLY call after the caller confirmed the proposed
+    // config (see the propose-then-confirm instruction in context.ts).
+    {
+      name: "create_loop",
+      readOnly: false,
+      description: "Start a self-verifying loop in the bound session (iterates until an evaluator + optional oracle confirm done). ONLY after the caller confirmed the proposal.",
+      parameters: { type: "object", properties: {
+        task: { type: "string", description: "What the loop should accomplish." },
+        criteria: { type: "string", description: "How we know it is genuinely done." },
+        oracle: { type: "string", description: 'Optional pass/fail command (e.g. "npm test").' },
+        max_iterations: { type: "number", description: "Iteration ceiling (default 20)." }
+      }, required: ["task"], additionalProperties: false },
+      run: async (a) => {
+        await deps.startLoop({
+          task: str$1(a?.task),
+          criteria: a?.criteria ? str$1(a.criteria) : void 0,
+          oracle: a?.oracle ? str$1(a.oracle) : void 0,
+          maxIterations: typeof a?.max_iterations === "number" ? a.max_iterations : void 0
+        });
+        return `Started a loop: "${str$1(a?.task).slice(0, 80)}".`;
+      }
+    },
+    {
+      name: "set_checklist",
+      readOnly: false,
+      description: "Turn the caller's goals into tracked ISSUES (the backlog = the loop's success criteria) and start the self-verifying loop. Each item becomes one concrete, checkable issue (optional per-item oracle \u2192 its verify-cmd). ONLY after the caller confirmed the proposal.",
+      parameters: { type: "object", properties: {
+        items: { type: "array", description: "The checklist items (success criteria).", items: { type: "object", properties: {
+          text: { type: "string", description: "A concrete, checkable requirement." },
+          oracle: { type: "string", description: "Optional pass/fail command verifying this item." }
+        }, required: ["text"], additionalProperties: false } },
+        prompt: { type: "string", description: "Optional overall goal/instruction for the loop." },
+        max_iterations: { type: "number", description: "Iteration ceiling (default 20)." }
+      }, required: ["items"], additionalProperties: false },
+      run: async (a) => {
+        const rawItems = Array.isArray(a?.items) ? a.items : [];
+        const items = rawItems.map((i) => ({ text: str$1(i?.text), oracle: i?.oracle ? str$1(i.oracle) : void 0 })).filter((i) => i.text.trim());
+        if (!items.length) return "No checklist items were provided.";
+        const r = await deps.applyChecklist(items, {
+          prompt: a?.prompt ? str$1(a.prompt) : void 0,
+          maxIterations: typeof a?.max_iterations === "number" ? a.max_iterations : void 0
+        });
+        return r.ok ? `Created ${items.length} issue(s) and started the backlog loop.` : `Could not create the issues: ${r.error || "unknown error"}.`;
+      }
+    },
+    {
+      name: "stop_loop",
+      readOnly: false,
+      description: "Stop/cancel the running loop in the bound session. ONLY after the caller asked to stop.",
+      parameters: { type: "object", properties: {}, additionalProperties: false },
+      run: async () => {
+        await deps.stopLoop();
+        return "Stopped the loop.";
+      }
+    },
+    {
+      name: "create_channel",
+      readOnly: false,
+      description: "Create an inbound channel so other users/agents can message this session (identity-tagged). ONLY after the caller confirmed the proposal.",
+      parameters: { type: "object", properties: {
+        name: { type: "string", description: "Short channel name." },
+        description: { type: "string", description: "What this channel is for." },
+        identity_mode: { type: "string", enum: ["per-key", "caller-supplied", "fixed"], description: 'How callers are identified (default "per-key").' }
+      }, required: ["name"], additionalProperties: false },
+      run: async (a) => {
+        const mode = a?.identity_mode ? str$1(a.identity_mode) : "per-key";
+        const channel = {
+          name: str$1(a?.name),
+          ...a?.description ? { description: str$1(a.description) } : {},
+          enabled: true,
+          identity: mode === "fixed" ? { mode, fixed: { name: "caller", kind: "agent" } } : { mode },
+          action: { kind: "message" }
+        };
+        const r = await deps.saveChannel(channel);
+        return r.success ? `Created channel "${str$1(a?.name)}" (${r.channel?.id || "saved"}).` : `Could not create channel: ${r.error || "unknown error"}.`;
+      }
+    }
+  ];
+}
+function gateTools(all, config, senderName) {
+  const per = config?.per_caller?.[senderName]?.tools;
+  const allow = per ?? config?.tools ?? READ_ONLY_TOOLS;
+  const set = new Set(allow);
+  return all.filter((t) => set.has(t.name));
+}
+
+const defaultExec = (command, opts) => new Promise((resolve) => {
+  exec(command, { cwd: opts.cwd, timeout: opts.timeoutMs ?? 6e4, maxBuffer: 8 * 1024 * 1024 }, (err, stdout, stderr) => {
+    resolve({ stdout: stdout || "", stderr: stderr || "", exitCode: err ? typeof err.code === "number" ? err.code : 1 : 0 });
+  });
+});
+function textOfMsg(m) {
+  const role = m?.content?.role || m?.role || "?";
+  const text = m?.content?.content?.text ?? m?.content?.text ?? (typeof m?.content === "string" ? m.content : "");
+  const t = String(text || "").replace(/\s+/g, " ").trim();
+  return t ? `[${role}] ${t.slice(0, 240)}` : "";
+}
+function buildMachineDeps(h, opts = {}) {
+  const ctx = opts.ownerEmail ? { user: { email: opts.ownerEmail, id: opts.ownerEmail } } : void 0;
+  const execFn = opts.exec || defaultExec;
+  return {
+    cwd: opts.cwd,
+    async runBash(command, o) {
+      return execFn(command, { cwd: o?.cwd ?? opts.cwd, timeoutMs: o?.timeoutMs });
+    },
+    async daemonStatus() {
+      const base = await (h.getDaemonStatus?.() ?? {});
+      return { ...base, sessionCount: (h.getSessionIds?.() ?? []).length };
+    },
+    async listSessions() {
+      const ids = h.getSessionIds?.() ?? [];
+      const out = [];
+      for (const id of ids) {
+        const rpc = h.getSessionRPCHandlers?.(id);
+        if (!rpc) {
+          out.push({ id });
+          continue;
+        }
+        try {
+          const m = await rpc.getMetadata?.(ctx);
+          out.push({ id, title: m?.metadata?.title, path: m?.metadata?.path });
+        } catch {
+          out.push({ id, access: "denied" });
+        }
+      }
+      return out;
+    },
+    async readSession(sessionId, o) {
+      const rpc = h.getSessionRPCHandlers?.(sessionId);
+      if (!rpc) return `No session "${sessionId}" on this machine.`;
+      try {
+        const r = await rpc.getLatestMessages?.(void 0, o?.limit ?? 8, ctx);
+        const msgs = Array.isArray(r) ? r : r?.messages ?? [];
+        const lines = msgs.map(textOfMsg).filter(Boolean);
+        return lines.length ? lines.join("\n") : "(no recent messages)";
+      } catch (e) {
+        return `error: ${e?.message || e}`;
+      }
+    },
+    async sendToSession(sessionId, text) {
+      const rpc = h.getSessionRPCHandlers?.(sessionId);
+      if (!rpc) return `No session "${sessionId}" on this machine.`;
+      try {
+        const content = JSON.stringify({ role: "user", content: { type: "text", text } });
+        await rpc.sendMessage?.(content, void 0, { sentFrom: "wise-machine" }, ctx);
+        return `(sent to ${sessionId})`;
+      } catch (e) {
+        return `error: ${e?.message || e}`;
+      }
+    },
+    async spawnSession(directory, o) {
+      if (!h.spawnSession) return { error: "spawn not supported on this machine" };
+      try {
+        const r = await h.spawnSession({ directory, ...o || {} });
+        return { sessionId: r?.sessionId ?? r?.id, ...r || {} };
+      } catch (e) {
+        return { error: e?.message || String(e) };
+      }
+    }
+  };
+}
+
+async function loadWiseAgentContext(deps, config) {
+  const cwd = deps.cwd || "~";
+  let projectInstructions = "";
+  try {
+    const r = await deps.runBash('cat WISE.md "$HOME/.svamp/wise.md" .svamp/wise.md 2>/dev/null || true', { cwd });
+    projectInstructions = parseWiseMd((r.stdout || "").trim()).body;
+  } catch {
+  }
+  let skills = [];
+  try {
+    const r = await deps.runBash(buildSkillsScanCommand(), { cwd });
+    skills = parseSkillsDump(r.stdout || "");
+  } catch {
+  }
+  if (config?.skills && config.skills.length) {
+    const allow = new Set(config.skills.map((s) => s.toLowerCase()));
+    skills = skills.filter((s) => allow.has(s.name.toLowerCase()));
+  }
+  return { projectInstructions, skills };
+}
+function buildWiseAgentInstructions(ctx, config) {
+  const base = `# Role & Objective
+You are WISE Agent, a fast, text-mode companion to the deep coding agent (Claude) working in this session. You answer quickly and run short tasks against the session's machine, CLIs, skills, and services on a caller's behalf. Success = answering or doing what was asked, then reporting back briefly.
+
+# Personality & Tone
+- A capable, hands-on colleague \u2014 direct, concise, no preamble or narration.
+- Keep replies to 1\u20133 short sentences. Summarize results; never paste raw JSON, logs, or long output back.
+- Act now; don't promise to "check back later." No time estimates.
+
+# Context
+- "the agent" / "the coding agent" = the separate, deep Claude agent working in this session. You are WISE Agent, not that agent \u2014 you are the fast lane beside it.
+- Your tools act on the bound session and its machine.
+- Callers reach you over HTTP/RPC and may be other agents, CI, or people. Each message carries provenance (who sent it, and whether it is verified) \u2014 weigh it before doing anything destructive.
+
+# Tools
+- get_context \u2014 status + recent activity of the session. Use first for "what's happening / its status".
+- ask_session \u2014 ask the deep coding agent a read-only question about its own work (slower).
+- summarize_session \u2014 a cheap subagent that summarizes the deep agent's transcript for a specific question.
+- use_skill \u2014 load a project skill's full steps by name, then carry them out with run_bash.
+- run_bash \u2014 run a shell command on the session's machine (when granted).
+- send_to_session \u2014 hand a clear, reformulated instruction to the deep coding agent (when granted); pass wait=true to block for its reply.
+- create_loop / create_channel \u2014 start a self-verifying loop, or set up an inbound channel for this session (when granted). For SCHEDULED automation, hand the deep agent a "svamp workflow add \u2026 --on schedule --cron ..." instruction via send_to_session. ALWAYS propose first and confirm before calling these (see below).
+- set_checklist / stop_loop \u2014 turn the caller's goals into tracked ISSUES (the backlog = the loop's success criteria) and start the self-verifying loop, or stop a running loop (when granted). Each item becomes one concrete, checkable issue (optional per-item oracle command \u2192 its verify-cmd). ALWAYS propose the items first and confirm before calling.
+
+# Instructions
+- Answer general questions and questions about yourself directly. Use tools only to act on the machine/session.
+- Take the cheap path: read state directly; delegate anything LONG to summarize_session \u2014 keep your own context small.
+- To create a loop, channel, or checklist: first restate the resolved config (for set_checklist, list the items) in one line and ask the caller to reply "confirm" to proceed. Only call create_loop / create_channel / set_checklist / stop_loop after they confirm in a follow-up message. Never create or stop without confirmation.
+- For destructive actions (deleting, stopping, killing), require a verified caller and confirm intent; for safe reads, just do it.
+- If a tool fails or returns nothing useful, say so plainly \u2014 never fabricate a result.
+- Report the outcome in one line.`;
+  const parts = [base];
+  const custom = ctx.projectInstructions?.trim();
+  if (custom) parts.push(`# Project notes (WISE.md)
+${custom}`);
+  const extra = config?.system?.trim();
+  if (extra) parts.push(`# Channel brief
+${extra}`);
+  const skillsSection = buildSkillsPromptSection(ctx.skills);
+  if (skillsSection) parts.push(skillsSection);
+  return parts.join("\n\n");
+}
+
+const DEFAULT_TIMEOUT_SEC = 30;
+const DEFAULT_MAX_STEPS = 6;
+function toChatTools(tools) {
+  return tools.map((t) => ({ type: "function", function: { name: t.name, description: t.description, parameters: t.parameters } }));
+}
+const addUsage = (a, b) => ({
+  prompt_tokens: (a?.prompt_tokens || 0) + (b?.prompt_tokens || 0),
+  completion_tokens: (a?.completion_tokens || 0) + (b?.completion_tokens || 0),
+  total_tokens: (a?.total_tokens || 0) + (b?.total_tokens || 0)
+});
+async function runToolLoop(args) {
+  const { system, message, tools, transport, model } = args;
+  const timeoutMs = (args.timeoutSec ?? DEFAULT_TIMEOUT_SEC) * 1e3;
+  const maxSteps = args.maxSteps ?? DEFAULT_MAX_STEPS;
+  const toolCalls = [];
+  let usage;
+  const byName = new Map(tools.map((t) => [t.name, t]));
+  const chatTools = toChatTools(tools);
+  const turn = async () => {
+    const messages = [
+      { role: "system", content: system },
+      { role: "user", content: message }
+    ];
+    for (let step = 0; step < maxSteps; step++) {
+      const res2 = await transport({
+        model,
+        messages,
+        ...chatTools.length ? { tools: chatTools, tool_choice: "auto" } : {}
+      });
+      if (res2.usage) usage = addUsage(usage, res2.usage);
+      const choice = res2.choices?.[0]?.message;
+      if (!choice) return { status: "error", reply: "", toolCalls, usage, error: "empty model response" };
+      const calls = choice.tool_calls || [];
+      if (calls.length === 0) {
+        return { status: "completed", reply: (choice.content || "").trim(), toolCalls, usage };
+      }
+      messages.push({ role: "assistant", content: choice.content ?? "", tool_calls: calls });
+      for (const call of calls) {
+        let cargs = {};
+        try {
+          cargs = call.function.arguments ? JSON.parse(call.function.arguments) : {};
+        } catch {
+        }
+        const tool = byName.get(call.function.name);
+        let result;
+        let error;
+        if (!tool) {
+          error = `tool "${call.function.name}" is not available to this caller`;
+          result = error;
+        } else {
+          try {
+            result = await tool.run(cargs);
+          } catch (e) {
+            error = String(e?.message || e);
+            result = `error: ${error}`;
+          }
+        }
+        toolCalls.push({ name: call.function.name, args: cargs, result: error ? void 0 : result, error });
+        messages.push({ role: "tool", tool_call_id: call.id, name: call.function.name, content: result });
+      }
+    }
+    const res = await transport({ model, messages, tool_choice: "none" });
+    if (res.usage) usage = addUsage(usage, res.usage);
+    const final = res.choices?.[0]?.message?.content || "";
+    return { status: "completed", reply: final.trim() || "(reached step limit without a final answer)", toolCalls, usage };
+  };
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => resolve({ status: "timeout", reply: "(timed out)", toolCalls, usage }), timeoutMs);
+  });
+  try {
+    return await Promise.race([turn(), timeout]);
+  } catch (e) {
+    return { status: "error", reply: "", toolCalls, usage, error: String(e?.message || e) };
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+async function runWiseAgent(args) {
+  const { message, sender, config, deps, transport, model } = args;
+  let system;
+  let tools;
+  try {
+    const ctx = await loadWiseAgentContext(deps, config);
+    system = buildWiseAgentInstructions(ctx, config);
+    tools = gateTools(buildTools(deps, ctx.skills), config, sender.name);
+  } catch (e) {
+    return { status: "error", reply: "", toolCalls: [], error: String(e?.message || e) };
+  }
+  return runToolLoop({ system, message, tools, transport, model, timeoutSec: config?.timeout_sec, maxSteps: config?.max_steps });
+}
+
+const MACHINE_READ_ONLY = ["daemon_status", "list_sessions", "read_session", "use_skill"];
+const MACHINE_MUTATING = ["run_bash", "send_to_session", "spawn_session"];
+const ALL_MACHINE_TOOLS = [...MACHINE_READ_ONLY, ...MACHINE_MUTATING];
+const str = (v) => v == null ? "" : String(v);
+function machineToolsForRole(role) {
+  if (role === "admin") return [...ALL_MACHINE_TOOLS];
+  if (role === "interact") return [...MACHINE_READ_ONLY, "send_to_session"];
+  return [...MACHINE_READ_ONLY];
+}
+function buildMachineTools(deps, skills) {
+  return [
+    {
+      name: "daemon_status",
+      readOnly: true,
+      description: 'Status of the svamp daemon on this machine: version, health, session count. Call first for "what is the machine / daemon doing".',
+      parameters: { type: "object", properties: {}, additionalProperties: false },
+      run: async () => JSON.stringify(await deps.daemonStatus())
+    },
+    {
+      name: "list_sessions",
+      readOnly: true,
+      description: "List all agent sessions on this machine (id, title, path). Use before acting on a specific session.",
+      parameters: { type: "object", properties: {}, additionalProperties: false },
+      run: async () => JSON.stringify(await deps.listSessions())
+    },
+    {
+      name: "read_session",
+      readOnly: true,
+      description: "Read the recent messages of a session by id (to inspect what an agent is doing).",
+      parameters: { type: "object", properties: { session_id: { type: "string" }, limit: { type: "number" } }, required: ["session_id"], additionalProperties: false },
+      run: async (a) => deps.readSession(str(a?.session_id), { limit: a?.limit })
+    },
+    {
+      name: "use_skill",
+      readOnly: true,
+      description: "Load a machine-level skill's full steps by name, then carry them out.",
+      parameters: { type: "object", properties: { name: { type: "string" } }, required: ["name"], additionalProperties: false },
+      run: async (a) => {
+        const s = findSkill(skills, str(a?.name));
+        return s ? s.body || `(skill "${s.name}" has no body)` : `No skill named "${str(a?.name)}".`;
+      }
+    },
+    {
+      name: "run_bash",
+      readOnly: false,
+      description: "Run a shell command on this machine (the daemon host). Returns stdout/stderr/exit code. For quick machine ops (status, disk, processes).",
+      parameters: { type: "object", properties: { command: { type: "string" }, cwd: { type: "string" } }, required: ["command"], additionalProperties: false },
+      run: async (a) => JSON.stringify(await deps.runBash(str(a?.command), { cwd: a?.cwd ? str(a.cwd) : void 0 }))
+    },
+    {
+      name: "send_to_session",
+      readOnly: false,
+      description: "Hand an instruction to a specific session's deep Claude agent (the slow, powerful worker) by id.",
+      parameters: { type: "object", properties: { session_id: { type: "string" }, message: { type: "string" } }, required: ["session_id", "message"], additionalProperties: false },
+      run: async (a) => deps.sendToSession(str(a?.session_id), str(a?.message))
+    },
+    {
+      name: "spawn_session",
+      readOnly: false,
+      description: "Start a new agent session in a directory on this machine.",
+      parameters: { type: "object", properties: { directory: { type: "string" } }, required: ["directory"], additionalProperties: false },
+      run: async (a) => JSON.stringify(await deps.spawnSession(str(a?.directory)))
+    }
+  ];
+}
+async function loadMachineContext(deps) {
+  const cwd = deps.cwd || "~";
+  let projectInstructions = "";
+  try {
+    const r = await deps.runBash('cat WISE.md "$HOME/.svamp/wise.md" 2>/dev/null || true', { cwd });
+    projectInstructions = parseWiseMd((r.stdout || "").trim()).body;
+  } catch {
+  }
+  let skills = [];
+  try {
+    const r = await deps.runBash(buildSkillsScanCommand(), { cwd });
+    skills = parseSkillsDump(r.stdout || "");
+  } catch {
+  }
+  return { projectInstructions, skills };
+}
+function buildMachineInstructions(ctx, extra) {
+  const base = `# Role & Objective
+You are WISE in machine-manager (global) mode \u2014 a fast cockpit over the svamp daemon on this machine. You answer about and operate the MACHINE: daemon status, running commands, and inspecting/spawning/driving any agent session \u2014 WITHOUT involving the slow, powerful Claude coding agent unless the user wants it (then use send_to_session).
+
+# Personality & Tone
+- A capable ops colleague \u2014 direct, concise, no preamble. 1\u20133 short sentences.
+- Summarize results; never paste raw JSON or long logs back.
+
+# Context
+- You are NOT bound to a session \u2014 you manage the whole machine and can see every session.
+- "the agent" / "the coding agent" = the deep Claude agent inside a session (slow but powerful). You are the fast lane beside all of them.
+
+# Tools
+- daemon_status \u2014 daemon health / version / session count. Use first for machine status.
+- list_sessions / read_session \u2014 see all sessions and inspect any one.
+- run_bash \u2014 run quick commands / scripts on the machine.
+- send_to_session(id, message) \u2014 delegate a task to a specific session's Claude agent.
+- spawn_session(directory) \u2014 start a new session.
+- use_skill \u2014 load a machine-level procedure.
+
+# Instructions
+- Take the cheap path: read status/sessions directly; only delegate to a Claude agent when the user wants deep work.
+- For destructive machine actions, confirm intent. Report the outcome in one line.
+- If a tool fails, say so plainly \u2014 never fabricate a result.`;
+  const parts = [base];
+  const custom = ctx.projectInstructions?.trim();
+  if (custom) parts.push(`# Machine notes (WISE.md)
+${custom}`);
+  if (extra?.trim()) parts.push(`# Extra brief
+${extra.trim()}`);
+  const skillsSection = buildSkillsPromptSection(ctx.skills);
+  if (skillsSection) parts.push(skillsSection);
+  return parts.join("\n\n");
+}
+async function runMachineAgent(args) {
+  let system;
+  let tools;
+  try {
+    const ctx = await loadMachineContext(args.deps);
+    system = buildMachineInstructions(ctx, args.extraSystem);
+    const allow = new Set(machineToolsForRole(args.role ?? "admin"));
+    tools = buildMachineTools(args.deps, ctx.skills).filter((t) => allow.has(t.name));
+  } catch (e) {
+    return { status: "error", reply: "", toolCalls: [], error: String(e?.message || e) };
+  }
+  return runToolLoop({ system, message: args.message, tools, transport: args.transport, model: args.model, timeoutSec: args.timeoutSec, maxSteps: args.maxSteps });
+}
+
+export { MUTATING_TOOLS as M, READ_ONLY_TOOLS as R, buildMachineTools as a, buildMachineInstructions as b, buildMachineDeps as c, loadWiseAgentContext as d, buildWiseAgentInstructions as e, buildTools as f, gateTools as g, runMachineAgent as h, loadMachineContext as l, machineToolsForRole as m, runWiseAgent as r };

package/dist/model-CUHojegn.mjs

@@ -0,0 +1,66 @@
+const DEFAULTS = {
+  // Fast, cheap default — the snappy companion tier.
+  "openai": { baseUrl: "https://api.openai.com", model: "gpt-5-mini" },
+  // Quota-governed gateway. NOTE: the Hypha proxy is Anthropic-shaped today; an
+  // OpenAI-compatible route may be required for non-Claude models (docs §6).
+  "hypha-proxy": { baseUrl: "", model: "gpt-5-mini" },
+  // Fallback when no OpenAI access — Claude Haiku via the same proxy path.
+  "claude-haiku": { baseUrl: "", model: "claude-haiku-4-5" }
+};
+const DEFAULT_OPENAI_BASE = "https://api.openai.com";
+function resolveModel(config, env) {
+  const provider = config?.provider || env.WISE_AGENT_PROVIDER || "openai";
+  const d = DEFAULTS[provider] || DEFAULTS.openai;
+  const model = config?.model || env.WISE_AGENT_MODEL || d.model;
+  let baseUrl = env.WISE_AGENT_BASE_URL || "";
+  let apiKey = env.WISE_AGENT_API_KEY || "";
+  if (provider === "openai") {
+    baseUrl = baseUrl || env.OPENAI_BASE_URL || env.OPENAI_API_BASE || d.baseUrl;
+    apiKey = apiKey || env.OPENAI_API_KEY || "";
+  } else if (provider === "hypha-proxy" || provider === "claude-haiku") {
+    baseUrl = baseUrl || (env.SVAMP_HYPHA_PROXY_URL || "").replace(/\/+$/, "");
+    apiKey = apiKey || env.HYPHA_TOKEN || "";
+  } else {
+    baseUrl = baseUrl || d.baseUrl;
+  }
+  baseUrl = baseUrl.replace(/\/v1\/?$/, "");
+  return { provider, baseUrl, apiKey, model };
+}
+function describeMisconfiguration(resolved) {
+  const { provider, baseUrl, apiKey } = resolved;
+  if (!baseUrl) {
+    if (provider === "hypha-proxy" || provider === "claude-haiku") {
+      return `WISE Agent (${provider}) is not configured: no proxy base URL. Run \`svamp wise-agent auth use-hypha-proxy <URL>\` (or set SVAMP_HYPHA_PROXY_URL), then \`svamp daemon restart\`.`;
+    }
+    return "WISE Agent is not configured: no base URL. Run `svamp wise-agent auth set <URL> <KEY>` (or set WISE_AGENT_BASE_URL / OPENAI_BASE_URL), then `svamp daemon restart`.";
+  }
+  if (provider === "hypha-proxy" || provider === "claude-haiku") {
+    if (!apiKey) return `WISE Agent (${provider}) is not configured: no auth token. Ensure HYPHA_TOKEN is set (\`svamp login\`), then \`svamp daemon restart\`.`;
+    return null;
+  }
+  if (!apiKey && baseUrl.replace(/\/v1\/?$/, "") === DEFAULT_OPENAI_BASE) {
+    return "WISE Agent is not configured: no OpenAI API key. Run `svamp wise-agent auth use-openai <KEY>` (or set OPENAI_API_KEY / WISE_AGENT_API_KEY), then `svamp daemon restart`.";
+  }
+  return null;
+}
+function makeHttpTransport(resolved, fetchImpl = fetch) {
+  return async (req) => {
+    if (!resolved.baseUrl) throw new Error(`WISE Agent: no base URL for provider "${resolved.provider}" (set WISE_AGENT_BASE_URL or SVAMP_HYPHA_PROXY_URL)`);
+    const url = `${resolved.baseUrl}/v1/chat/completions`;
+    const res = await fetchImpl(url, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...resolved.apiKey ? { authorization: `Bearer ${resolved.apiKey}` } : {}
+      },
+      body: JSON.stringify({ ...req, model: req.model || resolved.model })
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`WISE Agent chat ${res.status}: ${text.slice(0, 300)}`);
+    }
+    return await res.json();
+  };
+}
+
+export { describeMisconfiguration as d, makeHttpTransport as m, resolveModel as r };

package/dist/{notifyCommands-0aZUwKQK.mjs → notifyCommands-D-IKIxiq.mjs}

@@ -1,25 +1,10 @@
-import { c as connectToHypha, S as SharingNotificationSync, N as parseJwtEmail } from './run-CF4kAVPW.mjs';
+import { c as connectToHypha } from './hyphaClient-ybivOjZo.mjs';
+import { S as SharingNotificationSync } from './sharingNotificationSync-qGIQ-3yf.mjs';
+import { p as parseJwtEmail } from './serveAuth-DbVLRCRR.mjs';
 import { randomUUID } from 'node:crypto';
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import os from 'node:os';
-import 'os';
-import 'fs/promises';
-import 'fs';
-import 'path';
-import 'url';
-import 'child_process';
-import 'crypto';
-import 'node:child_process';
-import 'util';
-import 'http';
-import 'net';
-import 'node:events';
-import '@agentclientprotocol/sdk';
-import 'node:util';
-import 'node:readline';
-import 'node:fs/promises';
-import 'yaml';
 
 function loadEnv() {
   const SVAMP_HOME = process.env.SVAMP_HOME || join(os.homedir(), ".svamp");