@strideops/bridge 0.1.2 → 0.1.5

package/dist/cli.js

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
-import { requireConfig, log, readConfig, CONFIG_PATH, isConfigured, writeConfig, logError, logWarn, readJsonSafe, PENDING_REPORTS_PATH, AGENTS_DIR, writeJsonAtomic } from './chunk-GBLMB3XB.js';
+import { BRIDGE_DIR, requireConfig, log, readConfig, CONFIG_PATH, isConfigured, writeConfig, logError, logWarn, PENDING_REPORTS_PATH, AGENTS_DIR, readJsonSafe, writeJsonAtomic, __require } from './chunk-6LRDE2ZS.js';
 import { Command } from 'commander';
-import { homedir, cpus, totalmem, release, platform, arch, hostname } from 'os';
+import os, { homedir, cpus, totalmem, release, platform, arch, hostname, loadavg, freemem } from 'os';
 import { join, dirname } from 'path';
 import { existsSync, mkdirSync, accessSync, constants, writeFileSync, chmodSync } from 'fs';
 import { execSync, spawn } from 'child_process';
+import { readFile, statfs } from 'fs/promises';
 
 // src/version.ts
-var VERSION = "0.1.2";
+var VERSION = "0.1.5";
 async function runPair(pairingCode, apiBaseUrl) {
   const url = `${apiBaseUrl.replace(/\/$/, "")}/api/bridge/v1/pair`;
   log(`Pairing with ${apiBaseUrl} ...`);
@@ -82,8 +83,38 @@ async function runPair(pairingCode, apiBaseUrl) {
   console.log(`  Auth mode   : ${authMode}`);
   console.log(`  Config      : ~/.stride-bridge/config.json`);
   console.log();
+  await offerAutostart();
   console.log(`Run \`stride-bridge start\` to begin accepting work.`);
 }
+async function offerAutostart() {
+  if (process.platform !== "win32" || !process.stdin.isTTY) {
+    if (process.platform === "win32") {
+      console.log(
+        `Tip: run \`stride-bridge autostart install\` so the daemon starts at login.`
+      );
+      console.log();
+    }
+    return;
+  }
+  const { createInterface } = await import('readline/promises');
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = (await rl.question(
+      "Start the daemon automatically at Windows login? [Y/n] "
+    )).trim().toLowerCase();
+    if (answer === "" || answer === "y" || answer === "yes") {
+      const { autostartInstall } = await import('./autostart-ASW5MDQS.js');
+      autostartInstall();
+    } else {
+      console.log(
+        `Skipped. You can enable it later with \`stride-bridge autostart install\`.`
+      );
+    }
+  } finally {
+    rl.close();
+    console.log();
+  }
+}
 
 // src/api.ts
 var REQUEST_TIMEOUT_MS = 1e4;
