@agentprojectcontext/apx 1.33.0 → 1.34.0

package/src/host/daemon/api/voice.js

@@ -1,5 +1,3 @@
-// eslint-disable-next-line -- import below
-import { CHANNELS } from "#core/constants/channels.js";
 // Daemon HTTP routes for the unified "voice" channel.
 //
 //   POST /voice/turn  { audio?: <base64 or path>, format?, text?, agent?,
@@ -17,268 +15,21 @@ import { CHANNELS } from "#core/constants/channels.js";
 //
 // Channel/agent surfaces (Telegram plugin, overlay) can keep their own
 // pipelines, but they should delegate here when they want a hablada reply.
+//
+// Domain logic (channel context, suggestion parsing, audio decoding) lives in
+// core/. This file is just glue: parse request → call core → format response.
 import fs from "node:fs";
 import path from "node:path";
-import os from "node:os";
-import { randomUUID } from "node:crypto";
 import { readConfig } from "#core/config/index.js";
 import { synthesize } from "#core/voice/tts.js";
-import { transcribe } from "../transcription.js";
+import { transcribe } from "#core/voice/transcription.js";
+import { decodeAudioInput } from "#core/voice/audio-decode.js";
 import { runSuperAgent, isSuperAgentEnabled } from "#core/agent/super-agent.js";
+import { buildVoiceChannelContext } from "#core/agent/channels/voice-context.js";
+import { extractSuggestions } from "#core/agent/suggestions.js";
 import { appendGlobalMessage } from "#core/stores/messages.js";
 import { appendErrorTrace, previewText } from "#core/logging.js";
 
