@fancyboi999/open-tag-daemon 0.7.1 → 0.8.0

package/dist/agent-cli.mjs

@@ -3047,7 +3047,7 @@ var {
 } = import_index.default;
 
 // src/cli/index.ts
-import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { readFile, writeFile, mkdir, appendFile } from "node:fs/promises";
 import { basename, join } from "node:path";
 
 // src/log.ts
@@ -3110,6 +3110,7 @@ var log = createLogger("cli");
 var BASE = process.env.OPEN_TAG_SERVER_URL ?? "http://localhost:7777";
 var KEY = process.env.OPEN_TAG_AGENT_TOKEN ?? process.env.OPEN_TAG_MACHINE_KEY ?? process.env.OPEN_TAG_API_KEY ?? "poc-secret-key";
 var AGENT = process.env.OPEN_TAG_AGENT_ID ?? "";
+var TURN_FILE = process.env.OPEN_TAG_TURN_FILE ?? "";
 function headers() {
   return { authorization: `Bearer ${KEY}`, "x-agent-id": AGENT, "content-type": "application/json" };
 }
@@ -3147,12 +3148,28 @@ function readStdin() {
     process.stdin.on("end", () => resolve(d));
   });
 }
+function targetFromText(text) {
+  const m = /^\[target=([^\s\]]+)/.exec(text);
+  return m?.[1] ?? null;
+}
+async function recordTurnEvent(event) {
+  if (!TURN_FILE) return;
+  try {
+    await appendFile(TURN_FILE, JSON.stringify({ ...event, at: Date.now() }) + "\n");
+  } catch {
+  }
+}
 var program2 = new Command();
 program2.name("open-tag").description("open-tag agent CLI").version("0.1.0");
 var message = program2.command("message").description("message send/receive");
 message.command("check").description("non-blocking check for new messages").action(async () => {
   const d = await api("GET", "/agent-api/message/check");
-  if (!d.messages?.length) return console.log("No new messages.");
+  if (!d.messages?.length) {
+    await recordTurnEvent({ type: "check", count: 0 });
+    return console.log("No new messages.");
+  }
+  const targets = Array.from(new Set((d.messages ?? []).map((m) => targetFromText(String(m.text ?? ""))).filter(Boolean)));
+  await recordTurnEvent({ type: "check", count: d.messages.length, target: targets[targets.length - 1] ?? null, targets });
   for (const m of d.messages) console.log(m.text);
   console.log("No more new messages.");
 });
@@ -3166,7 +3183,11 @@ message.command("send").description("send a message (body read from stdin); if n
     process.exit(1);
   }
   const d = await api("POST", "/agent-api/message/send", { target: opts.target, content, attachmentIds, sendDraft });