@@ -365,6 +396,188 @@ console.log(res.ok ? "identity-sync: onboarding recorded in Stride" : \`identity
   mkdirSync(claudeDir, { recursive: true });
   writeFileSync(join(claudeDir, "identity-sync.mjs"), script, { encoding: "utf-8", mode: 448 });
 }
+function writeMemorySearchScript(opts) {
+  const { agentId, hookSecret, apiBaseUrl, workspaceDir } = opts;
+  const base = apiBaseUrl.replace(/\/$/, "");
+  const searchUrl = `${base}/api/internal/build/agents/${agentId}/memory/search`;
+  const script = `#!/usr/bin/env node
+// Auto-generated by stride-bridge. Do not edit.
+// Semantically searches this agent's synced memory in Stride.
+
+import { createHmac } from "node:crypto";
+
+const HOOK_SECRET = ${JSON.stringify(hookSecret)};
+const SEARCH_URL = ${JSON.stringify(searchUrl)};
+
+const query = process.argv.slice(2).join(" ").trim();
+if (!query) {
+  console.log("usage: node memory-search.mjs <query>");
+  process.exit(0);
+}
+
+const body = JSON.stringify({ query, limit: 5 });
+const ts = Math.floor(Date.now() / 1000).toString();
+const sig = createHmac("sha256", HOOK_SECRET).update(ts + "\\n" + body).digest("hex");
+
+const res = await fetch(SEARCH_URL, {
+  method: "POST",
+  headers: {
+    "Content-Type": "application/json",
+    "x-stride-hook-ts": ts,
+    "x-stride-hook-sig": sig,
+  },
+  body,
+}).catch(() => null);
+
+if (!res || !res.ok) {
+  console.log("memory-search: unavailable");
+  process.exit(0);
+}
+const data = await res.json();
+const results = data?.data?.results ?? [];
+if (results.length === 0) {
+  console.log("memory-search: no matches");
+} else {
+  for (const r of results) {
+    console.log("--- " + (r.label ?? "memory") + " ---");
+    console.log(String(r.content ?? "").slice(0, 600));
+  }
+}
+`;
+  const claudeDir = join(workspaceDir, ".claude");
+  mkdirSync(claudeDir, { recursive: true });
+  writeFileSync(join(claudeDir, "memory-search.mjs"), script, { encoding: "utf-8", mode: 448 });
+}
+function writeApprovalRequestScript(opts) {
+  const { agentId, hookSecret, apiBaseUrl, workspaceDir } = opts;
+  const base = apiBaseUrl.replace(/\/$/, "");
+  const approvalsUrl = `${base}/api/internal/build/agents/${agentId}/approvals`;
+  const script = `#!/usr/bin/env node
+// Auto-generated by stride-bridge. Do not edit.
+// Posts a plan/question/action approval request to Stride (HMAC-signed).
+// Usage: node .claude/approval-request.mjs <title> <plan>
+// After calling this, END your current run and wait to be re-woken.
+
+import { createHmac } from "node:crypto";
+
+const HOOK_SECRET = ${JSON.stringify(hookSecret)};
+const APPROVALS_URL = ${JSON.stringify(approvalsUrl)};
+
+const args = process.argv.slice(2);
+const title = (args[0] ?? "").trim();
+const plan = (args[1] ?? "").trim();
+
+if (!title) {
+  console.error("approval-request: title is required");
+  console.error("usage: node .claude/approval-request.mjs <title> <plan>");
+  process.exit(1);
+}
+
+const body = JSON.stringify({ type: "plan", title: title.slice(0, 200), body: plan.slice(0, 8000) });
+const ts = Math.floor(Date.now() / 1000).toString();
+const sig = createHmac("sha256", HOOK_SECRET).update(ts + "\\n" + body).digest("hex");
+
+const res = await fetch(APPROVALS_URL, {
+  method: "POST",
+  headers: {
+    "Content-Type": "application/json",
+    "x-stride-hook-ts": ts,
+    "x-stride-hook-sig": sig,
+  },
+  body,
+}).catch((err) => ({ ok: false, statusText: String(err) }));
+
+if (!res.ok) {
+  console.error(\`approval-request: failed (\${res.statusText ?? res.status})\`);
+  process.exit(1);
+}
+
+const data = await res.json();
+console.log(\`approval-request: submitted (approvalId=\${data?.approvalId ?? "?"})\`);
+console.log(data?.message ?? "End your current run and wait to be re-woken.");
+`;
+  const claudeDir = join(workspaceDir, ".claude");
+  mkdirSync(claudeDir, { recursive: true });
+  writeFileSync(join(claudeDir, "approval-request.mjs"), script, { encoding: "utf-8", mode: 448 });
+}
+var PROBE_TIMEOUT_MS = 3e3;
+var CACHE_TTL_MS = 5 * 60 * 1e3;
+var PROBES = [
+  { runtime: "claude-code", cmd: "claude", args: ["--version"] },
+  { runtime: "codex", cmd: "codex", args: ["--version"] },
+  { runtime: "hermes", cmd: "hermes", args: ["--version"] }
+];
+function probeRuntime(cmd, args) {
+  return new Promise((resolve) => {
+    let child;
+    let resolved = false;
+    const done = (value) => {
+      if (!resolved) {
+        resolved = true;
+        resolve(value);
+      }
+    };
+    const useShell = process.platform === "win32";
+    try {
+      child = spawn(cmd, args, {
+        shell: useShell,
+        stdio: ["ignore", "pipe", "ignore"],
+        env: process.env
+      });
+    } catch {
+      done("");
+      return;
+    }
+    let stdoutBuf = "";
+    child.stdout?.on("data", (chunk) => {
+      stdoutBuf += chunk.toString("utf-8");
+    });
+    const timer = setTimeout(() => {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      done("");
+    }, PROBE_TIMEOUT_MS);
+    child.on("close", () => {
+      clearTimeout(timer);
+      const firstLine = stdoutBuf.split("\n").map((l) => l.trim()).find((l) => l.length > 0) ?? "";
+      done(firstLine);
+    });
+    child.on("error", () => {
+      clearTimeout(timer);
+      done("");
+    });
+  });
+}
+function extractVersion(raw) {
+  if (!raw.trim()) return "";
+  const match = raw.match(/\d+\.\d+(?:\.\d+)*/);
+  return match ? match[0] : raw.trim().split(/\s+/).pop() ?? "";
+}
+var cached = null;
+async function detectRuntimes(force = false) {
+  if (!force && cached && Date.now() - cached.at < CACHE_TTL_MS) {
+    return cached.capabilities;
+  }
+  const results = [];
+  for (const probe of PROBES) {
+    try {
+      const raw = await probeRuntime(probe.cmd, probe.args);
+      results.push({ runtime: probe.runtime, version: extractVersion(raw) });
+    } catch (err) {
+      logWarn(
+        `Runtime probe failed for "${probe.runtime}": ${err instanceof Error ? err.message : String(err)}`
+      );
+      results.push({ runtime: probe.runtime, version: "" });
+    }
+  }
+  cached = { capabilities: results, at: Date.now() };
+  return results;
+}
+function invalidateRuntimeCache() {
+  cached = null;
+}
 
 // src/agents.ts
 var cachedAgents = [];
@@ -378,10 +591,14 @@ async function refreshAgents(config) {
     for (const agent of cachedAgents) {
       await ensureAgentWorkspace(config, agent);
     }
+    invalidateRuntimeCache();
   } catch (err) {
     logError("Failed to refresh agents", err);
   }
 }
+function getCachedAgents() {
+  return cachedAgents;
+}
 function findAgent(agentId) {
   return cachedAgents.find((a) => a.id === agentId);
 }
@@ -394,17 +611,32 @@ async function ensureAgentWorkspace(config, agent) {
   sections.push(agent.soulMd ?? agent.defaultSoulMd ?? "");
   if (agent.memoryProtocolMd) sections.push(agent.memoryProtocolMd);
   sections.push(
-    "## Memory sync (local agent)\n\nAfter updating MEMORY.md or today's daily journal, sync them to Stride by running:\n\n```\nnode .claude/memory-sync.mjs\n```\n"
+    '## Memory sync (local agent)\n\nAfter updating MEMORY.md or today\'s daily journal, sync them to Stride by running:\n\n```\nnode .claude/memory-sync.mjs\n```\n\nBefore re-researching something you may have learned before, search your own past memory semantically:\n\n```\nnode .claude/memory-search.mjs "your question"\n```\n'
   );
+  if (agent.approvalProtocolMd) {
+    sections.push(
+      agent.approvalProtocolMd + '\n\n### Approval Request (local agent)\n\nPost a plan or question for human review using the Windows-safe Node script:\n\n```\nnode .claude/approval-request.mjs "<title>" "<plan>"\n```\n\nAfter posting, **end your current run immediately** and wait to be re-woken.'
+    );
+  }
+  if (agent.experimentProtocolMd) {
+    sections.push(agent.experimentProtocolMd);
+    if (agent.experimentSnippet) {
+      sections.push(agent.experimentSnippet);
+    }
+  }
   if (!agent.onboardedAt && agent.onboardingMd) {
     sections.push(
       "## FIRST BOOT \u2014 onboarding required\n\nYou have not been onboarded. Read ONBOARDING.md in this workspace and complete the interview BEFORE regular work. To sync your identity after the interview, run:\n\n```\nnode .claude/identity-sync.mjs\n```\n"
     );
   }
-  writeFileSync(join(workspaceDir, "CLAUDE.md"), sections.filter(Boolean).join("\n\n"), "utf-8");
+  const claudeMdContent = sections.filter(Boolean).join("\n\n");
+  writeFileSync(join(workspaceDir, "CLAUDE.md"), claudeMdContent, "utf-8");
+  writeFileSync(join(workspaceDir, "AGENTS.md"), claudeMdContent, "utf-8");
   if (!agent.onboardedAt && agent.onboardingMd) {
     writeFileSync(join(workspaceDir, "ONBOARDING.md"), agent.onboardingMd, "utf-8");
   }
+  const soulContent = agent.soulMd ?? agent.defaultSoulMd;
+  if (soulContent) writeFileSync(join(workspaceDir, "SOUL.md"), soulContent, "utf-8");
   if (agent.identityMd) writeFileSync(join(workspaceDir, "IDENTITY.md"), agent.identityMd, "utf-8");
   if (agent.userMd) writeFileSync(join(workspaceDir, "USER.md"), agent.userMd, "utf-8");
   if (agent.heartbeatChecklist) {
@@ -436,6 +668,18 @@ async function ensureAgentWorkspace(config, agent) {
     apiBaseUrl: config.apiBaseUrl,
     workspaceDir
   });
+  writeMemorySearchScript({
+    agentId: agent.id,
+    hookSecret: agent.hookSecret,
+    apiBaseUrl: config.apiBaseUrl,
+    workspaceDir
+  });
+  writeApprovalRequestScript({
+    agentId: agent.id,
+    hookSecret: agent.hookSecret,
+    apiBaseUrl: config.apiBaseUrl,
+    workspaceDir
+  });
   log(`Provisioned workspace for agent "${agent.name}" (${agent.id})`);
 }
 function agentWorkspaceDir(agentId) {
@@ -491,6 +735,151 @@ function recordRunSession(agentId, newSessionId, previous, nowMs) {
   return next;
 }
 
+// src/prompt.ts
+function buildPromptText(opts) {
+  try {
+    const { workPrompt, agent, cwd, agentWorkspace, rotated } = opts;
+    const parts = [];
+    const soulText = agent?.soulMd ?? agent?.defaultSoulMd;
+    const shouldInjectSoul = cwd !== agentWorkspace && soulText != null && soulText.trim().length > 0;
+    if (shouldInjectSoul) {
+      let identityBlock = `## Who you are
+
+${soulText}`;
+      if (agent?.identityMd && agent.identityMd.trim().length > 0) {
+        identityBlock += `
+
+${agent.identityMd}`;
+      }
+      parts.push(identityBlock);
+    }
+    if (rotated) {
+      parts.push(
+        "## Session rotated\nYour previous session ended (context rotation). Read HANDOFF.md and your recent memory/ journal entries before starting."
+      );
+    }
+    parts.push(workPrompt);
+    return parts.join("\n\n---\n\n");
+  } catch {
+    return opts.workPrompt;
+  }
+}
+var DEAD_REPORTS_PATH = join(BRIDGE_DIR, "dead-reports.json");
+var MAX_ATTEMPTS = 20;
+function isPermanentClientError(err) {
+  if (!(err instanceof ApiError)) return false;
+  const { status } = err;
+  if (status === null) return false;
+  if (status < 400 || status >= 500) return false;
+  if (status === 408 || status === 429) return false;
+  return true;
+}
+function normalizeEntry(raw) {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    logWarn("[report-queue] Dropping unrecognised queue entry (not an object)");
+    return null;
+  }
+  const r = raw;
+  if (typeof r["runId"] !== "string" || !r["runId"]) {
+    logWarn("[report-queue] Dropping queue entry missing runId");
+    return null;
+  }
+  const runId = r["runId"];
+  if (typeof r["status"] === "string" && (r["report"] === void 0 || r["report"] === null)) {
+    logWarn(
+      `[report-queue] Normalising legacy flat RunReport for run ${runId} (pre-WS1 daemon)`
+    );
+    return {
+      runId,
+      report: r,
+      attempts: 0,
+      firstFailedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  if (r["report"] === null || typeof r["report"] !== "object" || Array.isArray(r["report"])) {
+    logWarn(`[report-queue] Dropping queue entry for run ${runId}: invalid .report field`);
+    return null;
+  }
+  const rawAttempts = r["attempts"];
+  const attempts = Number.isFinite(rawAttempts) ? rawAttempts : 0;
+  const firstFailedAt = typeof r["firstFailedAt"] === "string" ? r["firstFailedAt"] : (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    runId,
+    report: r["report"],
+    attempts,
+    firstFailedAt
+  };
+}
+function readQueue(path) {
+  const raw = readJsonSafe(path);
+  if (!raw) return [];
+  const normalised = [];
+  for (const entry of raw) {
+    const item = normalizeEntry(entry);
+    if (item !== null) normalised.push(item);
+  }
+  return normalised;
+}
+function writeQueue(path, items) {
+  writeJsonAtomic(path, items);
+}
+function removePendingById(runId, path) {
+  const items = readQueue(path);
+  const filtered = items.filter((r) => r.runId !== runId);
+  if (filtered.length !== items.length) {
+    writeQueue(path, filtered);
+  }
+}
+function updatePending(item, path) {
+  const items = readQueue(path);
+  const updated = items.map((r) => r.runId === item.runId ? item : r);
+  writeQueue(path, updated);
+}
+function deadLetter(item, reason) {
+  logError(
+    `[report-queue] Dead-lettering run ${item.runId} (${reason}, attempts=${item.attempts})`
+  );
+  const existing = readQueue(DEAD_REPORTS_PATH);
+  const deduped = existing.filter((r) => r.runId !== item.runId);
+  deduped.push(item);
+  writeQueue(DEAD_REPORTS_PATH, deduped);
+}
+function enqueue(item) {
+  const existing = readQueue(PENDING_REPORTS_PATH);
+  const deduped = existing.filter((r) => r.runId !== item.runId);
+  deduped.push(item);
+  writeQueue(PENDING_REPORTS_PATH, deduped);
+}
+function removePendingReport(runId) {
+  removePendingById(runId, PENDING_REPORTS_PATH);
+}
+async function drain(send) {
+  const items = readQueue(PENDING_REPORTS_PATH);
+  if (items.length === 0) return;
+  for (const item of items) {
+    try {
+      await send(item);
+      removePendingById(item.runId, PENDING_REPORTS_PATH);
+    } catch (err) {
+      if (isPermanentClientError(err)) {
+        removePendingById(item.runId, PENDING_REPORTS_PATH);
+        deadLetter(item, `permanent ${err.status}`);
+      } else {
+        const updated = { ...item, attempts: item.attempts + 1 };
+        if (updated.attempts >= MAX_ATTEMPTS) {
+          removePendingById(item.runId, PENDING_REPORTS_PATH);
+          deadLetter(updated, "max_attempts_exceeded");
+        } else {
+          updatePending(updated, PENDING_REPORTS_PATH);
+          logWarn(
+            `[report-queue] Transient failure for run ${item.runId} (attempt ${updated.attempts}/${MAX_ATTEMPTS})`
+          );
+        }
+      }
+    }
+  }
+}
+
 // src/runner.ts
 var RUN_TIMEOUT_MS = 15 * 60 * 1e3;
 var STDOUT_CAP = 1e4;
@@ -503,6 +892,12 @@ function resolveClaudeCommand() {
   if (existsSync(nativeExe)) return { cmd: nativeExe, shell: false };
   return { cmd: "claude", shell: true };
 }
+function shellEscapeArgs(args) {
+  return args.map((a) => /[\s"^&|<>%]/.test(a) ? `"${a.replace(/"/g, '""')}"` : a);
+}
+function isValidModelSlug(model) {
+  return /^[A-Za-z0-9._:+/-]+$/.test(model);
+}
 function parseClaudeOutput(raw) {
   const trimmed = raw.trim();
   const lastBrace = trimmed.lastIndexOf("}");
@@ -521,148 +916,526 @@ function parseClaudeOutput(raw) {
   }
   if (start === -1) return {};
   try {
-    const parsed = JSON.parse(trimmed.slice(start, lastBrace + 1));
-    const result = {};
-    if (typeof parsed["total_cost_usd"] === "number") {
-      result.costUsd = parsed["total_cost_usd"];
-    }
-    if (typeof parsed["session_id"] === "string") {
-      result.sessionId = parsed["session_id"];
-    }
-    if (typeof parsed["is_error"] === "boolean") {
-      result.isError = parsed["is_error"];
-    }
-    if (typeof parsed["result"] === "string") {
-      result.resultText = parsed["result"];
+    const p = JSON.parse(trimmed.slice(start, lastBrace + 1));
+    const r = {};
+    if (typeof p["total_cost_usd"] === "number") r.costUsd = p["total_cost_usd"];
+    if (typeof p["session_id"] === "string") r.sessionId = p["session_id"];
+    if (typeof p["is_error"] === "boolean") r.isError = p["is_error"];
+    if (typeof p["result"] === "string") r.resultText = p["result"];
+    if (typeof p["api_error_status"] === "number") r.apiErrorStatus = p["api_error_status"];
+    const u = p["usage"];
+    if (u && typeof u === "object") {
+      const uo = u;
+      if (typeof uo["input_tokens"] === "number") r.tokensInput = uo["input_tokens"];
+      if (typeof uo["output_tokens"] === "number") r.tokensOutput = uo["output_tokens"];
     }
-    const usage = parsed["usage"];
-    if (usage && typeof usage === "object") {
-      const u = usage;
-      if (typeof u["input_tokens"] === "number") result.tokensInput = u["input_tokens"];
-      if (typeof u["output_tokens"] === "number") result.tokensOutput = u["output_tokens"];
-    }
-    return result;
+    return r;
   } catch {
     return {};
   }
 }
-async function runWorkItem(config, work) {
-  const agent = findAgent(work.agent.id);
-  const model = agent?.model ?? work.agent.model;
-  const agentWorkspace = agentWorkspaceDir(work.agent.id);
-  let cwd = agentWorkspace;
-  if (work.workingDir && existsSync(work.workingDir)) {
-    cwd = work.workingDir;
-  } else if (work.workingDir) {
-    logWarn(
-      `workingDir "${work.workingDir}" does not exist; falling back to agent workspace`
-    );
+function classifyFailure(stderr, resultText, apiErrorStatus) {
+  const h = `${stderr}
+${resultText ?? ""}`.toLowerCase();
+  if (apiErrorStatus === 429 || apiErrorStatus === 529 || /rate.?limit|overloaded|too many requests|usage limit|quota|exhausted/.test(h)) return "rate_limited";
+  if (/enoent|not recognized|command not found|login|authenticate|credentials|api key/.test(h))
+    return "environment";
+  return "error";
+}
+function resolveRuntime(agentRuntime) {
+  switch (agentRuntime) {
+    case "codex":
+      return "codex";
+    case "hermes":
+      return "hermes";
+    default:
+      return "claude-code";
   }
-  log(`Starting run ${work.runId} (agent "${work.agent.name}", model "${model}")`);
-  log(`  cwd: ${cwd}`);
-  const claude = resolveClaudeCommand();
-  const settingsPath = join(agentWorkspace, ".claude", "settings.json").replace(/\\/g, "/");
+}
+function parseCodexOutput(raw) {
+  const trimmed = raw.trim();
+  const lastBrace = trimmed.lastIndexOf("}");
+  if (lastBrace === -1) return {};
+  let depth = 0;
+  let start = -1;
+  for (let i = lastBrace; i >= 0; i--) {
+    if (trimmed[i] === "}") depth++;
+    else if (trimmed[i] === "{") {
+      depth--;
+      if (depth === 0) {
+        start = i;
+        break;
+      }
+    }
+  }
+  if (start === -1) return {};
+  try {
+    const p = JSON.parse(trimmed.slice(start, lastBrace + 1));
+    const r = {};
+    if (typeof p["result"] === "string") r.resultText = p["result"];
+    if (typeof p["output"] === "string") r.resultText = p["output"];
+    if (typeof p["cost"] === "number") r.costUsd = p["cost"];
+    if (p["error"] !== void 0) r.isError = true;
+    return r;
+  } catch {
+    return {};
+  }
+}
+var HANDOFF_TIMEOUT_MS = 4 * 60 * 1e3;
+async function runHandoffTurn(claude, agentWorkspace, settingsPath, model, oldSessionId) {
   const rawArgs = [
     "-p",
     "--output-format",
     "json",
     "--max-turns",
-    "25",
+    "6",
     "--model",
     model,
     "--settings",
-    settingsPath
+    settingsPath,
+    "--resume",
+    oldSessionId
   ];
-  const persistent = work.agent.localSessionMode === "persistent";
-  let sessionState = loadSessionState(work.agent.id);
-  if (persistent) {
-    if (shouldRotateSession(sessionState, Date.now())) {
-      if (sessionState.sessionId) {
-        log(`Rotating session for agent "${work.agent.name}" (age/run limit reached)`);
-      }
-      sessionState = { sessionId: null, sessionStartedAt: null, runCount: 0 };
-    } else if (sessionState.sessionId) {
-      rawArgs.push("--resume", sessionState.sessionId);
-    }
-  }
-  const args = claude.shell ? rawArgs.map((a) => /[\s"^&|<>%]/.test(a) ? `"${a.replace(/"/g, '""')}"` : a) : rawArgs;
-  const env = { ...process.env };
-  let stdoutBuf = "";
-  let stderrBuf = "";
-  let exitCode = null;
-  let spawnError;
+  const args = claude.shell ? shellEscapeArgs(rawArgs) : rawArgs;
   await new Promise((resolve) => {
     let child;
     try {
       child = spawn(claude.cmd, args, {
-        cwd,
-        env,
-        // shell only as a last resort (Windows .cmd shim). Safe because argv
-        // contains only our fixed, pre-quoted tokens.
+        cwd: agentWorkspace,
+        env: { ...process.env },
         shell: claude.shell,
-        // stdin: pipe — the prompt is delivered via stdin, not argv.
-        stdio: ["pipe", "pipe", "pipe"]
+        stdio: ["pipe", "ignore", "ignore"]
       });
-      child.stdin?.write(work.prompt);
+      child.stdin?.write(
+        "Your session is about to be rotated (context limit). Write or overwrite HANDOFF.md in your workspace root RIGHT NOW: what you were working on, current state, decisions in flight, and the immediate next step. Max 60 lines. Do nothing else."
+      );
       child.stdin?.end();
     } catch (err) {
-      spawnError = err instanceof Error ? err.message : String(err);
+      logWarn(`Handoff turn failed to spawn: ${err instanceof Error ? err.message : String(err)}`);
       resolve();
       return;
     }
-    const timeoutHandle = setTimeout(() => {
-      logWarn(`Run ${work.runId} exceeded timeout \u2014 sending SIGTERM`);
+    const timer = setTimeout(() => {
+      logWarn("Handoff turn timed out \u2014 rotating without handoff doc");
       try {
         child.kill("SIGTERM");
       } catch {
       }
-      setTimeout(() => {
-        try {
-          child.kill("SIGKILL");
-        } catch {
-        }
-      }, 5e3);
-    }, RUN_TIMEOUT_MS);
-    child.stdout?.on("data", (chunk) => {
-      stdoutBuf += chunk.toString("utf-8");
+    }, HANDOFF_TIMEOUT_MS);
+    child.on("close", () => {
+      clearTimeout(timer);
+      log("Handoff turn complete");
+      resolve();
+    });
+    child.on("error", () => {
+      clearTimeout(timer);
+      resolve();
     });
-    child.stderr?.on("data", (chunk) => {
-      stderrBuf += chunk.toString("utf-8");
+  });
+}
+async function spawnMemorySync(agentWorkspace) {
+  const scriptPath = join(agentWorkspace, ".claude", "memory-sync.mjs");
+  if (!existsSync(scriptPath)) return;
+  await new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn(process.execPath, [scriptPath], {
+        cwd: agentWorkspace,
+        env: { ...process.env },
+        shell: false,
+        stdio: ["ignore", "ignore", "pipe"]
+      });
+    } catch (err) {
+      logWarn(`Memory sync spawn failed: ${err instanceof Error ? err.message : String(err)}`);
+      resolve();
+      return;
+    }
+    let stderrBuf = "";
+    child.stderr?.on("data", (c) => {
+      stderrBuf += c.toString("utf-8");
     });
+    const timer = setTimeout(() => {
+      logWarn("Memory sync timed out after 60s \u2014 killing");
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+    }, 6e4);
     child.on("close", (code) => {
-      clearTimeout(timeoutHandle);
-      exitCode = code;
+      clearTimeout(timer);
+      if (code !== 0) logWarn(`Memory sync exited ${String(code)}${stderrBuf ? `: ${stderrBuf.slice(-500)}` : ""}`);
       resolve();
     });
     child.on("error", (err) => {
-      clearTimeout(timeoutHandle);
-      spawnError = err.message;
+      clearTimeout(timer);
+      logWarn(`Memory sync error: ${err.message}`);
       resolve();
     });
   });
-  const stdoutExcerpt = stdoutBuf.length > STDOUT_CAP ? stdoutBuf.slice(-STDOUT_CAP) : stdoutBuf;
-  const stderrExcerpt = stderrBuf.length > STDERR_CAP ? stderrBuf.slice(-STDERR_CAP) : stderrBuf;
-  const parsed = parseClaudeOutput(stdoutBuf);
-  const succeeded = spawnError === void 0 && exitCode === 0 && parsed.isError !== true;
-  const errorMessage = succeeded ? void 0 : spawnError ?? (parsed.isError ? parsed.resultText?.slice(0, 1e3) : void 0) ?? (stderrExcerpt.trim() ? stderrExcerpt.trim().slice(-1e3) : void 0) ?? `claude exited with code ${exitCode ?? "unknown"}`;
-  const { isError: _isError, resultText: _resultText, ...reportFields } = parsed;
-  const report = {
-    runId: work.runId,
-    wakeupId: work.wakeupId,
-    status: succeeded ? "completed" : "failed",
-    stdoutExcerpt,
-    stderrExcerpt,
-    error: errorMessage,
-    exitCode,
-    ...reportFields
-  };
-  log(
-    `Run ${work.runId} ${report.status} (exit ${exitCode ?? "n/a"}${parsed.costUsd !== void 0 ? `, cost $${parsed.costUsd.toFixed(4)}` : ""})`
+}
+function buildCodexSpawnConfig(model, allowedTools) {
+  const useShell = process.platform === "win32";
+  const rawArgs = ["exec", "--json"];
+  if (model && model.trim().length > 0) {
+    rawArgs.push("--model", model);
+  }
+  if (allowedTools.length > 0) {
+    log(`codex runtime: --allowedTools [${allowedTools.join(",")}] not forwarded (no codex equivalent); use sandbox isolation for tool restriction`);
+  }
+  const args = useShell ? shellEscapeArgs(rawArgs) : rawArgs;
+  return { cmd: "codex", args, shell: useShell, promptAsArg: false };
+}
+function buildHermesSpawnConfig(model, allowedTools) {
+  const useShell = process.platform === "win32";
+  const rawArgs = ["-z"];
+  if (model && model.trim().length > 0) {
+    rawArgs.push("--model", model);
+  }
+  if (allowedTools.length > 0) {
+    const hermesToolsets = allowedTools.filter(
+      (t) => /^(web|terminal|development|safe|memory|messaging|calendar|files|code|search)$/i.test(t)
+    );
+    if (hermesToolsets.length > 0) {
+      rawArgs.push("--toolsets", hermesToolsets.join(","));
+    } else {
+      log(`hermes runtime: allowedTools [${allowedTools.join(",")}] not in hermes toolset format; skipping --toolsets`);
+    }
+  }
+  const args = useShell ? shellEscapeArgs(rawArgs) : rawArgs;
+  return { cmd: "hermes", args, shell: useShell, promptAsArg: false };
+}
+async function runWorkItem(config, work) {
+  if (!work.agent) {
+    logWarn(`Run ${work.runId} has no agent \u2014 not an agent_run work item; skipping`);
+    await sendReport(config, {
+      runId: work.runId,
+      wakeupId: work.wakeupId,
+      status: "failed",
+      failureKind: "config_error",
+      stdoutExcerpt: "",
+      stderrExcerpt: "",
+      error: "Work item has no agent (wrong kind reached runWorkItem)",
+      exitCode: null
+    });
+    return;
+  }
+  const workAgent = work.agent;
+  const agent = findAgent(workAgent.id);
+  const model = agent?.model ?? workAgent.model;
+  const agentWorkspace = agentWorkspaceDir(workAgent.id);
+  const runtime = resolveRuntime(
+    workAgent.agentRuntime ?? agent?.agentRuntime
   );
-  if (persistent && report.status === "completed") {
-    recordRunSession(work.agent.id, parsed.sessionId, sessionState, Date.now());
+  let cwd = agentWorkspace;
+  if (work.workingDir && existsSync(work.workingDir)) {
+    cwd = work.workingDir;
+  } else if (work.workingDir) {
+    logWarn(`workingDir "${work.workingDir}" does not exist; falling back to agent workspace`);
+  }
+  log(`Starting run ${work.runId} (agent "${workAgent.name}", runtime "${runtime}", model "${model}")`);
+  log(`  cwd: ${cwd}`);
+  const env = { ...process.env };
+  if (runtime === "hermes") {
+    env["HERMES_HOME"] = join(agentWorkspace, ".hermes");
+  }
+  const promptText = buildPromptText({
+    workPrompt: work.prompt,
+    agent,
+    cwd,
+    agentWorkspace,
+    rotated: false
+  });
+  let stdoutBuf = "", stderrBuf = "";
+  let exitCode = null;
+  let spawnError;
+  if (runtime === "claude-code") {
+    const claude = resolveClaudeCommand();
+    const settingsPath = join(agentWorkspace, ".claude", "settings.json").replace(/\\/g, "/");
+    const rawArgs = [
+      "-p",
+      "--output-format",
+      "json",
+      "--max-turns",
+      "25",
+      "--model",
+      model,
+      "--settings",
+      settingsPath
+    ];
+    if (Array.isArray(workAgent.allowedTools) && workAgent.allowedTools.length > 0) {
+      rawArgs.push("--allowedTools", workAgent.allowedTools.join(","));
+    }
+    const persistent = workAgent.localSessionMode === "persistent";
+    let sessionState = loadSessionState(workAgent.id);
+    let rotated = false;
+    if (persistent) {
+      if (shouldRotateSession(sessionState, Date.now())) {
+        if (sessionState.sessionId) {
+          log(`Rotating session for agent "${workAgent.name}" (age/run limit reached)`);
+          await runHandoffTurn(claude, agentWorkspace, settingsPath, model, sessionState.sessionId);
+          rotated = true;
+        }
+        sessionState = { sessionId: null, sessionStartedAt: null, runCount: 0 };
+      } else if (sessionState.sessionId) {
+        rawArgs.push("--resume", sessionState.sessionId);
+      }
+    }
+    const claudePromptText = buildPromptText({
+      workPrompt: work.prompt,
+      agent,
+      cwd,
+      agentWorkspace,
+      rotated
+    });
+    const args = claude.shell ? shellEscapeArgs(rawArgs) : rawArgs;
+    await new Promise((resolve) => {
+      let child;
+      try {
+        child = spawn(claude.cmd, args, {
+          cwd,
+          env,
+          shell: claude.shell,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        child.stdin?.write(claudePromptText);
+        child.stdin?.end();
+      } catch (err) {
+        spawnError = err instanceof Error ? err.message : String(err);
+        resolve();
+        return;
+      }
+      const timeoutHandle = setTimeout(() => {
+        logWarn(`Run ${work.runId} exceeded timeout \u2014 sending SIGTERM`);
+        try {
+          child.kill("SIGTERM");
+        } catch {
+        }
+        setTimeout(() => {
+          try {
+            child.kill("SIGKILL");
+          } catch {
+          }
+        }, 5e3);
+      }, RUN_TIMEOUT_MS);
+      child.stdout?.on("data", (c) => {
+        stdoutBuf += c.toString("utf-8");
+      });
+      child.stderr?.on("data", (c) => {
+        stderrBuf += c.toString("utf-8");
+      });
+      child.on("close", (code) => {
+        clearTimeout(timeoutHandle);
+        exitCode = code;
+        resolve();
+      });
+      child.on("error", (err) => {
+        clearTimeout(timeoutHandle);
+        spawnError = err.message;
+        resolve();
+      });
+    });
+    const stdoutExcerpt = stdoutBuf.length > STDOUT_CAP ? stdoutBuf.slice(-STDOUT_CAP) : stdoutBuf;
+    const stderrExcerpt = stderrBuf.length > STDERR_CAP ? stderrBuf.slice(-STDERR_CAP) : stderrBuf;
+    const parsed = parseClaudeOutput(stdoutBuf);
+    const succeeded = spawnError === void 0 && exitCode === 0 && parsed.isError !== true;
+    const errorMessage = succeeded ? void 0 : spawnError ?? (parsed.isError ? parsed.resultText?.slice(0, 1e3) : void 0) ?? (stderrExcerpt.trim() ? stderrExcerpt.trim().slice(-1e3) : void 0) ?? `claude exited with code ${exitCode ?? "unknown"}`;
+    const failureKind = succeeded ? void 0 : classifyFailure(stderrExcerpt, parsed.resultText, parsed.apiErrorStatus);
+    const { isError: _ie, resultText: _rt, apiErrorStatus: _aes, ...reportFields } = parsed;
+    const report = {
+      runId: work.runId,
+      wakeupId: work.wakeupId,
+      status: succeeded ? "completed" : "failed",
+      failureKind,
+      stdoutExcerpt,
+      stderrExcerpt,
+      error: errorMessage,
+      exitCode,
+      ...reportFields
+    };
+    log(`Run ${work.runId} ${report.status} (exit ${exitCode ?? "n/a"}${parsed.costUsd !== void 0 ? `, cost $${parsed.costUsd.toFixed(4)}` : ""})`);
+    if (persistent && report.status === "completed") {
+      recordRunSession(workAgent.id, parsed.sessionId, sessionState, Date.now());
+    }
+    await sendReport(config, report);
+    if (report.status === "completed") {
+      await spawnMemorySync(agentWorkspace);
+    }
+  } else if (runtime === "codex") {
+    if (!isValidModelSlug(model)) {
+      logWarn(`Run ${work.runId} aborted \u2014 model slug failed validation: "${model}"`);
+      const report2 = {
+        runId: work.runId,
+        wakeupId: work.wakeupId,
+        status: "failed",
+        failureKind: "config_error",
+        stdoutExcerpt: "",
+        stderrExcerpt: "",
+        error: `Invalid model slug: "${model}" \u2014 must match ^[A-Za-z0-9._:+/-]+$`,
+        exitCode: null
+      };
+      await sendReport(config, report2);
+      return;
+    }
+    const spawnCfg = buildCodexSpawnConfig(model, workAgent.allowedTools ?? []);
+    const args = spawnCfg.args;
+    await new Promise((resolve) => {
+      let child;
+      try {
+        child = spawn(spawnCfg.cmd, args, {
+          cwd,
+          env,
+          shell: spawnCfg.shell,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        if (!spawnCfg.promptAsArg) {
+          child.stdin?.write(promptText);
+        }
+        child.stdin?.end();
+      } catch (err) {
+        spawnError = err instanceof Error ? err.message : String(err);
+        resolve();
+        return;
+      }
+      const timeoutHandle = setTimeout(() => {
+        logWarn(`Run ${work.runId} exceeded timeout \u2014 sending SIGTERM`);
+        try {
+          child.kill("SIGTERM");
+        } catch {
+        }
+        setTimeout(() => {
+          try {
+            child.kill("SIGKILL");
+          } catch {
+          }
+        }, 5e3);
+      }, RUN_TIMEOUT_MS);
+      child.stdout?.on("data", (c) => {
+        stdoutBuf += c.toString("utf-8");
+      });
+      child.stderr?.on("data", (c) => {
+        stderrBuf += c.toString("utf-8");
+      });
+      child.on("close", (code) => {
+        clearTimeout(timeoutHandle);
+        exitCode = code;
+        resolve();
+      });
+      child.on("error", (err) => {
+        clearTimeout(timeoutHandle);
+        spawnError = err.message;
+        resolve();
+      });
+    });
+    const stdoutExcerpt = stdoutBuf.length > STDOUT_CAP ? stdoutBuf.slice(-STDOUT_CAP) : stdoutBuf;
+    const stderrExcerpt = stderrBuf.length > STDERR_CAP ? stderrBuf.slice(-STDERR_CAP) : stderrBuf;
+    const parsed = parseCodexOutput(stdoutBuf);
+    const succeeded = spawnError === void 0 && exitCode === 0 && parsed.isError !== true;
+    const errorMessage = succeeded ? void 0 : spawnError ?? (stderrExcerpt.trim() ? stderrExcerpt.trim().slice(-1e3) : void 0) ?? `codex exited with code ${exitCode ?? "unknown"}`;
+    const failureKind = succeeded ? void 0 : classifyFailure(stderrExcerpt, parsed.resultText ?? stdoutBuf.slice(0, 500), void 0);
+    const report = {
+      runId: work.runId,
+      wakeupId: work.wakeupId,
+      status: succeeded ? "completed" : "failed",
+      failureKind,
+      stdoutExcerpt,
+      stderrExcerpt,
+      error: errorMessage,
+      exitCode,
+      costUsd: parsed.costUsd
+    };
+    log(`Run ${work.runId} ${report.status} \u2014 codex (exit ${exitCode ?? "n/a"}${parsed.costUsd !== void 0 ? `, cost $${parsed.costUsd.toFixed(4)}` : ""})`);
+    await sendReport(config, report);
+    if (report.status === "completed") {
+      await spawnMemorySync(agentWorkspace);
+    }
+  } else {
+    log(`Hermes runtime: HERMES_YOLO_MODE is forced on by -z \u2014 ensure this bridge machine is sandboxed/isolated`);
+    log(`  HERMES_HOME: ${env["HERMES_HOME"] ?? "(default)"}`);
+    if (!isValidModelSlug(model)) {
+      logWarn(`Run ${work.runId} aborted \u2014 model slug failed validation: "${model}"`);
+      const report2 = {
+        runId: work.runId,
+        wakeupId: work.wakeupId,
+        status: "failed",
+        failureKind: "config_error",
+        stdoutExcerpt: "",
+        stderrExcerpt: "",
+        error: `Invalid model slug: "${model}" \u2014 must match ^[A-Za-z0-9._:+/-]+$`,
+        exitCode: null
+      };
+      await sendReport(config, report2);
+      return;
+    }
+    const spawnCfg = buildHermesSpawnConfig(model, workAgent.allowedTools ?? []);
+    const args = spawnCfg.args;
+    await new Promise((resolve) => {
+      let child;
+      try {
+        child = spawn(spawnCfg.cmd, args, {
+          cwd,
+          env,
+          shell: spawnCfg.shell,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        child.stdin?.write(promptText);
+        child.stdin?.end();
+      } catch (err) {
+        spawnError = err instanceof Error ? err.message : String(err);
+        resolve();
+        return;
+      }
+      const timeoutHandle = setTimeout(() => {
+        logWarn(`Run ${work.runId} exceeded timeout \u2014 sending SIGTERM`);
+        try {
+          child.kill("SIGTERM");
+        } catch {
+        }
+        setTimeout(() => {
+          try {
+            child.kill("SIGKILL");
+          } catch {
+          }
+        }, 5e3);
+      }, RUN_TIMEOUT_MS);
+      child.stdout?.on("data", (c) => {
+        stdoutBuf += c.toString("utf-8");
+      });
+      child.stderr?.on("data", (c) => {
+        stderrBuf += c.toString("utf-8");
+      });
+      child.on("close", (code) => {
+        clearTimeout(timeoutHandle);
+        exitCode = code;
+        resolve();
+      });
+      child.on("error", (err) => {
+        clearTimeout(timeoutHandle);
+        spawnError = err.message;
+        resolve();
+      });
+    });
+    const stdoutExcerpt = stdoutBuf.length > STDOUT_CAP ? stdoutBuf.slice(-STDOUT_CAP) : stdoutBuf;
+    const stderrExcerpt = stderrBuf.length > STDERR_CAP ? stderrBuf.slice(-STDERR_CAP) : stderrBuf;
+    const succeeded = spawnError === void 0 && exitCode === 0;
+    const errorMessage = succeeded ? void 0 : spawnError ?? (stderrExcerpt.trim() ? stderrExcerpt.trim().slice(-1e3) : void 0) ?? `hermes exited with code ${exitCode ?? "unknown"}`;
+    const failureKind = succeeded ? void 0 : classifyFailure(stderrExcerpt, stdoutBuf.slice(0, 500), void 0);
+    const report = {
+      runId: work.runId,
+      wakeupId: work.wakeupId,
+      status: succeeded ? "completed" : "failed",
+      failureKind,
+      stdoutExcerpt,
+      stderrExcerpt,
+      error: errorMessage,
+      exitCode
+      // No costUsd / tokensInput / tokensOutput from hermes -z (FLAG above).
+    };
+    log(`Run ${work.runId} ${report.status} \u2014 hermes (exit ${exitCode ?? "n/a"})`);
+    await sendReport(config, report);
+    if (report.status === "completed") {
+      await spawnMemorySync(agentWorkspace);
+    }
   }
-  await sendReport(config, report);
 }
 async function sendReport(config, report) {
   const path = `/api/bridge/v1/runs/${report.runId}`;
@@ -674,46 +1447,251 @@ async function sendReport(config, report) {
       return;
     } catch (err) {
       logError(`Failed to report run ${report.runId} (attempt ${attempt})`, err);
-      if (attempt < REPORT_RETRY_COUNT) {
-        const delay = REPORT_RETRY_BASE_MS * Math.pow(2, attempt - 1);
-        await sleep(delay);
-      }
+      if (attempt < REPORT_RETRY_COUNT) await sleep(REPORT_RETRY_BASE_MS * Math.pow(2, attempt - 1));
     }
   }
   logWarn(`Persisting failed report for run ${report.runId} to pending-reports.json`);
-  appendPendingReport(report);
+  enqueue({ runId: report.runId, report, attempts: REPORT_RETRY_COUNT, firstFailedAt: (/* @__PURE__ */ new Date()).toISOString() });
 }
 async function retryPendingReports(config) {
-  const pending = readJsonSafe(PENDING_REPORTS_PATH);
-  if (!pending || pending.length === 0) return;
-  log(`Retrying ${pending.length} pending report(s)`);
-  for (const report of pending) {
-    await sendReport(config, report);
+  await drain(async (item) => {
+    const path = `/api/bridge/v1/runs/${item.report.runId}`;
+    await post(config, path, item.report);
+    log(`Reported run ${item.report.runId} (from queue)`);
+  });
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var STDOUT_CAP2 = 1e4;
+var STDERR_CAP2 = 4e3;
+var DEFAULT_EXEC_TIMEOUT_MS = 3e4;
+var MAX_EXEC_TIMEOUT_MS = 6e4;
+var KILL_GRACE_MS = 5e3;
+function resolveExecTimeout(timeoutMs) {
+  if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    return DEFAULT_EXEC_TIMEOUT_MS;
   }
+  return Math.min(timeoutMs, MAX_EXEC_TIMEOUT_MS);
 }
-function appendPendingReport(report) {
-  const existing = readJsonSafe(PENDING_REPORTS_PATH) ?? [];
-  const deduped = existing.filter((r) => r.runId !== report.runId);
-  deduped.push(report);
-  writeJsonAtomic(PENDING_REPORTS_PATH, deduped);
+function capExcerpt(buf, cap) {
+  return buf.length > cap ? buf.slice(-cap) : buf;
 }
-function removePendingReport(runId) {
-  const existing = readJsonSafe(PENDING_REPORTS_PATH);
-  if (!existing || existing.length === 0) return;
-  const filtered = existing.filter((r) => r.runId !== runId);
-  if (filtered.length !== existing.length) {
-    writeJsonAtomic(PENDING_REPORTS_PATH, filtered);
+function classifyExec(opts) {
+  if (opts.timedOut) return { exitCode: opts.exitCode, status: "timeout" };
+  if (opts.spawnError !== void 0) return { exitCode: opts.exitCode, status: "failed" };
+  if (opts.exitCode === 0) return { exitCode: 0, status: "completed" };
+  return { exitCode: opts.exitCode, status: "failed" };
+}
+function resolveExecShell(command) {
+  if (process.platform === "win32") {
+    return { cmd: process.env["ComSpec"] ?? "cmd.exe", args: ["/d", "/s", "/c", command], shell: false };
   }
+  const sh = process.env["SHELL"] ?? "/bin/sh";
+  return { cmd: sh, args: ["-c", command], shell: false };
 }
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+async function execShellCommand(command, options = {}) {
+  const timeoutMs = resolveExecTimeout(options.timeoutMs);
+  const { cmd, args, shell } = resolveExecShell(command);
+  const spawnCwd = options.cwd && options.cwd.length > 0 ? options.cwd : void 0;
+  let stdoutBuf = "";
+  let stderrBuf = "";
+  let exitCode = null;
+  let spawnError;
+  let timedOut = false;
+  await new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn(cmd, args, {
+        cwd: spawnCwd,
+        env: { ...process.env },
+        shell,
+        stdio: ["ignore", "pipe", "pipe"],
+        windowsHide: true
+      });
+    } catch (err) {
+      spawnError = err instanceof Error ? err.message : String(err);
+      resolve();
+      return;
+    }
+    const timeoutHandle = setTimeout(() => {
+      timedOut = true;
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      setTimeout(() => {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+      }, KILL_GRACE_MS);
+    }, timeoutMs);
+    child.stdout?.on("data", (c) => {
+      stdoutBuf += c.toString("utf-8");
+    });
+    child.stderr?.on("data", (c) => {
+      stderrBuf += c.toString("utf-8");
+    });
+    child.on("close", (code) => {
+      clearTimeout(timeoutHandle);
+      exitCode = code;
+      resolve();
+    });
+    child.on("error", (err) => {
+      clearTimeout(timeoutHandle);
+      spawnError = err.message;
+      resolve();
+    });
+  });
+  const stdoutExcerpt = capExcerpt(stdoutBuf, STDOUT_CAP2);
+  const stderrSource = spawnError !== void 0 && stderrBuf.length === 0 ? spawnError : stderrBuf;
+  const stderrExcerpt = capExcerpt(stderrSource, STDERR_CAP2);
+  const { exitCode: finalExit, status } = classifyExec({ exitCode, spawnError, timedOut });
+  return { exitCode: finalExit, stdoutExcerpt, stderrExcerpt, status };
+}
+var DEFAULT_COLS = 120;
+var DEFAULT_ROWS = 30;
+function loadNodePty() {
+  try {
+    return __require("node-pty");
+  } catch (err) {
+    logWarn(`node-pty unavailable: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+}
+function resolveShell(override) {
+  if (override && override.length > 0) {
+    return { shell: override, args: os.platform() === "win32" ? [] : ["--login"] };
+  }
+  if (os.platform() === "win32") {
+    const gitBashPaths = [
+      "C:\\Program Files\\Git\\bin\\bash.exe",
+      "C:\\Program Files (x86)\\Git\\bin\\bash.exe"
+    ];
+    const bashPath = gitBashPaths.find((p) => existsSync(p));
+    if (bashPath) return { shell: bashPath, args: ["--login", "-i"] };
+    return { shell: "powershell.exe", args: ["-NoLogo"] };
+  }
+  return { shell: process.env["SHELL"] ?? "/bin/bash", args: ["--login"] };
+}
+function buildDaemonJoinUrl(relayWsUrl, joinToken) {
+  const base = relayWsUrl.replace(/\/+$/, "");
+  return `${base}/daemon?token=${encodeURIComponent(joinToken)}`;
+}
+async function openTerminalSession(opts) {
+  const { WebSocket } = await import('ws');
+  const url = buildDaemonJoinUrl(opts.relayWsUrl, opts.joinToken);
+  const cols = opts.cols && opts.cols > 0 ? opts.cols : DEFAULT_COLS;
+  const rows = opts.rows && opts.rows > 0 ? opts.rows : DEFAULT_ROWS;
+  const ws = new WebSocket(url);
+  let pty = null;
+  let closed = false;
+  const send = (frame) => {
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify(frame));
+    }
+  };
+  const cleanup = (reason) => {
+    if (closed) return;
+    closed = true;
+    if (pty) {
+      try {
+        pty.kill();
+      } catch {
+      }
+      pty = null;
+    }
+    try {
+      ws.close();
+    } catch {
+    }
+    log(`[terminal] session ${opts.sessionId} closed (${reason})`);
+    if (opts.onClosed) {
+      try {
+        opts.onClosed(opts.sessionId);
+      } catch {
+      }
+    }
+  };
+  const handle = {
+    sessionId: opts.sessionId,
+    close: () => cleanup("handle.close")
+  };
+  ws.on("open", () => {
+    send({ type: "auth", joinToken: opts.joinToken, sessionId: opts.sessionId });
+    const nodePty = loadNodePty();
+    if (!nodePty) {
+      send({
+        type: "output",
+        data: "\r\n[stride-bridge] Interactive terminal unavailable on this machine: node-pty is not installed. Non-interactive commands (Processes, Services, Logs, Actions, Snippets) still work.\r\n"
+      });
+      send({ type: "error", message: "node-pty unavailable on daemon host" });
+      cleanup("node-pty unavailable");
+      return;
+    }
+    const { shell, args } = resolveShell(opts.shell);
+    try {
+      pty = nodePty.spawn(shell, args, {
+        name: "xterm-256color",
+        cols,
+        rows,
+        cwd: opts.cwd && opts.cwd.length > 0 ? opts.cwd : os.homedir(),
+        env: process.env
+      });
+    } catch (err) {
+      send({
+        type: "error",
+        message: `Failed to spawn shell: ${err instanceof Error ? err.message : String(err)}`
+      });
+      cleanup("pty spawn failed");
+      return;
+    }
+    pty.onData((data) => {
+      send({ type: "output", data });
+    });
+    pty.onExit(({ exitCode }) => {
+      send({ type: "exit", code: exitCode });
+      cleanup(`pty exit ${exitCode}`);
+    });
+    send({ type: "ready" });
+    log(`[terminal] session ${opts.sessionId} ready (${shell})`);
+  });
+  ws.on("message", (raw) => {
+    const text = Buffer.isBuffer(raw) ? raw.toString("utf-8") : Array.isArray(raw) ? Buffer.concat(raw).toString("utf-8") : Buffer.from(raw).toString("utf-8");
+    let frame;
+    try {
+      frame = JSON.parse(text);
+    } catch {
+      if (pty) pty.write(text);
+      return;
+    }
+    if (frame.type === "input" && typeof frame.data === "string") {
+      if (pty) pty.write(frame.data);
+    } else if (frame.type === "resize" && typeof frame.cols === "number" && typeof frame.rows === "number") {
+      if (pty) {
+        try {
+          pty.resize(frame.cols, frame.rows);
+        } catch {
+        }
+      }
+    } else if (frame.type === "ping") {
+      send({ type: "pong" });
+    }
+  });
+  ws.on("close", () => cleanup("ws close"));
+  ws.on("error", (err) => {
+    logWarn(`[terminal] session ${opts.sessionId} ws error: ${err.message}`);
+    cleanup("ws error");
+  });
+  return handle;
 }
 var USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
-var CACHE_TTL_MS = 6e4;
+var CACHE_TTL_MS2 = 6e4;
 var FETCH_TIMEOUT_MS = 5e3;
 function remainingPct(utilization) {
   if (typeof utilization !== "number" || !Number.isFinite(utilization)) return null;
-  return Math.max(0, Math.min(100, Math.round((1 - utilization) * 100)));
+  return Math.max(0, Math.min(100, Math.round(100 - utilization)));
 }
 function parseUsageResponse(body, nowIso) {
   return {
@@ -729,10 +1707,10 @@ function readOauthToken() {
   );
   return creds?.claudeAiOauth?.accessToken ?? null;
 }
-var cached = null;
+var cached2 = null;
 var warnedNoToken = false;
 async function getQuotaSnapshot() {
-  if (cached && Date.now() - cached.at < CACHE_TTL_MS) return cached.snapshot;
+  if (cached2 && Date.now() - cached2.at < CACHE_TTL_MS2) return cached2.snapshot;
   const token = readOauthToken();
   if (!token) {
     if (!warnedNoToken) {
@@ -749,20 +1727,243 @@ async function getQuotaSnapshot() {
       signal: controller.signal
     });
     clearTimeout(timer);
-    if (!res.ok) return cached?.snapshot ?? null;
+    if (!res.ok) return cached2?.snapshot ?? null;
     const body = await res.json();
     const snapshot = parseUsageResponse(body, (/* @__PURE__ */ new Date()).toISOString());
-    cached = { snapshot, at: Date.now() };
+    cached2 = { snapshot, at: Date.now() };
     return snapshot;
   } catch {
-    return cached?.snapshot ?? null;
+    return cached2?.snapshot ?? null;
+  }
+}
+function readCpuTotals() {
+  let idle = 0;
+  let total = 0;
+  for (const cpu of cpus()) {
+    idle += cpu.times.idle;
+    total += cpu.times.user + cpu.times.nice + cpu.times.sys + cpu.times.idle + cpu.times.irq;
+  }
+  return { idle, total };
+}
+function computeCpuPct(prev, curr) {
+  const dTotal = curr.total - prev.total;
+  if (dTotal <= 0) return void 0;
+  const dIdle = curr.idle - prev.idle;
+  const pct = 100 * (1 - dIdle / dTotal);
+  return Math.round(Math.min(100, Math.max(0, pct)) * 10) / 10;
+}
+function parseMeminfo(content) {
+  const totalMatch = content.match(/MemTotal:\s+(\d+)\s*kB/);
+  const availMatch = content.match(/MemAvailable:\s+(\d+)\s*kB/);
+  if (!totalMatch || !availMatch) return void 0;
+  const totalMb = Math.round(Number(totalMatch[1]) / 1024);
+  const availMb = Math.round(Number(availMatch[1]) / 1024);
+  return { memUsedMb: totalMb - availMb, memTotalMb: totalMb };
+}
+function parseNetDev(content) {
+  let rxBytes = 0;
+  let txBytes = 0;
+  for (const line of content.split("\n")) {
+    const match = line.match(/^\s*([^:\s]+):\s*(\d+)(?:\s+\d+){7}\s+(\d+)/);
+    if (!match || match[1] === "lo") continue;
+    rxBytes += Number(match[2]);
+    txBytes += Number(match[3]);
+  }
+  return { rxBytes, txBytes };
+}
+function computeNetKbps(prev, curr) {
+  const seconds = (curr.at - prev.at) / 1e3;
+  if (seconds <= 0) return void 0;
+  const rx = (curr.rxBytes - prev.rxBytes) / 1024 / seconds;
+  const tx = (curr.txBytes - prev.txBytes) / 1024 / seconds;
+  if (rx < 0 || tx < 0) return void 0;
+  return { netRxKbps: Math.round(rx * 10) / 10, netTxKbps: Math.round(tx * 10) / 10 };
+}
+var prevCpu = null;
+var prevNet = null;
+async function collectHostMetrics() {
+  const metrics = {};
+  try {
+    const curr = readCpuTotals();
+    if (prevCpu) {
+      const pct = computeCpuPct(prevCpu, curr);
+      if (pct !== void 0) metrics.cpuPct = pct;
+    }
+    prevCpu = curr;
+  } catch {
+  }
+  try {
+    const load = loadavg()[0];
+    if (Number.isFinite(load)) metrics.load1 = Math.round(load * 100) / 100;
+  } catch {
+  }
+  try {
+    const meminfo = parseMeminfo(await readFile("/proc/meminfo", "utf8"));
+    if (meminfo) Object.assign(metrics, meminfo);
+  } catch {
+    const totalMb = Math.round(totalmem() / 1024 / 1024);
+    metrics.memTotalMb = totalMb;
+    metrics.memUsedMb = totalMb - Math.round(freemem() / 1024 / 1024);
+  }
+  try {
+    const root = platform() === "win32" ? "C:\\" : "/";
+    const stats = await statfs(root);
+    const totalGb = stats.blocks * stats.bsize / 1024 ** 3;
+    const freeGb = stats.bfree * stats.bsize / 1024 ** 3;
+    metrics.diskTotalGb = Math.round(totalGb * 10) / 10;
+    metrics.diskUsedGb = Math.round((totalGb - freeGb) * 10) / 10;
+  } catch {
+  }
+  try {
+    const parsed = parseNetDev(await readFile("/proc/net/dev", "utf8"));
+    const curr = { ...parsed, at: Date.now() };
+    if (prevNet) {
+      const kbps = computeNetKbps(prevNet, curr);
+      if (kbps) Object.assign(metrics, kbps);
+    }
+    prevNet = curr;
+  } catch {
   }
+  return metrics;
 }
 
 // src/poller.ts
 var POLL_INTERVAL_MS = 2500;
 var HEARTBEAT_INTERVAL_MS = 6e4;
 var BACKOFF_STEPS_MS = [2500, 5e3, 1e4, 3e4];
+var activeRunAgentId = null;
+var activeRunTask = void 0;
+var activeTerminalSessions = /* @__PURE__ */ new Map();
+var MAX_CONCURRENT_TERMINALS = 8;
+function classifyWorkItem(work) {
+  switch (work.kind) {
+    case "exec":
+      return "exec";
+    case "terminal_open":
+      return "terminal_open";
+    default:
+      return "agent_run";
+  }
+}
+async function handleExecWork(config, work) {
+  if (!work.execId || typeof work.command !== "string") {
+    logWarn(`exec work item missing execId/command (run ${work.runId}); ignoring`);
+    return;
+  }
+  const execId = work.execId;
+  log(`Running exec ${execId}`);
+  const result = await execShellCommand(work.command, {
+    cwd: work.cwd,
+    timeoutMs: work.timeoutMs
+  });
+  const payload = {
+    execId,
+    status: result.status,
+    exitCode: result.exitCode,
+    stdoutExcerpt: result.stdoutExcerpt,
+    stderrExcerpt: result.stderrExcerpt
+  };
+  try {
+    await post(config, `/api/bridge/v1/exec/${execId}`, payload);
+    log(`Reported exec ${execId} (${result.status})`);
+  } catch (err) {
+    logError(`Failed to report exec ${execId}`, err);
+  }
+}
+function dispatchTerminalWork(work) {
+  if (!work.sessionId || !work.relayWsUrl || !work.joinToken) {
+    logWarn(`terminal_open work item missing sessionId/relayWsUrl/joinToken (run ${work.runId}); ignoring`);
+    return;
+  }
+  const sessionId = work.sessionId;
+  if (activeTerminalSessions.has(sessionId)) {
+    return;
+  }
+  if (activeTerminalSessions.size >= MAX_CONCURRENT_TERMINALS) {
+    logWarn(
+      `terminal_open ignored \u2014 concurrency cap reached (${MAX_CONCURRENT_TERMINALS} active sessions)`
+    );
+    return;
+  }
+  const relayWsUrl = work.relayWsUrl;
+  const joinToken = work.joinToken;
+  const onClosed = (id) => {
+    activeTerminalSessions.delete(id);
+  };
+  let realHandle = null;
+  activeTerminalSessions.set(sessionId, {
+    sessionId,
+    close: () => {
+      if (realHandle) realHandle.close();
+      activeTerminalSessions.delete(sessionId);
+    }
+  });
+  log(`Opening terminal session ${sessionId} (detached)`);
+  void openTerminalSession({
+    relayWsUrl,
+    joinToken,
+    sessionId,
+    cols: work.cols,
+    rows: work.rows,
+    shell: work.shell,
+    cwd: work.cwd,
+    onClosed
+  }).then((handle) => {
+    realHandle = handle;
+    if (!activeTerminalSessions.has(sessionId)) {
+      handle.close();
+    }
+  }).catch((err) => {
+    logError(`Failed to open terminal session ${sessionId}`, err);
+    activeTerminalSessions.delete(sessionId);
+  });
+}
+function closeAllTerminalSessions() {
+  if (activeTerminalSessions.size === 0) return;
+  log(`Closing ${activeTerminalSessions.size} terminal session(s)`);
+  for (const handle of activeTerminalSessions.values()) {
+    try {
+      handle.close();
+    } catch {
+    }
+  }
+  activeTerminalSessions.clear();
+}
+function buildEventPayload(opts) {
+  const details = {
+    daemonVersion: opts.daemonVersion,
+    ...opts.osInfo ? { osInfo: opts.osInfo } : {},
+    ...opts.extra ?? {}
+  };
+  const payload = {
+    kind: opts.kind,
+    message: opts.message,
+    details
+  };
+  if (opts.agentId !== void 0) payload.agentId = opts.agentId;
+  return payload;
+}
+function buildHeartbeatPayload(opts) {
+  const agents = opts.agentIds.map((agentId) => {
+    if (agentId === opts.activeAgentId) {
+      const entry = { agentId, status: "running" };
+      if (opts.activeTask) entry.currentTask = opts.activeTask;
+      return entry;
+    }
+    return { agentId, status: "idle" };
+  });
+  const payload = {
+    daemonVersion: opts.daemonVersion,
+    osInfo: opts.osInfo,
+    agents
+  };
+  if (opts.quota !== void 0) payload.quota = opts.quota;
+  if (opts.runtimes !== void 0) payload.capabilities = opts.runtimes;
+  if (opts.hostMetrics !== void 0 && Object.keys(opts.hostMetrics).length > 0) {
+    payload.hostMetrics = opts.hostMetrics;
+  }
+  return payload;
+}
 var running = false;
 async function startDaemon(config) {
   running = true;
@@ -771,32 +1972,59 @@ async function startDaemon(config) {
     running = false;
     log(`Received ${signal} \u2014 shutting down gracefully`);
     stopAgentRefreshTimer();
-    await postBestEffort(config, "/api/bridge/v1/events", {
-      kind: "daemon_stopping",
-      message: `Daemon stopping (${signal})`,
-      daemonVersion: VERSION
-    });
+    closeAllTerminalSessions();
+    await postBestEffort(
+      config,
+      "/api/bridge/v1/events",
+      buildEventPayload({
+        kind: "daemon_stopping",
+        message: `Daemon stopping (${signal})`,
+        daemonVersion: VERSION
+      })
+    );
     process.exit(0);
   };
   process.on("SIGINT", () => void shutdown("SIGINT"));
   process.on("SIGTERM", () => void shutdown("SIGTERM"));
-  await postBestEffort(config, "/api/bridge/v1/events", {
-    kind: "daemon_started",
-    message: "Daemon started",
-    daemonVersion: VERSION,
-    osInfo: { platform: platform(), release: release() }
-  });
+  await postBestEffort(
+    config,
+    "/api/bridge/v1/events",
+    buildEventPayload({
+      kind: "daemon_started",
+      message: "Daemon started",
+      daemonVersion: VERSION,
+      osInfo: { platform: platform(), release: release() }
+    })
+  );
   log(`Daemon started (v${VERSION}, bridge ${config.bridgeId})`);
   await refreshAgents(config);
   startAgentRefreshTimer(config);
   const sendHeartbeat = async () => {
-    const payload = {
+    const cachedAgents2 = getCachedAgents();
+    const agentIds = cachedAgents2.map((a) => a.id);
+    const quota = await getQuotaSnapshot();
+    let runtimes;
+    try {
+      const all = await detectRuntimes();
+      const present = all.filter((r) => r.version.length > 0);
+      runtimes = present.length > 0 ? present : void 0;
+    } catch {
+    }
+    let hostMetrics;
+    try {
+      hostMetrics = await collectHostMetrics();
+    } catch {
+    }
+    const payload = buildHeartbeatPayload({
       daemonVersion: VERSION,
       osInfo: { platform: platform(), release: release() },
-      agents: []
-    };
-    const quota = await getQuotaSnapshot();
-    if (quota) payload.quota = quota;
+      agentIds,
+      activeAgentId: activeRunAgentId,
+      activeTask: activeRunTask,
+      quota: quota ?? void 0,
+      runtimes,
+      hostMetrics
+    });
     try {
       await post(config, "/api/bridge/v1/heartbeat", payload);
     } catch (err) {
@@ -816,11 +2044,30 @@ async function startDaemon(config) {
       const data = await post(config, "/api/bridge/v1/work", {});
       backoffIndex = 0;
       if (data.work) {
-        log(`Received work item: run ${data.work.runId}`);
+        const work = data.work;
+        const kind = classifyWorkItem(work);
+        log(`Received work item: run ${work.runId} (kind ${kind})`);
+        if (kind === "terminal_open") {
+          dispatchTerminalWork(work);
+          continue;
+        }
+        if (kind === "exec") {
+          try {
+            await handleExecWork(config, work);
+          } catch (err) {
+            logError(`Unhandled error in handleExecWork for run ${work.runId}`, err);
+          }
+          continue;
+        }
+        activeRunAgentId = work.agent?.id ?? null;
+        activeRunTask = work.prompt.slice(0, 200);
         try {
-          await runWorkItem(config, data.work);
+          await runWorkItem(config, work);
         } catch (err) {
-          logError(`Unhandled error in runWorkItem for run ${data.work.runId}`, err);
+          logError(`Unhandled error in runWorkItem for run ${work.runId}`, err);
+        } finally {
+          activeRunAgentId = null;
+          activeRunTask = void 0;
         }
         continue;
       }
@@ -891,7 +2138,7 @@ program.command("status").description("Print current configuration and server co
   console.log();
 });
 program.command("autostart <action>").description("Manage start-at-logon: install | remove | status (Windows Task Scheduler)").action(async (action) => {
-  const { autostartInstall, autostartRemove, autostartStatus } = await import('./autostart-77BPPTEG.js');
+  const { autostartInstall, autostartRemove, autostartStatus } = await import('./autostart-ASW5MDQS.js');
   if (action === "install") autostartInstall();
   else if (action === "remove") autostartRemove();
   else if (action === "status") autostartStatus();