-// ── Channel-aware pre-processor ────────────────────────────────────
-//
-// Each surface that talks to the super-agent (voice overlay on the
-// deck, deck buttons, telegram, raw API) has different ergonomics:
-// what the response will look like, how long it can be, whether the
-// UI can render structured suggestions. `buildChannelContext` is the
-// single place where those decisions live — voice.js passes the
-// channel string from the request body and gets back the context
-// note + system suffix to feed into the super-agent.
-//
-// The shape is intentionally tiny: contextNote becomes the
-// `contextNote` field on the super-agent call (gets prepended to the
-// prompt), systemSuffix is concatenated onto the system prompt to
-// teach the model surface-specific output rules (e.g. trailing
-// ```suggestions JSON block``` on voice/deck).
-function buildChannelContext(channel, { projectId, language = "es" } = {}) {
-  const base = {
-    contextNote: "",
-    systemSuffix: "",
-    wantsSuggestions: false,
-    // Channel id forwarded to runSuperAgent so the matching channels/*.md
-    // formatting block is injected.
-    channel: "",
-    // Forwarded as channelMeta; { voice: true } flags spoken mode.
-    channelMeta: {},
-  };
-  // Project resolution hint.
-  //   - per-project mic (projectId set): use it imperatively, don't ask.
-  //   - global deck mic (no projectId): default to project id=0
-  //     ("default") for actions unless the user names a project out
-  //     loud. Either way, don't pester the user with "¿en qué
-  //     proyecto?" — pick a sensible default and act.
-  const projectHint = projectId
-    ? `\nThe active project is id=${projectId}. For ANY task/note/list ` +
-      `action, pass project_id=${projectId} automatically. Do NOT ask the ` +
-      `user which project — only switch if they explicitly name another.`
-    : `\nThis is the GLOBAL mic (no project in focus). For task/note/list ` +
-      `actions, default to project_id=0 ("default") UNLESS the user names ` +
-      `a project out loud (e.g. "en evolution-registry…", "en el proyecto ` +
-      `apx…") — then resolve that project by name. Never ask "¿en qué ` +
-      `proyecto?"; pick the default and act.`;
-  // Hard language directive — without this the model defaults to its
-  // training-bias English on short Spanish prompts, especially when
-  // the user mixes English-ish product names ("aicrm").
-  const langDirective = language === "es"
-    ? "IMPORTANT: Reply ALWAYS in Spanish (rioplatense/Argentina). The user speaks Spanish."
-    : `IMPORTANT: Reply in language "${language}".`;
-
-  // Surface mapping. Channels are surfaces; "voice" is NOT a surface — it's the
-  // spoken MODE of the deck. All channel FORMATTING now lives in the
-  // channels/*.md + modes/voice.md blocks (injected by buildSuperAgentSystem);
-  // contextNote here carries ONLY per-request dynamic bits (language + project).
-  //   incoming "voice"   → deck surface, spoken
-  //   incoming "deck"    → deck surface, text card
-  //   incoming "desktop" → desktop module, spoken (voice-first)
-  const dynamicNote = `${langDirective}${projectHint}`;
-  switch (channel) {
-    case "voice":
-      return { ...base, contextNote: dynamicNote, systemSuffix: SUGGESTIONS_INSTRUCTION, wantsSuggestions: true, channel: CHANNELS.DECK, channelMeta: { voice: true } };
-    case "deck":
-      return { ...base, contextNote: dynamicNote, systemSuffix: SUGGESTIONS_INSTRUCTION, wantsSuggestions: true, channel: CHANNELS.DECK, channelMeta: {} };
-    case "desktop":
-      return { ...base, contextNote: dynamicNote, systemSuffix: SUGGESTIONS_INSTRUCTION, wantsSuggestions: true, channel: CHANNELS.DESKTOP, channelMeta: { voice: true } };
-    case "telegram":
-      // Format rules live in channels/telegram.md; keep only the dynamic note.
-      return { ...base, contextNote: dynamicNote, channel: CHANNELS.TELEGRAM, channelMeta: {} };
-    default:
-      return { ...base, contextNote: dynamicNote, channel: channel || "api", channelMeta: {} };
-  }
-}
-
-// Balanced suffix. An earlier, more aggressive version ("EJECUTA, no
-// narres — LLAMÁ A LA TOOL") made Gemini call tools for EVERYTHING,
-// even "hola" → it fired send_telegram("hola"). The rule below gates
-// tool use on a *clear* action request and explicitly tells the model
-// to just talk for chit-chat.
-const SUGGESTIONS_INSTRUCTION = `
-
-# Cuándo usar tools
-SOLO llamá una tool cuando el usuario pide CLARAMENTE una acción
-concreta: "creá una tarea …", "mandá un telegram …", "listá …",
-"abrí …", "marcá como hecha …". En esos casos ejecutá la tool (no
-digas "lo voy a hacer" — hacelo) y después confirmá en una frase corta
-en castellano lo que YA hiciste.
-
-Si el mensaje es un saludo, una pregunta, o charla ("hola", "cómo
-andás", "qué podés hacer") NO llames ninguna tool: respondé en texto,
-breve, en castellano.
-
-Nunca llames la misma tool dos veces en el mismo turno.
-
-# Sugerencias (opcional)
-Al final, en su propia línea, podés agregar un bloque fenced
-\`suggestions\` con 2-3 próximos pasos. El usuario NO lo ve (la deck lo
-quita):
-\`\`\`suggestions
-[{"label":"Ver tareas","command":"deck.view:tasks"}]
-\`\`\`
-Si no hay próximos pasos útiles, omití el bloque.`;
-
-// Pull the trailing ```suggestions ... ``` block off the agent's
-// reply. Returns { cleanText, suggestions[] } — cleanText is the
-// reply with the block removed so the user (and TTS) never sees it.
-const SUGGESTIONS_BLOCK_RE = /\n*```\s*suggestions\s*\n([\s\S]*?)\n?```\s*$/i;
-
-function extractSuggestions(text) {
-  if (typeof text !== "string" || !text) return { cleanText: text || "", suggestions: [] };
-  const m = SUGGESTIONS_BLOCK_RE.exec(text);
-  if (!m) return { cleanText: text, suggestions: [] };
-  const cleanText = text.slice(0, m.index).trim();
-  let suggestions = [];
-  try {
-    const parsed = JSON.parse(m[1]);
-    if (Array.isArray(parsed)) {
-      suggestions = parsed
-        .filter((s) => s && typeof s === "object" && typeof s.label === "string")
-        .slice(0, 4)
-        .map((s) => ({
-          label: String(s.label).slice(0, 48),
-          ...(typeof s.command === "string" ? { command: s.command.slice(0, 96) } : {}),
-        }));
-    }
-  } catch {
-    // Malformed JSON — drop suggestions silently rather than fail the
-    // turn. Better UX to show the reply without chips than an error.
-  }
-  return { cleanText, suggestions };
-}
-
-// ── Voice intent classifier ────────────────────────────────────────
-//
-// A very small, regex-based router that catches a handful of "verb-y"
-// utterances we want to short-circuit instead of sending to the LLM.
-// Right now: "crear tarea ...", "creá tarea ...", "agregá una tarea ...",
-// "nueva tarea ..." → POST to the project's tasks store directly.
-//
-// The classifier always returns either:
-//   - { handled: false } → caller falls through to the super-agent
-//   - { handled: true, reply: "...", meta?: {...} } → caller returns
-//
-// Keeping it dependency-free + sync lets us run it before any heavy
-// work in the voice handler.
-const TASK_INTENT_RE = new RegExp(
-  // Optional polite preamble: "podés / por favor"
-  "^\\s*(?:por favor|porfa|porfis|dale|che|apx)?[,!\\s]*" +
-    // Either:
-    //   (a) verb cluster + optional article + "tarea"
-    //   (b) standalone "nueva|otra tarea" (no verb)
-    "(?:" +
-      // (a) verbs — with optional clitic pronouns (-me, -te, -le)
-      "(?:crea[r]?|cre[áa]|agreg[áa](?:me|le)?|agreg[uú]e|sum[áa](?:me)?|" +
-      "anot[áa](?:me)?|an[oó]tame|guard[áa](?:me)?|met[ée](?:me)?|" +
-      "añad[íi]|añad[ée]|pone(?:me|le)?|recor[dáa]me)" +
-      "\\s+(?:una|la|el|esta|ese|otra|otro)?\\s*" +
-      "(?:tarea|task|pendiente|todo|to-do)" +
-    "|" +
-      // (b) "nueva tarea X" / "otra tarea X" without a verb
-      "(?:nueva|otra|nuevo)\\s+(?:tarea|task|pendiente)" +
-    ")" +
-    // Optional connectors before the title
-    "\\s+(?:que\\s+(?:diga|sea|es)|para|de|sobre|llamada|titulada|titul[áa]da|:|-|de:)?\\s*",
-  "i"
-);
-
-function extractTaskTitle(text) {
-  if (typeof text !== "string") return null;
-  const cleaned = text.trim().replace(/^[«"']|[«"'.,;:!?]+$/g, "");
-  if (!cleaned) return null;
-  const m = TASK_INTENT_RE.exec(cleaned);
-  if (!m) return null;
-  const title = cleaned.slice(m[0].length).trim().replace(/[.!?]+$/, "");
-  if (!title) return null;
-  return title;
-}
-
-function pickIntentProject({ projects, hintId }) {
-  if (!projects?.list) return null;
-  const list = projects.list();
-  if (hintId !== undefined && hintId !== null) {
-    const hit = list.find((p) => String(p.id) === String(hintId));
-    if (hit) return hit;
-  }
-  // Prefer the first non-default real project; fall back to default.
-  return list.find((p) => Number(p.id) !== 0) || list[0] || null;
-}
-
-async function tryVoiceTaskIntent({ projects, userText, hintProjectId }) {
-  const title = extractTaskTitle(userText);
-  if (!title) return { handled: false };
-  const listEntry = pickIntentProject({ projects, hintId: hintProjectId });
-  if (!listEntry) {
-    return {
-      handled: true,
-      reply: "No hay proyectos APX registrados. Agregá uno con `apx project add` y volvé a intentar.",
-    };
-  }
-  // projects.list() returns flat entries without storagePath; the
-  // resolver returns the full record. We need that for the JSONL store.
-  const project = projects.get(listEntry.id) || listEntry;
-  if (!project?.storagePath) {
-    return {
-      handled: true,
-      reply: `No pude crear la tarea: no encuentro el storage del proyecto ${project?.name || listEntry.name}.`,
-    };
-  }
-  try {
-    const { createTask } = await import("#core/stores/tasks.js");
-    const task = createTask(project.storagePath, {
-      title,
-      source: "voice",
-    });
-    // Resolver may strip the human-readable name; fall back to the
-    // list entry which always has it.
-    const displayName = project.name || listEntry.name || `proyecto #${project.id}`;
-    return {
-      handled: true,
-      reply: `Listo. Anoté "${title}" en ${displayName}.`,
-      meta: { task_id: task.id, project_id: project.id },
-    };
-  } catch (e) {
-    return {
-      handled: true,
-      reply: `No pude crear la tarea: ${e.message || "error desconocido"}`,
-    };
-  }
-}
-
-async function decodeAudioInput({ audio, format = "webm" }) {
-  if (!audio) return null;
-  // A short string that starts with "/" and exists on disk is treated as a
-  // path. Anything else is interpreted as base64 (optionally with a data:
-  // prefix).
-  if (
-    typeof audio === "string" &&
-    audio.length < 1024 &&
-    audio.startsWith("/") &&
-    fs.existsSync(audio)
-  ) {
-    return { path: audio, cleanup: false };
-  }
-  let b64 = audio;
-  const m = /^data:[^;]+;base64,(.+)$/.exec(b64);
-  if (m) b64 = m[1];
-  const buf = Buffer.from(b64, "base64");
-  if (!buf.length) throw new Error("voice/turn: decoded audio is empty");
-  const ext = String(format || "webm").replace(/^\./, "");
-  const tmp = path.join(os.tmpdir(), `apx-voice-${Date.now()}-${randomUUID()}.${ext}`);
-  fs.writeFileSync(tmp, buf);
-  return { path: tmp, cleanup: true };
-}
-
 export function register(app, { projects, plugins, registries }) {
   // GET /voice/tts?path=<abs>
   //
@@ -345,45 +96,20 @@ export function register(app, { projects, plugins, registries }) {
         });
       }
 
-      // ── 1.5 Intent classifier (DISABLED) ──────────────────────────
-      // We used to regex-match "creá una tarea X" here and short-circuit
-      // the LLM. That fired far too eagerly — any sentence containing
-      // those words became a task title, even when the user's actual
-      // intent was different ("explicame cómo funciona crear una
-      // tarea" would create a bogus task).
-      //
-      // The right path is the agent's own tool calling: the super-agent
-      // already has `create_task`, `send_telegram`, `list_tasks`, etc.
-      // in its CORE schema (see super-agent-tools/index.js). We let
-      // the model decide; the system prompt below pushes it toward
-      // tool use instead of narrating the action in prose.
-      const intentResult = { handled: false };
       let replyText = "";
       const previousMessages = Array.isArray(body.previousMessages)
         ? body.previousMessages
         : [];
       const channel = body.channel || "voice";
-
-      let intentMeta = null;
       let suggestions = [];
       let toolsUsed = [];
-      const channelCtx = buildChannelContext(channel, {
+
+      const channelCtx = buildVoiceChannelContext(channel, {
         projectId: body.projectId,
         language: body.language && body.language !== "auto" ? body.language : "es",
       });
-      if (intentResult.handled) {
-        replyText = intentResult.reply;
-        intentMeta = intentResult.meta || null;
-        // Intent shortcut bypasses the LLM, so no model-generated
-        // suggestions either; we hand-craft a couple based on the
-        // outcome so the chips area isn't empty.
-        if (intentMeta?.task_id) {
-          suggestions = [
-            { label: "Ver tareas", command: "deck.view:tasks" },
-            { label: "Anotar otra", command: "voice.again" },
-          ];
-        }
-      } else if (isSuperAgentEnabled(cfg)) {
+
+      if (isSuperAgentEnabled(cfg)) {
         try {
           const result = await runSuperAgent({
             globalConfig: cfg,
@@ -423,9 +149,7 @@ export function register(app, { projects, plugins, registries }) {
             // text to TTS — synthesize a generic confirmation so the
             // user gets audible feedback that something happened.
             if (!replyText && raw) {
-              replyText = suggestions.length
-                ? "Listo."
-                : raw;
+              replyText = suggestions.length ? "Listo." : raw;
             }
           } else {
             replyText = raw;
@@ -493,10 +217,9 @@ export function register(app, { projects, plugins, registries }) {
         reply_mime: tts.mime,
         provider: tts.provider,
         tts_error: tts.error || undefined,
-        intent: intentMeta || undefined,
         suggestions: suggestions.length ? suggestions : undefined,
         tools_used: toolsUsed.length ? toolsUsed : undefined,
-        channel: channel,
+        channel,
       });
     } catch (e) {
       res.status(500).json({ error: e.message });

package/src/host/daemon/api.js

@@ -18,6 +18,7 @@ import { register as registerProjects } from "./api/projects.js";
 import { register as registerAgents } from "./api/agents.js";
 import { register as registerSessions } from "./api/sessions.js";
 import { register as registerMcps } from "./api/mcps.js";
+import { register as registerVars } from "./api/vars.js";
 import { register as registerMessages } from "./api/messages.js";
 import { register as registerTelegram } from "./api/telegram.js";
 import { register as registerPlugins } from "./api/plugins.js";
@@ -106,6 +107,7 @@ export function buildApi({
   registerAgents(app, ctx);
   registerSessions(app, ctx);
   registerMcps(app, ctx);
+  registerVars(app, ctx);
   registerMessages(app, ctx);
   registerEngines(app, ctx);
   registerSkills(app, ctx);

package/src/host/daemon/db.js

@@ -5,6 +5,7 @@ import path from "node:path";
 import { appendMessageToFs } from "#core/stores/messages.js";
 import { effectiveConfig } from "./project-config.js";
 import { readAgents } from "#core/apc/parser.js";
+import { apcDir, apcProjectFile, apcAgentsDir, apcCommandsDir } from "#core/apc/paths.js";
 import { getOrCreateApxId } from "#core/apc/scaffold.js";
 import {
   ensureProjectStorage,
@@ -30,12 +31,12 @@ export class ProjectManager {
   register(projectPath) {
     const abs = path.resolve(projectPath);
     if (this.byPath.has(abs)) return this.byPath.get(abs);
-    const projectJson = path.join(abs, ".apc", "project.json");
+    const projectJson = apcProjectFile(abs);
     if (!fs.existsSync(projectJson)) {
       throw new Error(`not an APC project: ${abs}`);
     }
     // Ensure directories exist for projects initialized before they were added.
-    fs.mkdirSync(path.join(abs, ".apc", "commands"), { recursive: true });
+    fs.mkdirSync(apcCommandsDir(abs), { recursive: true });
 
     // Resolve stable APX storage ID (read from .apc/project.json).
     const apxId = getOrCreateApxId(abs);
@@ -72,9 +73,8 @@ export class ProjectManager {
     if (this.byId.has(0)) return this.byId.get(0);
     // Create a minimal APC-compatible structure inside the storage root so that
     // readAgents() and other parser functions work without a separate project dir.
-    const apcDir = path.join(DEFAULT_PROJECT_STORE, ".apc");
-    fs.mkdirSync(path.join(apcDir, "agents"), { recursive: true });
-    const projectJson = path.join(apcDir, "project.json");
+    fs.mkdirSync(apcAgentsDir(DEFAULT_PROJECT_STORE), { recursive: true });
+    const projectJson = apcProjectFile(DEFAULT_PROJECT_STORE);
     if (!fs.existsSync(projectJson)) {
       fs.writeFileSync(
         projectJson,
@@ -113,7 +113,7 @@ export class ProjectManager {
       let kind = e.id === 0 ? "default" : "other";
       try {
         const meta = JSON.parse(
-          fs.readFileSync(path.join(e.path, ".apc", "project.json"), "utf8")
+          fs.readFileSync(apcProjectFile(e.path), "utf8")
         );
         if (meta.name) name = meta.name;
         if (typeof meta.kind === "string" && meta.kind.trim()) {

package/src/host/daemon/deck-exec.js

@@ -0,0 +1,148 @@
+// /deck/exec implementation.
+//
+// All shell spawning sits behind this helper so api/deck.js stays a thin HTTP
+// adapter. The OS abstraction is intentionally tiny: pick the "opener" command
+// for the platform and pass `target` as a single arg (no shell). For
+// app-launching on macOS we use `open -a <App>`.
+//
+// Stays in host/daemon/ because it's pure process orchestration (spawn child
+// processes), not domain logic.
+import { spawn } from "node:child_process";
+
+const MAC_APPS = {
+  // Whitelisted mac app names. Adding here is the only way the deck can
+  // launch something — we never honour a free-form `app` string.
+  claude: "Claude",
+  chatgpt: "ChatGPT",
+  cursor: "Cursor",
+  vscode: "Visual Studio Code",
+  zen: "Zen Browser",
+  terminal: "Terminal",
+  iterm: "iTerm",
+  finder: "Finder",
+};
+
+function platformOpener() {
+  if (process.platform === "darwin") return "open";
+  if (process.platform === "win32") return "start";
+  return "xdg-open";
+}
+
+function spawnDetached(cmd, args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, { stdio: "ignore", detached: true });
+    let settled = false;
+    const done = (err) => {
+      if (settled) return;
+      settled = true;
+      err ? reject(err) : resolve();
+    };
+    child.on("error", done);
+    // Give the process a tick to fail-fast (bad binary); otherwise detach.
+    setTimeout(() => {
+      try { child.unref(); } catch {}
+      done(null);
+    }, 250);
+  });
+}
+
+/** Pipe `text` into the platform clipboard (pbcopy / xclip / clip). */
+export async function copyToClipboard(text) {
+  const platform = process.platform;
+  const cmd =
+    platform === "darwin" ? "pbcopy" :
+    platform === "win32" ? "clip" :
+    "xclip";
+  const args = platform === "linux" ? ["-selection", "clipboard"] : [];
+  await new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, { stdio: ["pipe", "ignore", "ignore"] });
+    child.on("error", reject);
+    child.on("close", (code) => (code === 0 ? resolve() : reject(new Error(`${cmd} exited ${code}`))));
+    child.stdin.end(text);
+  });
+}
+
+/**
+ * Dispatch one /deck/exec action. `ctx.projects` is the daemon's
+ * ProjectManager — used to resolve numeric project ids to absolute paths.
+ *
+ * Supported kinds:
+ *   open_app      { target: "<appKey>" }                        — mac only
+ *   open_path     { target: "<absPath>" | "<projectId>" }       — opens in Finder/default
+ *   open_path_in  { target: "<projectId>", app: "<appKey>" }    — mac only
+ *   open_url      { target: "https://..." }
+ *   copy_clipboard { text: "..." }
+ */
+export async function runDeckExec({ kind, target, appHint, text, ctx }) {
+  const platform = process.platform;
+
+  // Resolve a project id (number or "<n>") into an absolute path via
+  // the daemon's project manager. Returns null when the id is bogus.
+  const projectPath = (idOrPath) => {
+    if (!idOrPath) return null;
+    const str = String(idOrPath);
+    if (str.startsWith("/")) return str;
+    if (!/^\d+$/.test(str)) return null;
+    const p = ctx.projects?.get?.(parseInt(str, 10));
+    return p?.path || null;
+  };
+
+  if (kind === "open_app") {
+    if (platform !== "darwin") throw new Error("open_app only implemented on macOS for now");
+    const appName = MAC_APPS[String(target || "").toLowerCase()];
+    if (!appName) throw new Error(`unknown app: ${target}`);
+    // Two-step launch:
+    //   1. `open -a` ensures the app is running (no-op if already up).
+    //   2. AppleScript `activate` brings it to the foreground across
+    //      Spaces / Stage Manager, which `open` alone often skips when
+    //      the app was already running in the background.
+    await spawnDetached("open", ["-a", appName]);
+    try {
+      await new Promise((resolve) => {
+        const child = spawn("osascript", [
+          "-e",
+          `tell application "${appName}" to activate`,
+        ], { stdio: "ignore" });
+        child.on("close", () => resolve());
+        child.on("error", () => resolve());
+        setTimeout(() => { try { child.kill(); } catch {} ; resolve(); }, 600);
+      });
+    } catch {
+      // osascript missing or refused — `open -a` already ran.
+    }
+    return { app: appName };
+  }
+
+  if (kind === "open_path") {
+    const resolved = projectPath(target);
+    if (!resolved) throw new Error(`open_path: invalid target ${target}`);
+    await spawnDetached(platformOpener(), [resolved]);
+    return { path: resolved };
+  }
+
+  if (kind === "open_path_in") {
+    if (platform !== "darwin") throw new Error("open_path_in only implemented on macOS for now");
+    const resolved = projectPath(target);
+    if (!resolved) throw new Error(`open_path_in: invalid target ${target}`);
+    const appName = MAC_APPS[String(appHint || "").toLowerCase()];
+    if (!appName) throw new Error(`open_path_in: unknown app ${appHint}`);
+    await spawnDetached("open", ["-a", appName, resolved]);
+    return { app: appName, path: resolved };
+  }
+
+  if (kind === "open_url") {
+    if (!target || !/^https?:\/\//i.test(String(target))) {
+      throw new Error("open_url: target must be http(s) URL");
+    }
+    await spawnDetached(platformOpener(), [String(target)]);
+    return { url: target };
+  }
+
+  if (kind === "copy_clipboard") {
+    if (typeof text !== "string") throw new Error("copy_clipboard: text required");
+    await copyToClipboard(text);
+    return { bytes: text.length };
+  }
+
+  throw new Error(`unknown kind: ${kind}`);
+}

package/src/host/daemon/index.js

@@ -18,7 +18,7 @@ import {
 import { ProjectManager } from "./db.js";
 import { McpRegistry } from "#core/mcp/runner.js";
 import { PluginManager } from "./plugins/index.js";
-import { RoutineScheduler } from "./routines.js";
+import { RoutineScheduler } from "./routines-scheduler.js";
 import { buildApi } from "./api.js";
 import { createTokenStore } from "./token-store.js";
 import { triggerWakeup } from "./wakeup.js";
@@ -222,7 +222,7 @@ async function main() {
     setTimeout(() => triggerWakeup(cfg, log), 3000);
     // Preload whisper-server in the background so first desktop transcription is fast.
     // Adopts an existing one if already on the port; otherwise spawns fresh.
-    import("./transcription.js").then(({ preloadWhisperServer }) => {
+    import("./whisper-server.js").then(({ preloadWhisperServer }) => {
       preloadWhisperServer((m) => log(m));
     }).catch(() => {});
   });
@@ -257,7 +257,7 @@ async function main() {
     stopMemory();
     registries.shutdown();
     // Best-effort shutdown of whisper-server subprocess.
-    import("./transcription.js").then(({ shutdownWhisperServer }) => {
+    import("./whisper-server.js").then(({ shutdownWhisperServer }) => {
       shutdownWhisperServer().catch(() => {});
     }).catch(() => {});
     server.close(() => {