-  if (d.held) return console.log(d.text);
+  if (d.held) {
+    await recordTurnEvent({ type: "held", target: opts.target });
+    return console.log(d.text);
+  }
+  await recordTurnEvent({ type: "send", target: opts.target, id: d.id, seq: d.seq });
   console.log(`Sent to ${opts.target} (msg ${String(d.id).slice(0, 8)}, seq ${d.seq})`);
 });
 message.command("read").description("read channel history (supports anchor flags --before/--after/--around: message short/full id or seq, jumps to the specified context)").requiredOption("--channel <channel>").option("--limit <n>", "number of messages", "50").option("--around <idOrSeq>", "fetch context centered on this message").option("--before <idOrSeq>", "fetch messages before this one").option("--after <idOrSeq>", "fetch messages after this one").action(async (opts) => {
@@ -3175,6 +3196,7 @@ message.command("read").description("read channel history (supports anchor flags
   else if (opts.before) q.set("before", opts.before);
   else if (opts.after) q.set("after", opts.after);
   const d = await api("GET", `/agent-api/message/read?${q}`);
+  await recordTurnEvent({ type: "read", target: opts.channel, count: d.messages?.length ?? 0 });
   for (const m of d.messages ?? []) console.log(m.text);
 });
 message.command("react").description("add or remove a reaction emoji on a message (lightweight feedback)").requiredOption("--message-id <id>").requiredOption("--emoji <emoji>", "e.g. \u{1F44D} \u2705").option("--remove", "remove the reaction instead of adding it").action(async (opts) => {

package/dist/cli.mjs

@@ -3725,7 +3725,7 @@ try {
 // src/daemon/index.ts
 import os4 from "node:os";
 import fs3 from "node:fs";
-import path12 from "node:path";
+import path14 from "node:path";
 
 // node_modules/ws/wrapper.mjs
 var import_stream = __toESM(require_stream(), 1);
@@ -3913,8 +3913,8 @@ var Connection = class {
 };
 
 // src/daemon/agentManager.ts
-import { mkdir, writeFile, readFile, access, rm } from "node:fs/promises";
-import path10 from "node:path";
+import { mkdir, writeFile, readFile as readFile2, access, rm } from "node:fs/promises";
+import path11 from "node:path";
 import os2 from "node:os";
 
 // src/daemon/prompt.ts
@@ -4033,6 +4033,7 @@ ${c.description}. This may evolve.` : ""}`;
 }
 var STARTUP_NUDGE = "You just started \u2014 someone messaged you. FIRST run `open-tag message check` to read the message(s) waiting for you, handle them fully, reply with `open-tag message send`, then stop.";
 var RESUME_NUDGE = "You were woken because new messages may be waiting. Run `open-tag message check` to read them, handle them, reply with `open-tag message send`, then stop.";
+var ONE_SHOT_WAKE_NUDGE = "You were woken by a new open-tag delivery. FIRST run `open-tag message check` now, handle the pending message(s), and send exactly one reply with `open-tag message send`. Do not end this turn with stdout only; only `open-tag message send` reaches the human.";
 function inboxNotice(o) {
   const plural = (n) => n === 1 ? "" : "s";
   const changed = o.changedTargets ?? 1;
@@ -4043,7 +4044,7 @@ function inboxNotice(o) {
 Inbox update: ${o.count} unread message${plural(o.count)} total; ${changed} changed target${plural(changed)}
 ${o.targetName}  pending: ${o.count} message${plural(o.count)}${first} \xB7 latest @${o.from}${latest}${suffix}
 ]
-Content-free signal \u2014 message bodies are withheld, not absent. Finish your current step, then run \`open-tag message check\` to read and handle. Never conclude "no work" from this notice alone.`;
+Content-free signal \u2014 message bodies are withheld, not absent. Finish your current step, then run \`open-tag message check\` to read and handle. If this notice is the only thing in your current turn, check now and reply with \`open-tag message send\`; do not finish with stdout only. Never conclude "no work" from this notice alone.`;
 }
 
 // src/daemon/memory.ts
@@ -5376,6 +5377,302 @@ var cursorRuntime = {
   }
 };
 
+// src/daemon/hermesRuntime.ts
+import { spawn as spawn8 } from "node:child_process";
+import { existsSync } from "node:fs";
+import { readFile, unlink } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import path10 from "node:path";
+var MAX8 = 4e3;
+var clip8 = (s) => String(s ?? "").slice(0, MAX8);
+var FINAL_RESPONSE_MAX = 2400;
+function hermesProfile(model, runtimeConfig) {
+  const configured = runtimeConfig?.profile;
+  if (typeof configured === "string" && configured.trim()) return configured.trim();
+  if (model && model !== "default") return model;
+  return "default";
+}
+function hermesProfileRoots(home = homedir(), env = process.env) {
+  return [env.HERMES_PROFILE_DIR, path10.join(home, ".hermes", "profiles")].filter((v) => !!v);
+}
+function buildHermesPrompt(message, opts) {
+  return [
+    "[OpenTag runtime context]",
+    `You are running as an OpenTag agent in this isolated workspace: ${opts.cwd}`,
+    "Follow this OpenTag system prompt for collaboration, @mentions, and reporting:",
+    opts.systemPrompt,
+    "",
+    "[OpenTag message]",
+    message
+  ].join("\n");
+}
+function buildHermesArgs(prompt, sessionId) {
+  const args2 = ["chat", "-q", prompt, "-Q", "--source", "open-tag"];
+  if (sessionId) args2.push("--resume", sessionId);
+  return args2;
+}
+function parseHermesSessionId(stderr) {
+  const matches = [...stderr.matchAll(/^session_id:\s*(\S+)\s*$/gm)];
+  return matches.length ? matches[matches.length - 1][1] : null;
+}
+function isMissingHermesSession(stderr) {
+  return /Session not found:/i.test(stderr);
+}
+function parseHermesTurnEvents(jsonl) {
+  const state = { sent: false, held: false, engaged: false, target: null };
+  for (const line of jsonl.split("\n")) {
+    if (!line.trim()) continue;
+    let evt;
+    try {
+      evt = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (evt.type === "send") state.sent = true;
+    if (evt.type === "held") state.held = true;
+    if ((evt.type === "check" || evt.type === "read") && typeof evt.target === "string" && evt.target.trim()) {
+      state.engaged = true;
+      state.target = evt.target.trim();
+    }
+  }
+  return state;
+}
+function cleanHermesStdout(stdout) {
+  let lines = stdout.trim().split(/\r?\n/).map((line) => line.trimEnd());
+  while (lines.length && !lines[0].trim()) lines.shift();
+  while (lines.length && /^(⚠|Warning:)/.test(lines[0].trim())) lines.shift();
+  while (lines.length && !lines[0].trim()) lines.shift();
+  const content = lines.join("\n").trim();
+  if (!content) return { ok: false, reason: "empty-stdout" };
+  if (/^(No new messages\.|Sent to |Freshness hold:)/.test(content)) return { ok: false, reason: "cli-output" };
+  if (/^(Error:|Code:|Exception:|Traceback\b|Unhandled\b)/i.test(content)) return { ok: false, reason: "error-output" };
+  if (/^(┊|diff --git\b|@@\s+-|\+\+\+ |--- )/m.test(content) || /\na\/.+\s+→\s+b\/.+/.test(content)) {
+    return { ok: false, reason: "diff-output" };
+  }
+  return { ok: true, target: "", content: content.slice(0, FINAL_RESPONSE_MAX) };
+}
+function hermesBridgeDecision(stdout, state) {
+  if (state.sent) return { ok: false, reason: "already-sent" };
+  if (state.held) return { ok: false, reason: "already-held" };
+  if (!state.engaged || !state.target) return { ok: false, reason: "no-open-tag-read" };
+  if (!/^(#|dm:|thread:)/.test(state.target)) return { ok: false, reason: "invalid-target" };
+  const cleaned = cleanHermesStdout(stdout);
+  if (!cleaned.ok) return cleaned;
+  return { ok: true, target: state.target, content: cleaned.content };
+}
+async function responseJson(res) {
+  try {
+    return await res.json();
+  } catch {
+    return {};
+  }
+}
+async function postHermesBridgeMessage(fetchImpl, serverUrl2, headers, target, content) {
+  const url = `${serverUrl2}/agent-api/message/send`;
+  const first = await fetchImpl(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ target, content })
+  });
+  const firstBody = await responseJson(first);
+  if (!first.ok) return { ok: false, status: first.status };
+  if (!firstBody?.held) return { ok: true };
+  const held = { ok: false, held: true, sentDraft: false };
+  if (typeof firstBody.text === "string") held.text = firstBody.text;
+  return held;
+}
+function hermesProfileHome(profile, home = homedir(), roots = hermesProfileRoots(home)) {
+  if (!profile || profile === "default") return null;
+  for (const root of roots) {
+    const dir = path10.join(root, profile);
+    if (existsSync(dir)) return dir;
+  }
+  return null;
+}
+function hermesRuntimeEnv(baseEnv, cwd, requestedProfile, home = homedir()) {
+  const env = { ...baseEnv, PWD: cwd };
+  delete env.NODE_OPTIONS;
+  delete env.HERMES_HOME;
+  delete env.HERMES_PROFILE;
+  const profileHome = hermesProfileHome(requestedProfile, home, hermesProfileRoots(home, env));
+  const profile = requestedProfile === "default" || profileHome ? requestedProfile : "default";
+  if (profileHome) {
+    env.HERMES_HOME = profileHome;
+    env.HERMES_PROFILE = profile;
+  }
+  return { env, profile };
+}
+var HermesRun = class {
+  constructor(opts, cb) {
+    this.opts = opts;
+    this.cb = cb;
+    const requestedProfile = hermesProfile(opts.model, opts.runtimeConfig);
+    const resolved = hermesRuntimeEnv(opts.env, opts.cwd, requestedProfile);
+    this.env = resolved.env;
+    this.profile = resolved.profile;
+    if (requestedProfile !== "default" && this.profile === "default") {
+      cb.log.warn("hermes profile not found; using default profile", { profile: requestedProfile });
+    }
+    this.sessionId = opts.sessionId ?? null;
+    if (this.sessionId) cb.onSession(this.sessionId);
+    if (opts.initialPrompt.trim()) this.enqueue(opts.initialPrompt);
+  }
+  opts;
+  cb;
+  queue = [];
+  turnBusy = false;
+  stopped = false;
+  proc = null;
+  everSucceeded = false;
+  env;
+  profile;
+  sessionId;
+  enqueue(text) {
+    if (this.stopped || !text.trim()) return;
+    this.queue.push(text);
+    this.pump();
+  }
+  pump() {
+    if (this.stopped || this.turnBusy || this.queue.length === 0) return;
+    this.runTurn(this.queue.shift());
+  }
+  runTurn(message) {
+    this.turnBusy = true;
+    this.cb.onActivity("working", `hermes/${this.profile}`);
+    const prompt = buildHermesPrompt(message, this.opts);
+    const args2 = buildHermesArgs(prompt, this.sessionId);
+    const turnFile = path10.join(tmpdir(), `open-tag-hermes-turn-${Date.now()}-${Math.random().toString(36).slice(2)}.jsonl`);
+    const proc = spawn8("hermes", args2, { cwd: this.opts.cwd, stdio: ["ignore", "pipe", "pipe"], env: { ...this.env, OPEN_TAG_TURN_FILE: turnFile } });
+    this.proc = proc;
+    let stdout = "";
+    const errTail = [];
+    let errLen = 0;
+    proc.stdout?.on("data", (c) => {
+      if (this.stopped) return;
+      if (stdout.length < MAX8) stdout += c.toString();
+    });
+    proc.stderr?.on("data", (c) => {
+      const t = c.toString();
+      errTail.push(t);
+      errLen += t.length;
+      while (errLen > 16384 && errTail.length > 1) errLen -= errTail.shift().length;
+    });
+    proc.on("error", (e) => {
+      this.proc = null;
+      this.turnBusy = false;
+      if (this.stopped) return;
+      this.cb.log.error("hermes spawn failed", { detail: String(e?.message ?? e) });
+      this.cb.onActivity("offline", "hermes not found");
+      if (!this.everSucceeded) this.cb.onExit(1);
+      else this.pump();
+    });
+    proc.on("exit", async (code) => {
+      this.proc = null;
+      if (this.stopped) return;
+      const out = stdout.trim();
+      const tail = errTail.join("").trim();
+      if (code === 0) {
+        this.everSucceeded = true;
+        const nextSessionId = parseHermesSessionId(tail);
+        if (nextSessionId && nextSessionId !== this.sessionId) {
+          this.sessionId = nextSessionId;
+          this.cb.onSession(nextSessionId);
+        }
+        const bridged = await this.bridgeFinalResponse(turnFile, out);
+        if (out) this.cb.onTrajectory([{ kind: "text", text: clip8(out) }]);
+        if (bridged !== false) this.cb.onActivity("online", "");
+        this.turnBusy = false;
+        this.pump();
+        return;
+      }
+      if (this.sessionId && isMissingHermesSession(tail)) {
+        this.cb.log.warn("hermes resume session missing; retrying fresh", { sessionId: this.sessionId });
+        this.sessionId = null;
+        this.cb.onSession(null);
+        this.queue.unshift(message);
+        this.turnBusy = false;
+        this.pump();
+        return;
+      }
+      const last = tail.split("\n").filter(Boolean).pop() || `hermes exited ${code ?? "signal"}`;
+      this.cb.onTrajectory([{ kind: "text", text: "[hermes error] " + clip8(tail || last).slice(0, 800) }]);
+      this.cb.onActivity("error", last.slice(0, 200));
+      this.turnBusy = false;
+      if (!this.everSucceeded) {
+        this.cb.onExit(code ?? 1);
+        return;
+      }
+      this.pump();
+    });
+  }
+  async bridgeFinalResponse(turnFile, stdout) {
+    let state = { sent: false, held: false, engaged: false, target: null };
+    try {
+      state = parseHermesTurnEvents(await readFile(turnFile, "utf8"));
+    } catch {
+    } finally {
+      try {
+        await unlink(turnFile);
+      } catch {
+      }
+    }
+    const decision = hermesBridgeDecision(stdout, state);
+    if (!decision.ok) {
+      if (stdout.trim() && decision.reason !== "already-sent") {
+        this.cb.log.warn("hermes final response not bridged", { reason: decision.reason });
+        this.cb.onActivity("error", `hermes reply not sent (${decision.reason})`);
+        return false;
+      }
+      return null;
+    }
+    try {
+      const result = await postHermesBridgeMessage(fetch, this.env.OPEN_TAG_SERVER_URL ?? "", {
+        authorization: `Bearer ${this.env.OPEN_TAG_AGENT_TOKEN ?? ""}`,
+        "x-agent-id": this.env.OPEN_TAG_AGENT_ID ?? "",
+        "content-type": "application/json"
+      }, decision.target, decision.content);
+      if (!result.ok) {
+        if (result.held) {
+          this.cb.log.warn("hermes final response freshness-held; draft saved for review", { target: decision.target });
+          if (result.text) this.cb.onTrajectory([{ kind: "status", text: "[open-tag freshness hold]\n" + clip8(result.text) }]);
+          this.cb.onActivity("error", "hermes reply held for freshness review");
+          return false;
+        }
+        this.cb.log.warn("hermes final response bridge failed", { status: result.status, target: decision.target });
+        this.cb.onActivity("error", "hermes bridge send failed");
+        return false;
+      } else {
+        this.cb.log.info("hermes final response bridged", { target: decision.target, chars: decision.content.length, held: !!result.held });
+        return true;
+      }
+    } catch (e) {
+      this.cb.log.warn("hermes final response bridge failed", { detail: String(e?.message ?? e), target: decision.target });
+      this.cb.onActivity("error", "hermes bridge send failed");
+      return false;
+    }
+  }
+  stop() {
+    this.stopped = true;
+    const p = this.proc;
+    this.proc = null;
+    if (p) {
+      try {
+        p.kill("SIGTERM");
+      } catch {
+      }
+    }
+  }
+};
+var hermesRuntime = {
+  name: "hermes",
+  experimental: true,
+  oneShotWake: true,
+  start(opts, cb) {
+    const run = new HermesRun(opts, cb);
+    return { deliver: (text) => run.enqueue(text), stop: () => run.stop() };
+  }
+};
+
 // src/daemon/runtimes.ts
 function has(tool) {
   try {
@@ -5386,9 +5683,9 @@ function has(tool) {
   }
 }
 function detectRuntimes() {
-  return ["claude", "codex", "copilot", "kimi", "opencode", "pi", "cursor-agent"].filter(has).map((t) => t === "cursor-agent" ? "cursor" : t);
+  return ["claude", "codex", "copilot", "kimi", "opencode", "pi", "cursor-agent", "hermes"].filter(has).map((t) => t === "cursor-agent" ? "cursor" : t);
 }
-var REG = { claude: claudeRuntime, codex: codexRuntime, copilot: copilotRuntime, opencode: opencodeRuntime, kimi: kimiRuntime, pi: piRuntime, cursor: cursorRuntime };
+var REG = { claude: claudeRuntime, codex: codexRuntime, copilot: copilotRuntime, opencode: opencodeRuntime, kimi: kimiRuntime, pi: piRuntime, cursor: cursorRuntime, hermes: hermesRuntime };
 function getRuntime(name) {
   return REG[name] ?? null;
 }
@@ -5397,14 +5694,28 @@ function getRuntime(name) {
 var DATA_DIR = agentsDir();
 var IDLE_MS = Number(process.env.OPEN_TAG_IDLE_MS ?? 10 * 60 * 1e3);
 var DELIVER_DEBOUNCE_MS = Number(process.env.OPEN_TAG_DELIVER_DEBOUNCE_MS ?? 3e3);
+var ONE_SHOT_DELIVER_DEBOUNCE_MS = Number(process.env.OPEN_TAG_ONE_SHOT_DELIVER_DEBOUNCE_MS ?? process.env.OPEN_TAG_HERMES_DELIVER_DEBOUNCE_MS ?? 500);
+var PENDING_DELIVER_TTL_MS = Number(process.env.OPEN_TAG_PENDING_DELIVER_TTL_MS ?? 15e3);
 var AgentManager = class {
-  constructor(send) {
+  constructor(send, opts = {}) {
     this.send = send;
-    this.binDir = ensureOpenTagBin();
+    this.binDir = opts.binDir ?? ensureOpenTagBin();
+    this.dataDir = opts.dataDir ?? DATA_DIR;
+    this.deliverDebounceMs = opts.deliverDebounceMs ?? DELIVER_DEBOUNCE_MS;
+    this.oneShotDeliverDebounceMs = opts.oneShotDeliverDebounceMs ?? ONE_SHOT_DELIVER_DEBOUNCE_MS;
+    this.pendingDeliverTtlMs = opts.pendingDeliverTtlMs ?? PENDING_DELIVER_TTL_MS;
+    this.runtimeResolver = opts.runtimeResolver ?? getRuntime;
   }
   send;
   agents = /* @__PURE__ */ new Map();
+  starting = /* @__PURE__ */ new Map();
+  pendingDelivers = /* @__PURE__ */ new Map();
   binDir;
+  dataDir;
+  deliverDebounceMs;
+  oneShotDeliverDebounceMs;
+  pendingDeliverTtlMs;
+  runtimeResolver;
   log = createLogger("daemon:agents");
   running() {
     return [...this.agents.keys()];
@@ -5414,6 +5725,7 @@ var AgentManager = class {
   }
   // Tear down process: clear timers + remove from map first (critical: deletion before session.stop() lets the onExit has() guard recognize this as an intentional stop, suppressing unexpected sleeping status) + stop runtime. Returns whether the agent was found.
   teardown(agentId) {
+    this.clearPendingDeliver(agentId);
     const r = this.agents.get(agentId);
     if (!r) return false;
     if (r.idleTimer) clearTimeout(r.idleTimer);
@@ -5439,7 +5751,7 @@ var AgentManager = class {
   async reset(agentId, wipeWorkspace = false, clearMemory = false) {
     this.teardown(agentId);
     this.send({ type: "agent:session", agentId, sessionId: null });
-    const dir = path10.join(DATA_DIR, agentId);
+    const dir = path11.join(this.dataDir, agentId);
     if (wipeWorkspace) {
       try {
         await rm(dir, { recursive: true, force: true });
@@ -5449,7 +5761,7 @@ var AgentManager = class {
       }
     } else if (clearMemory) {
       try {
-        await writeFile(path10.join(dir, "MEMORY.md"), "# Memory\n\n(reset)\n");
+        await writeFile(path11.join(dir, "MEMORY.md"), "# Memory\n\n(reset)\n");
         this.log.info("memory cleared", { agentId });
       } catch (e) {
         this.log.warn("clearMemory failed", { agentId, detail: String(e) });
@@ -5463,10 +5775,10 @@ var AgentManager = class {
    *  title + `## Role`, preserving the agent's own sections. No-op if the workspace/file doesn't exist
    *  yet (a not-yet-started agent gets fresh values from the DB when start() seeds it). */
   async syncProfile(agentId, displayName, description) {
-    const mem = path10.join(DATA_DIR, agentId, "MEMORY.md");
+    const mem = path11.join(this.dataDir, agentId, "MEMORY.md");
     let content;
     try {
-      content = await readFile(mem, "utf8");
+      content = await readFile2(mem, "utf8");
     } catch {
       this.log.debug("syncProfile: no MEMORY.md yet", { agentId });
       return;
@@ -5498,16 +5810,24 @@ var AgentManager = class {
   }
   async start(agentId, config) {
     if (this.agents.has(agentId)) return;
-    const runtime = getRuntime(config.runtime ?? "claude");
+    const existing = this.starting.get(agentId);
+    if (existing) return existing;
+    const pending = this.startNow(agentId, config).finally(() => this.starting.delete(agentId));
+    this.starting.set(agentId, pending);
+    return pending;
+  }
+  async startNow(agentId, config) {
+    if (this.agents.has(agentId)) return;
+    const runtime = this.runtimeResolver(config.runtime ?? "claude");
     if (!runtime) {
       this.log.error("no runtime", { runtime: config.runtime });
       this.send({ type: "agent:activity", agentId, activity: "offline", detail: `no runtime: ${config.runtime}` });
       return;
     }
     if (runtime.experimental) this.log.warn("experimental runtime", { runtime: runtime.name });
-    const dir = path10.join(DATA_DIR, agentId);
-    await mkdir(path10.join(dir, "notes"), { recursive: true });
-    const mem = path10.join(dir, "MEMORY.md");
+    const dir = path11.join(this.dataDir, agentId);
+    await mkdir(path11.join(dir, "notes"), { recursive: true });
+    const mem = path11.join(dir, "MEMORY.md");
     try {
       await access(mem);
     } catch {
@@ -5554,6 +5874,8 @@ var AgentManager = class {
       },
       log: this.log
     };
+    const pendingDeliveryCount = this.pendingDelivers.get(agentId)?.items.length ?? 0;
+    const useOneShotWakeNudge = !!runtime.oneShotWake && pendingDeliveryCount > 0;
     this.agents.set(agentId, running);
     running.session = runtime.start({
       cwd: dir,
@@ -5562,18 +5884,55 @@ var AgentManager = class {
       sessionId: config.sessionId,
       systemPrompt,
       env,
-      initialPrompt: config.sessionId ? RESUME_NUDGE : STARTUP_NUDGE
+      initialPrompt: useOneShotWakeNudge ? ONE_SHOT_WAKE_NUDGE : config.sessionId ? RESUME_NUDGE : STARTUP_NUDGE
     }, cb);
     this.send({ type: "agent:status", agentId, status: "active" });
     this.send({ type: "agent:activity", agentId, activity: "working", detail: "starting" });
     this.log.info("agent started", { agentId, runtime: runtime.name, model: config.model ?? "(default)", resume: !!config.sessionId, experimental: runtime.experimental ?? false });
     this.resetIdle(agentId);
+    if (useOneShotWakeNudge) {
+      this.clearPendingDeliver(agentId);
+      this.log.debug("pending deliver consumed by one-shot wake nudge", { agentId, runtime: runtime.name, count: pendingDeliveryCount });
+    } else {
+      this.flushPendingDeliver(agentId);
+    }
   }
-  /** server agent:deliver — wake a running agent with new messages; agents not yet running will self-check on startup once agent:start arrives. */
+  queuePendingDeliver(agentId, item) {
+    let q = this.pendingDelivers.get(agentId);
+    if (!q) {
+      const timer = setTimeout(() => {
+        this.pendingDelivers.delete(agentId);
+        this.log.debug("pending deliver expired", { agentId });
+      }, this.pendingDeliverTtlMs);
+      q = { items: [], timer };
+      this.pendingDelivers.set(agentId, q);
+    }
+    q.items.push(item);
+    if (q.items.length > 10) q.items.shift();
+    this.log.debug("deliver queued pending start", { agentId, count: q.items.length });
+  }
+  clearPendingDeliver(agentId) {
+    const q = this.pendingDelivers.get(agentId);
+    if (!q) return;
+    clearTimeout(q.timer);
+    this.pendingDelivers.delete(agentId);
+  }
+  flushPendingDeliver(agentId) {
+    const q = this.pendingDelivers.get(agentId);
+    if (!q) return;
+    this.clearPendingDeliver(agentId);
+    this.log.debug("pending deliver -> agent", { agentId, count: q.items.length });
+    for (const item of q.items) this.deliver(agentId, item.from, item.target, item.mentioned, item.meta);
+  }
+  debounceMsFor(r) {
+    const runtime = this.runtimeResolver(r.config.runtime ?? "claude");
+    return runtime?.oneShotWake ? this.oneShotDeliverDebounceMs : this.deliverDebounceMs;
+  }
+  /** server agent:deliver — wake a running agent with new messages; if start is still preparing the workspace, briefly queue and flush once the runtime exists. */
   deliver(agentId, from, target, mentioned = false, meta = {}) {
     const r = this.agents.get(agentId);
     if (!r) {
-      this.log.debug("deliver: agent not running yet", { agentId });
+      this.queuePendingDeliver(agentId, { from, target, mentioned, meta });
       return;
     }
     const tname = meta.targetName ?? target;
@@ -5601,29 +5960,29 @@ var AgentManager = class {
       } catch (e) {
         this.log.warn("deliver failed", { agentId, detail: String(e) });
       }
-    }, DELIVER_DEBOUNCE_MS);
+    }, this.debounceMsFor(r));
     r.deliverBuf = buf;
   }
 };
 
 // src/daemon/workspace.ts
-import { readdir, readFile as readFile2, stat } from "node:fs/promises";
-import path11 from "node:path";
+import { readdir, readFile as readFile3, stat } from "node:fs/promises";
+import path12 from "node:path";
 import os3 from "node:os";
 var DATA_DIR2 = agentsDir();
 var MAX_FILE = 256 * 1024;
 var SKIP = /* @__PURE__ */ new Set(["node_modules", ".git"]);
 function safe(agentId, rel) {
-  const root = path11.join(DATA_DIR2, agentId);
-  const target = path11.resolve(root, rel || ".");
-  if (target !== root && !target.startsWith(root + path11.sep)) return null;
+  const root = path12.join(DATA_DIR2, agentId);
+  const target = path12.resolve(root, rel || ".");
+  if (target !== root && !target.startsWith(root + path12.sep)) return null;
   return target;
 }
 async function walk(root, rel, acc, depth) {
   if (depth > 6 || acc.length > 2e3) return;
   let ds;
   try {
-    ds = await readdir(path11.join(root, rel), { withFileTypes: true });
+    ds = await readdir(path12.join(root, rel), { withFileTypes: true });
   } catch {
     return;
   }
@@ -5633,7 +5992,7 @@ async function walk(root, rel, acc, depth) {
     let size = 0;
     let modifiedAt = null;
     try {
-      const s = await stat(path11.join(root, childRel));
+      const s = await stat(path12.join(root, childRel));
       size = d.isFile() ? s.size : 0;
       modifiedAt = s.mtime.toISOString();
     } catch {
@@ -5643,13 +6002,13 @@ async function walk(root, rel, acc, depth) {
   }
 }
 async function listWorkspace(agentId, _subPath = "") {
-  const root = path11.join(DATA_DIR2, agentId);
+  const root = path12.join(DATA_DIR2, agentId);
   try {
     const files = [];
     await walk(root, "", files, 0);
-    return { files };
+    return { files, root };
   } catch (e) {
-    return { error: String(e?.message ?? e) };
+    return { error: String(e?.message ?? e), root };
   }
 }
 function fmField(fm, key) {
@@ -5681,7 +6040,7 @@ async function readSkillsDir(dir, sourcePath) {
     if (!e.isDirectory()) continue;
     let name = e.name, description = "", userInvocable = false;
     try {
-      const txt = await readFile2(path11.join(dir, e.name, "SKILL.md"), "utf8");
+      const txt = await readFile3(path12.join(dir, e.name, "SKILL.md"), "utf8");
       const fm = /^---\n([\s\S]*?)\n---/.exec(txt);
       if (fm) {
         name = fmField(fm[1], "name") || e.name;
@@ -5696,21 +6055,21 @@ async function readSkillsDir(dir, sourcePath) {
   return out;
 }
 var HOME = os3.homedir();
-var UNIVERSAL_SKILLS = { dir: path11.join(HOME, ".agents", "skills"), label: "~/.agents/skills" };
+var UNIVERSAL_SKILLS = { dir: path12.join(HOME, ".agents", "skills"), label: "~/.agents/skills" };
 var PROVIDER_HOME_SKILLS = {
-  claude: { dir: path11.join(HOME, ".claude", "skills"), label: "~/.claude/skills" },
-  codex: { dir: path11.join(process.env.CODEX_HOME || path11.join(HOME, ".codex"), "skills"), label: "~/.codex/skills" },
-  copilot: { dir: path11.join(HOME, ".copilot", "skills"), label: "~/.copilot/skills" },
-  opencode: { dir: path11.join(HOME, ".config", "opencode", "skills"), label: "~/.config/opencode/skills" },
-  cursor: { dir: path11.join(HOME, ".cursor", "skills"), label: "~/.cursor/skills" },
-  pi: { dir: path11.join(HOME, ".pi", "agent", "skills"), label: "~/.pi/agent/skills" }
+  claude: { dir: path12.join(HOME, ".claude", "skills"), label: "~/.claude/skills" },
+  codex: { dir: path12.join(process.env.CODEX_HOME || path12.join(HOME, ".codex"), "skills"), label: "~/.codex/skills" },
+  copilot: { dir: path12.join(HOME, ".copilot", "skills"), label: "~/.copilot/skills" },
+  opencode: { dir: path12.join(HOME, ".config", "opencode", "skills"), label: "~/.config/opencode/skills" },
+  cursor: { dir: path12.join(HOME, ".cursor", "skills"), label: "~/.cursor/skills" },
+  pi: { dir: path12.join(HOME, ".pi", "agent", "skills"), label: "~/.pi/agent/skills" }
 };
 var PROVIDER_WS_DIR = { claude: ".claude", codex: ".codex", copilot: ".copilot", opencode: ".opencode", cursor: ".cursor", pi: ".pi" };
 function skillRootsFor(runtime, agentId) {
   const home = PROVIDER_HOME_SKILLS[runtime];
   const global = home ? [home, UNIVERSAL_SKILLS] : [UNIVERSAL_SKILLS];
   const wsName = PROVIDER_WS_DIR[runtime];
-  const workspace = wsName ? { dir: path11.join(DATA_DIR2, agentId, wsName, "skills"), label: `<workspace>/${wsName}/skills` } : null;
+  const workspace = wsName ? { dir: path12.join(DATA_DIR2, agentId, wsName, "skills"), label: `<workspace>/${wsName}/skills` } : null;
   return { global, workspace };
 }
 async function listSkills(agentId, runtime = "claude") {
@@ -5726,7 +6085,7 @@ async function readWorkspaceFile(agentId, rel) {
     const s = await stat(file);
     if (!s.isFile()) return { error: "not a file" };
     if (s.size > MAX_FILE) return { error: `file too large (${s.size} bytes, max ${MAX_FILE})` };
-    const buf = await readFile2(file);
+    const buf = await readFile3(file);
     if (buf.includes(0)) return { error: "binary file" };
     return { path: rel, content: buf.toString("utf8") };
   } catch (e) {
@@ -5735,7 +6094,10 @@ async function readWorkspaceFile(agentId, rel) {
 }
 
 // src/daemon/listModels.ts
-import { spawn as spawn8 } from "node:child_process";
+import { spawn as spawn9 } from "node:child_process";
+import { existsSync as existsSync2, readdirSync, readFileSync, statSync } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import path13 from "node:path";
 var titleCase = (s) => s ? s[0].toUpperCase() + s.slice(1) : s;
 function isModelId(s) {
   return /^[A-Za-z][A-Za-z0-9\-_./]*$/.test(s);
@@ -5842,6 +6204,71 @@ function isPiNoise(line) {
   const l = line.toLowerCase();
   return l.includes("no models match pattern") || l.startsWith("warning:") || l.startsWith("error:") || l.startsWith("info:");
 }
+function labelFromId(id) {
+  return id.split(/[-_]/).filter(Boolean).map(titleCase).join(" ") || id;
+}
+function firstYamlString(text, keys) {
+  for (const key of keys) {
+    const re = new RegExp(`^${key}:\\s*["']?([^"'\\n#]+)`, "m");
+    const m = re.exec(text);
+    if (m?.[1]?.trim()) return m[1].trim();
+  }
+  return null;
+}
+function hermesProfileLabel(dir, id) {
+  for (const filename of ["profile.yaml", "config.yaml"]) {
+    const file = path13.join(dir, filename);
+    if (!existsSync2(file)) continue;
+    try {
+      const text = readFileSync(file, "utf8").slice(0, 4096);
+      const label = firstYamlString(text, ["display_name", "displayName", "name", "title"]);
+      if (label) return label;
+    } catch {
+    }
+  }
+  return labelFromId(id);
+}
+function isHermesProfileDir(dir) {
+  return ["profile.yaml", "SOUL.md", "config.yaml"].some((name) => existsSync2(path13.join(dir, name)));
+}
+function discoverHermesProfilesFromRoots(roots) {
+  const found = /* @__PURE__ */ new Map([
+    ["default", { id: "default", label: "Default profile", provider: "hermes", default: true }]
+  ]);
+  for (const root of roots) {
+    if (!root || !existsSync2(root)) continue;
+    let entries;
+    try {
+      entries = readdirSync(root);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const dir = path13.join(root, entry);
+      try {
+        if (!statSync(dir).isDirectory()) continue;
+      } catch {
+        continue;
+      }
+      if (!isHermesProfileDir(dir)) continue;
+      if (!isModelId(entry)) continue;
+      if (!found.has(entry)) found.set(entry, { id: entry, label: hermesProfileLabel(dir, entry), provider: "hermes" });
+    }
+  }
+  return [...found.values()].sort((a, b) => {
+    if (a.id === "default") return -1;
+    if (b.id === "default") return 1;
+    return a.id.localeCompare(b.id);
+  });
+}
+function discoverHermesProfiles() {
+  const home = homedir2();
+  const roots = [
+    process.env.HERMES_PROFILE_DIR,
+    path13.join(home, ".hermes", "profiles")
+  ].filter((v) => !!v);
+  return discoverHermesProfilesFromRoots(roots);
+}
 var LIST_TIMEOUT_MS = 7e3;
 var OUT_CAP = 256 * 1024;
 function runList(bin, args2, timeoutMs = LIST_TIMEOUT_MS) {
@@ -5850,7 +6277,7 @@ function runList(bin, args2, timeoutMs = LIST_TIMEOUT_MS) {
     delete env.NODE_OPTIONS;
     let proc;
     try {
-      proc = spawn8(bin, args2, { stdio: ["ignore", "pipe", "pipe"], env });
+      proc = spawn9(bin, args2, { stdio: ["ignore", "pipe", "pipe"], env });
     } catch (e) {
       return resolve({ stdout: "", stderr: String(e?.message ?? e), code: 1 });
     }
@@ -5913,6 +6340,10 @@ async function listModels(runtime) {
       const models = parseCodexModels(r.stdout);
       return models.length ? models : null;
     }
+    case "hermes": {
+      const profiles = discoverHermesProfiles();
+      return profiles.length ? profiles : null;
+    }
     default:
       return null;
   }
@@ -5928,8 +6359,10 @@ for (let i = 0; i < args.length; i++) {
   if (args[i] === "--api-key" && args[i + 1]) apiKey = args[++i];
 }
 if (!serverUrl) serverUrl = `http://localhost:${process.env.PORT ?? 7777}`;
+if (!apiKey) apiKey = process.env.OPEN_TAG_DAEMON_API_KEY ?? "";
 if (!apiKey) {
   console.error("Usage: open-tag-daemon [--server-url <url>] --api-key <machineKey>");
+  console.error("   or: OPEN_TAG_DAEMON_API_KEY=<machineKey> open-tag-daemon [--server-url <url>]");
   process.exit(1);
 }
 var MID_FILE = machineIdFile();
@@ -5942,7 +6375,7 @@ var readMachineId = () => {
 };
 var saveMachineId = (id) => {
   try {
-    fs3.mkdirSync(path12.dirname(MID_FILE), { recursive: true });
+    fs3.mkdirSync(path14.dirname(MID_FILE), { recursive: true });
     fs3.writeFileSync(MID_FILE, id);
   } catch {
   }
@@ -6003,7 +6436,7 @@ conn = new Connection(serverUrl, apiKey, (msg) => {
     runningAgents: mgr.running(),
     hostname: os4.hostname(),
     os: `${os4.platform()} ${os4.arch()}`,
-    daemonVersion: "0.7.1",
+    daemonVersion: "0.8.0",
     machineId: readMachineId()
     // Stable identity: empty on first connection; server sends it back via ready:ack for persistence.
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fancyboi999/open-tag-daemon",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "description": "open-tag compute-plane daemon — connect any machine to an open-tag server so its agents run there. No repo clone needed.",
   "license": "Apache-2.0",
   "type": "module",