crewswarm 0.8.1-beta

package/lib/agent-registry.mjs

@@ -0,0 +1,232 @@
+// Shared crewswarm agent registry.
+// Dynamically loads agents from ~/.crewswarm/crewswarm.json so new agents
+// are automatically discovered without code changes.
+
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+// Minimal built-in fallback for core coordinator agents
+// Plus agents used in tests (so tests pass on CI without config file)
+const CORE_AGENTS = [
+  "crew-main",
+  "crew-pm",
+  "crew-pm-cli",
+  "crew-pm-frontend",
+  "crew-pm-core",
+  "crew-orchestrator",
+  "crew-lead",
+  "crew-judge",
+  // Test agents (needed for CI)
+  "crew-coder",
+  "crew-coder-back",
+  "crew-coder-front",
+  "crew-researcher",
+  "crew-qa",
+  "crew-copywriter",
+  "crew-fixer",
+  "crew-github",
+  "crew-frontend",
+  "crew-security",
+];
+
+const CORE_MAP = {
+  "crew-main": "main",
+  "crew-pm": "pm",
+  "crew-pm-cli": "pm-cli",
+  "crew-pm-frontend": "pm-frontend",
+  "crew-pm-core": "pm-core",
+  "crew-orchestrator": "orchestrator",
+  "crew-lead": "lead",
+  "crew-judge": "judge",
+  // Test agents
+  "crew-coder": "coder",
+  "crew-coder-back": "coder-back",
+  "crew-coder-front": "coder-front",
+  "crew-researcher": "researcher",
+  "crew-qa": "qa",
+  "crew-copywriter": "copywriter",
+  "crew-fixer": "fixer",
+  "crew-github": "github",
+  "crew-frontend": "frontend",
+  "crew-security": "security",
+};
+
+/**
+ * Build agent registry dynamically from config files.
+ * Reads ~/.crewswarm/crewswarm.json and discovers all configured agents.
+ */
+function buildAgentRegistry() {
+  const map = { ...CORE_MAP };
+  const listSet = new Set(CORE_AGENTS);
+
+  const cfgPaths = [
+    path.join(os.homedir(), ".crewswarm", "crewswarm.json"),
+    path.join(os.homedir(), ".openclaw", "openclaw.json"),
+  ];
+
+  for (const cfgPath of cfgPaths) {
+    try {
+      const cfg = JSON.parse(fs.readFileSync(cfgPath, "utf8"));
+      const agents = Array.isArray(cfg.agents) ? cfg.agents
+                   : Array.isArray(cfg.agents?.list) ? cfg.agents.list
+                   : [];
+
+      for (const agent of agents) {
+        const rawId = String(agent.id || "").trim();
+        if (!rawId) continue;
+
+        // Normalize to RT format (crew-xxx)
+        const bareId = rawId.replace(/^crew-/, "");
+        const rtId = rawId.startsWith("crew-") ? rawId : `crew-${bareId}`;
+
+        // Always keep canonical RT IDs in the exported list
+        if (!map[rtId]) {
+          map[rtId] = bareId;
+          listSet.add(rtId);
+        }
+        // Support bare alias lookup (e.g. "orchestrator", "security")
+        // without adding duplicate non-RT IDs to BUILT_IN_RT_AGENTS.
+        if (rawId === bareId && !map[bareId]) {
+          map[bareId] = bareId;
+        }
+      }
+    } catch (err) {
+      // Config file not found or invalid JSON — use core agents only
+      if (process.env.DEBUG) {
+        console.warn(`[agent-registry] Could not load ${cfgPath}: ${err.message}`);
+      }
+    }
+  }
+
+  return { list: [...listSet].sort(), map };
+}
+
+// Build registry on module load
+const { list, map } = buildAgentRegistry();
+
+export const BUILT_IN_RT_AGENTS = list;
+export const RT_TO_GATEWAY_AGENT_MAP = map;
+
+// Core agents that MUST exist - system breaks if missing
+export const REQUIRED_AGENTS = new Set([
+  "crew-lead",      // Fatal: no chat handler, no dispatch
+  "crew-main",      // Fatal: no synthesis, no fallback coordinator
+  "crew-pm",        // Fatal: PM-loop breaks, no roadmap processing
+  "crew-orchestrator", // Fatal: pipeline dispatch fails
+  "crew-coder",     // Fatal: PM-loop's default worker
+  "crew-judge"      // Fatal: PM-loop judge decisions fail (if PM_USE_JUDGE=on)
+]);
+
+// Coordinator agents that can dispatch to other agents
+export const COORDINATOR_AGENT_IDS = [
+  "crew-main",
+  "crew-pm",
+  "crew-pm-cli",
+  "crew-pm-frontend",
+  "crew-pm-core",
+  "crew-orchestrator"
+];
+
+// Backward-compatible alias for a misspelled import introduced by recent edits.
+export const coordinate_aget_ids = COORDINATOR_AGENT_IDS;
+
+/**
+ * Agents whose tasks assume the configured engine runs (read_file / write_file / git / CLI).
+ * If Codex/Cursor/OpenCode fails, we must NOT silently fall back to direct LLM — the user would
+ * get prose with no qa-report.md, no audits, etc.
+ */
+export const AGENTS_NO_ENGINE_LLM_FALLBACK = new Set([
+  "crew-coder",
+  "crew-coder-back",
+  "crew-coder-front",
+  "crew-frontend",
+  "crew-fixer",
+  "crew-architect",
+  "crew-qa",
+  "crew-security",
+  "crew-github",
+  "crew-copywriter",
+  "crew-researcher",
+  "crew-seo",
+  "crew-ml",
+  "crew-mega",
+  "crew-pm",
+  "crew-pm-cli",
+  "crew-pm-frontend",
+  "crew-pm-core",
+  "crew-orchestrator",
+]);
+
+/**
+ * True when engine failure should surface an error instead of LLM-only fallback (rt-envelope).
+ * @param {string} agentId
+ * @returns {boolean}
+ */
+export function agentMustNotUseEngineLlmFallback(agentId = "") {
+  const id = normalizeRtAgentId(String(agentId || "").trim());
+  if (!id) return false;
+  if (AGENTS_NO_ENGINE_LLM_FALLBACK.has(id)) return true;
+  // Dynamic coding-style workers
+  if (/^crew-[\w-]*(coder|fixer)(-|$)/i.test(id)) return true;
+  if (/^crew-[\w-]*frontend(-|$)/i.test(id)) return true;
+  return false;
+}
+
+/**
+ * Check if an agent ID is a coordinator (can dispatch to other agents)
+ * Handles both RT format (crew-xxx) and bare aliases (xxx)
+ * @param {string} agentId - Agent ID to check
+ * @returns {boolean} True if agent is a coordinator
+ */
+export function isCoordinator(agentId = "") {
+  const id = String(agentId || "").trim();
+  if (!id) return false;
+  
+  // Check RT format directly
+  if (COORDINATOR_AGENT_IDS.includes(id)) return true;
+  
+  // Check bare alias by normalizing to RT format
+  const rtId = normalizeRtAgentId(id);
+  return COORDINATOR_AGENT_IDS.includes(rtId);
+}
+
+/**
+ * Validate that all required agents exist in config
+ * @param {Array} agents - Agent list from config
+ * @returns {Object} { valid: boolean, missing: string[] }
+ */
+export function validateRequiredAgents(agents = []) {
+  const agentIds = new Set(
+    agents
+      .map((a) => normalizeRtAgentId(a?.id))
+      .filter(Boolean)
+  );
+  const missing = [];
+  
+  for (const required of REQUIRED_AGENTS) {
+    if (!agentIds.has(required)) {
+      missing.push(required);
+    }
+  }
+  
+  return {
+    valid: missing.length === 0,
+    missing
+  };
+}
+
+// Agents that don't get "crew-" prefix normalization
+export const NO_PREFIX_AGENT_IDS = new Set(["security"]);
+
+/**
+ * Normalize agent ID to RT format (crew-xxx).
+ * @param {string} agentId - Raw agent ID
+ * @returns {string} Normalized RT agent ID
+ */
+export function normalizeRtAgentId(agentId = "") {
+  const id = String(agentId || "").trim();
+  if (!id) return "";
+  if (id.startsWith("crew-") || NO_PREFIX_AGENT_IDS.has(id)) return id;
+  return `crew-${id}`;
+}

package/lib/agents/daemon.mjs

@@ -0,0 +1,121 @@
+/**
+ * Agent daemon utilities — spawn, PID, heartbeat, resolve spawn targets.
+ * Extracted from gateway-bridge.mjs.
+ * Dependencies: fs, path, os, spawn from child_process
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import {
+  SWARM_RUNTIME_DIR,
+  SWARM_STATUS_LOG,
+  CREWSWARM_RT_CHANNELS,
+  CREWSWARM_REPO_ROOT,
+} from "../runtime/config.mjs";
+import { CREWSWARM_RT_SWARM_AGENTS } from "./registry.mjs";
+
+function agentRuntimeDir() {
+  const dir = path.join(SWARM_RUNTIME_DIR, "rt-agents");
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+export function agentPidPath(agent) {
+  return path.join(agentRuntimeDir(), `${agent}.pid`);
+}
+
+export function agentLogPath(agent) {
+  return path.join(agentRuntimeDir(), `${agent}.log`);
+}
+
+export function readPid(agent) {
+  try {
+    return Number(fs.readFileSync(agentPidPath(agent), "utf8").trim());
+  } catch {
+    return 0;
+  }
+}
+
+export function isPidAlive(pid) {
+  if (!pid || Number.isNaN(pid)) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function latestHeartbeatAgeSec(agent) {
+  try {
+    if (!fs.existsSync(SWARM_STATUS_LOG)) return null;
+    const lines = fs.readFileSync(SWARM_STATUS_LOG, "utf8").split("\n");
+    for (let i = lines.length - 1; i >= 0; i -= 1) {
+      const line = lines[i].trim();
+      if (!line) continue;
+      let row;
+      try { row = JSON.parse(line); } catch { continue; }
+      if (row?.type !== "agent.heartbeat") continue;
+      const hbAgent = row?.payload?.agent || row?.from;
+      if (hbAgent !== agent) continue;
+      const ts = Date.parse(row?.ts || "");
+      if (!Number.isFinite(ts)) return null;
+      return (Date.now() - ts) / 1000;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+export function isAgentDaemonRunning(agent) {
+  const SWARM_HEARTBEAT_WINDOW_SEC = Number(process.env.CREWSWARM_RT_HEARTBEAT_WINDOW_SEC || "90");
+  const heartbeatAge = latestHeartbeatAgeSec(agent);
+  if (heartbeatAge !== null && heartbeatAge <= SWARM_HEARTBEAT_WINDOW_SEC) return true;
+  const pid = readPid(agent);
+  if (isPidAlive(pid)) return true;
+  return false;
+}
+
+export function spawnAgentDaemon(agent) {
+  if (isAgentDaemonRunning(agent)) {
+    return { agent, status: "already_running" };
+  }
+  const logFile = agentLogPath(agent);
+  const out = fs.openSync(logFile, "a");
+  const child = spawn(
+    process.execPath,
+    [path.join(CREWSWARM_REPO_ROOT, "gateway-bridge.mjs"), "--rt-daemon"],
+    {
+      cwd: CREWSWARM_REPO_ROOT,
+      detached: true,
+      stdio: ["ignore", out, out],
+      env: {
+        ...process.env,
+        CREWSWARM_RT_AGENT: agent,
+        CREWSWARM_RT_CHANNELS,
+      },
+    },
+  );
+  child.unref();
+  fs.writeFileSync(agentPidPath(agent), `${child.pid}`);
+  return { agent, status: "started", pid: child.pid, logFile };
+}
+
+export function resolveSpawnTargets(payload) {
+  const all = [...new Set(CREWSWARM_RT_SWARM_AGENTS)];
+  if (Array.isArray(payload?.agents)) {
+    const agents = payload.agents.map((a) => String(a).trim()).filter(Boolean);
+    return agents.length ? agents : all;
+  }
+  if (typeof payload?.agent === "string" && payload.agent.trim()) {
+    if (payload.agent.trim().toLowerCase() === "all") return all;
+    return [payload.agent.trim()];
+  }
+  if (typeof payload?.target === "string" && payload.target.trim()) {
+    if (payload.target.trim().toLowerCase() === "all") return all;
+    return [payload.target.trim()];
+  }
+  return all;
+}

package/lib/agents/dispatch.mjs

@@ -0,0 +1,225 @@
+/**
+ * Dispatch guard, task lease, and task helpers — extracted from gateway-bridge.mjs.
+ * File-based lease and done records for dispatch deduplication.
+ * Dependencies: fs, path, crypto
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import {
+  SWARM_DISPATCH_DIR,
+  CREWSWARM_RT_AGENT,
+  CREWSWARM_RT_TASK_STATE_TTL_MS,
+  CREWSWARM_RT_DISPATCH_ENABLED,
+} from "../runtime/config.mjs";
+
+function transientError(err) {
+  const msg = String(err?.message ?? err ?? "").toLowerCase();
+  return ["timeout", "timed out", "econnrefused", "ehostunreach", "econnreset", "socket hang up", "websocket is not open", "connection closed", "broken pipe"].some((s) => msg.includes(s));
+}
+
+function ensureDispatchDir() {
+  fs.mkdirSync(SWARM_DISPATCH_DIR, { recursive: true });
+  return SWARM_DISPATCH_DIR;
+}
+
+function safeReadJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function isoNow() {
+  return new Date().toISOString();
+}
+
+export function dispatchKeyForTask({ taskId, incomingType, prompt, idempotencyKey }) {
+  const stableTaskId = String(taskId || "").trim();
+  if (stableTaskId) return `task-${stableTaskId}`;
+  const stableIdempotency = String(idempotencyKey || "").trim();
+  if (stableIdempotency) return `idem-${stableIdempotency}`;
+  const hash = crypto.createHash("sha256")
+    .update(`${incomingType || "event"}\n${prompt || ""}`, "utf8")
+    .digest("hex")
+    .slice(0, 24);
+  return `hash-${hash}`;
+}
+
+export function leasePathForKey(key) {
+  return path.join(ensureDispatchDir(), `${key}.lease`);
+}
+
+export function donePathForKey(key) {
+  return path.join(ensureDispatchDir(), `${key}.done.json`);
+}
+
+export function readTaskDoneRecord(key) {
+  return safeReadJson(donePathForKey(key));
+}
+
+export function isDoneRecordFresh(record) {
+  if (!record?.doneAt) return false;
+  const doneAtMs = Date.parse(record.doneAt);
+  if (!Number.isFinite(doneAtMs)) return false;
+  return (Date.now() - doneAtMs) <= CREWSWARM_RT_TASK_STATE_TTL_MS;
+}
+
+export function readLeaseRecord(leaseDir) {
+  return safeReadJson(path.join(leaseDir, "lease.json"));
+}
+
+export function writeLeaseRecord(leaseDir, leaseRecord) {
+  fs.writeFileSync(path.join(leaseDir, "lease.json"), JSON.stringify(leaseRecord, null, 2));
+}
+
+export function acquireTaskLease({ key, source, incomingType, from, leaseMs }) {
+  const leaseDir = leasePathForKey(key);
+  const donePath = donePathForKey(key);
+  const doneRecord = readTaskDoneRecord(key);
+  if (doneRecord) {
+    if (isDoneRecordFresh(doneRecord)) {
+      return { acquired: false, reason: "already_done", doneRecord };
+    }
+    try {
+      fs.rmSync(donePath, { force: true });
+    } catch {}
+  }
+
+  const now = Date.now();
+  const claimId = `${CREWSWARM_RT_AGENT}-${process.pid}-${crypto.randomUUID()}`;
+  const leaseRecord = {
+    key,
+    claimId,
+    agent: CREWSWARM_RT_AGENT,
+    source,
+    from,
+    incomingType,
+    leaseMs,
+    leasedAt: isoNow(),
+    leaseExpiresAt: new Date(now + leaseMs).toISOString(),
+    updatedAt: isoNow(),
+  };
+
+  const writeNewLease = () => {
+    fs.mkdirSync(leaseDir);
+    writeLeaseRecord(leaseDir, leaseRecord);
+    return { acquired: true, claimId, leaseDir };
+  };
+
+  try {
+    return writeNewLease();
+  } catch (err) {
+    if (err?.code !== "EEXIST") throw err;
+  }
+
+  const existing = readLeaseRecord(leaseDir);
+  const existingExpiry = Date.parse(existing?.leaseExpiresAt || "");
+  if (Number.isFinite(existingExpiry) && existingExpiry > now) {
+    return {
+      acquired: false,
+      reason: "claimed",
+      claimedBy: existing?.agent || "unknown",
+      leaseExpiresAt: existing?.leaseExpiresAt || null,
+    };
+  }
+
+  try {
+    fs.rmSync(leaseDir, { recursive: true, force: true });
+    return writeNewLease();
+  } catch {
+    return {
+      acquired: false,
+      reason: "claimed",
+      claimedBy: existing?.agent || "unknown",
+      leaseExpiresAt: existing?.leaseExpiresAt || null,
+    };
+  }
+}
+
+export function renewTaskLease({ key, claimId, leaseMs }) {
+  const leaseDir = leasePathForKey(key);
+  const current = readLeaseRecord(leaseDir);
+  if (!current || current.claimId !== claimId || current.agent !== CREWSWARM_RT_AGENT) return false;
+  const now = Date.now();
+  current.updatedAt = isoNow();
+  current.leaseMs = leaseMs;
+  current.leaseExpiresAt = new Date(now + leaseMs).toISOString();
+  writeLeaseRecord(leaseDir, current);
+  return true;
+}
+
+export function releaseTaskLease({ key, claimId }) {
+  const leaseDir = leasePathForKey(key);
+  try {
+    const current = readLeaseRecord(leaseDir);
+    if (!current || current.claimId !== claimId || current.agent !== CREWSWARM_RT_AGENT) return false;
+    fs.rmSync(leaseDir, { recursive: true, force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function markTaskDone({ key, claimId, taskId, incomingType, from, attempt, idempotencyKey, reply }) {
+  const donePath = donePathForKey(key);
+  const replyText = String(reply || "");
+  const doneRecord = {
+    key,
+    taskId,
+    incomingType,
+    from,
+    claimId,
+    idempotencyKey,
+    agent: CREWSWARM_RT_AGENT,
+    attempt,
+    reply: replyText.slice(0, 24000),
+    replyHash: crypto.createHash("sha256").update(replyText, "utf8").digest("hex"),
+    doneAt: isoNow(),
+  };
+  fs.writeFileSync(donePath, JSON.stringify(doneRecord, null, 2));
+}
+
+export function shouldUseDispatchGuard(incomingType) {
+  if (!CREWSWARM_RT_DISPATCH_ENABLED) return false;
+  return incomingType === "command.run_task" || incomingType === "task.assigned" || incomingType === "task.reassigned";
+}
+
+export function shouldRetryTaskFailure(err) {
+  const msg = String(err?.message ?? err ?? "");
+  if (!msg) return false;
+  if (msg.includes("MEMORY_PROTOCOL_MISSING") || msg.includes("MEMORY_LOAD_FAILED")) return false;
+  if (msg.includes("CODING_ARTIFACT_MISSING")) return true;
+  return transientError(err) || msg.toLowerCase().includes("timeout");
+}
+
+export function isCodingTask(incomingType, prompt, payload) {
+  if (!incomingType) return false;
+  const codingTypes = ["command.run_task", "task.assigned", "task.reassigned"];
+  if (!codingTypes.includes(incomingType)) return false;
+
+  const action = String(payload?.action || "").toLowerCase();
+  if (action === "collect_status" || action === "status" || action === "heartbeat") return false;
+
+  const text = String(prompt || "").toLowerCase();
+  if (text.includes("report status") || text.includes("reply with agent id")) return false;
+  if (text.includes("busy/idle") || text.includes("active task")) return false;
+
+  const codingKeywords = [
+    "implement", "build", "create", "fix", "refactor", "add", "update", "modify",
+    "code", "function", "class", "component", "api", "endpoint", "route", "test",
+    "bug", "error", "issue", "file", "script", "module", "package"
+  ];
+  return codingKeywords.some(kw => text.includes(kw));
+}
+
+export function looksLikeCodingTask(prompt = "") {
+  const p = String(prompt).toLowerCase();
+  return [
+    "implement", "write code", "refactor", "fix bug", "unit test", "integration test",
+    "build", "compile", "typescript", "javascript", "python", "go ", "rust",
+    "repo", "pull request", "pr ", "commit", "lint", "migrate",
+  ].some((kw) => p.includes(kw));
+}

package/lib/agents/permissions.mjs

@@ -0,0 +1,90 @@
+/**
+ * Agent tool permission helpers — extracted from crew-lead.mjs
+ * Reads/writes per-agent tool permissions from crewswarm.json.
+ */
+
+import fs   from "fs";
+import path from "path";
+import os   from "os";
+import { applySharedChatPromptOverlay } from "../chat/shared-chat-prompt-overlay.mjs";
+
+function tryRead(p) {
+  try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch { return null; }
+}
+
+export const CREWSWARM_TOOL_NAMES = new Set([
+  "write_file","read_file","mkdir","run_cmd","git","dispatch","telegram","web_search","web_fetch","skill","define_skill","browser",
+]);
+
+export const AGENT_TOOL_ROLE_DEFAULTS = {
+  "crew-qa":          ["read_file"],
+  "crew-security":    ["read_file","run_cmd"],
+  "crew-coder":       ["write_file","read_file","mkdir","run_cmd","browser"],
+  "crew-coder-front": ["write_file","read_file","mkdir","run_cmd","browser"],
+  "crew-coder-back":  ["write_file","read_file","mkdir","run_cmd","browser"],
+  "crew-frontend":    ["write_file","read_file","mkdir","run_cmd"],
+  "crew-fixer":       ["write_file","read_file","mkdir","run_cmd","browser"],
+  "crew-github":      ["read_file","run_cmd","git"],
+  "crew-copywriter":  ["write_file","read_file","web_search","web_fetch"],
+  "crew-main":        ["write_file","read_file","mkdir","run_cmd","dispatch","web_search","web_fetch"],
+  "crew-pm":          ["read_file","dispatch"],
+  "crew-telegram":    ["telegram","read_file"],
+};
+
+export function readAgentTools(agentId) {
+  const swarm = tryRead(path.join(os.homedir(), ".crewswarm", "crewswarm.json")) || {};
+  const agents = Array.isArray(swarm.agents) ? swarm.agents : [];
+  const agent  = agents.find(a => a.id === agentId);
+  const exact = AGENT_TOOL_ROLE_DEFAULTS[agentId];
+  const roleDefaults = exact || Object.entries(AGENT_TOOL_ROLE_DEFAULTS).find(([key]) => agentId.startsWith(key))?.[1] || [];
+  const explicit = agent?.tools?.crewswarmAllow || agent?.tools?.alsoAllow || null;
+  if (explicit) {
+    const valid = explicit.filter(t => CREWSWARM_TOOL_NAMES.has(t));
+    if (valid.length) return { source: "config", tools: [...new Set([...roleDefaults, ...valid])] };
+  }
+  if (roleDefaults.length) return { source: "role-default", tools: roleDefaults };
+  return { source: "fallback", tools: ["read_file","write_file","mkdir","run_cmd"] };
+}
+
+export function writeAgentTools(agentId, tools) {
+  const valid = tools.filter(t => CREWSWARM_TOOL_NAMES.has(t));
+  const swarmPath = path.join(os.homedir(), ".crewswarm", "crewswarm.json");
+  const swarm = tryRead(swarmPath) || {};
+  if (!Array.isArray(swarm.agents)) swarm.agents = [];
+  let agent = swarm.agents.find(a => a.id === agentId);
+  if (!agent) {
+    agent = { id: agentId };
+    swarm.agents.push(agent);
+  }
+  if (!agent.tools) agent.tools = {};
+  agent.tools.crewswarmAllow = valid;
+  fs.writeFileSync(swarmPath, JSON.stringify(swarm, null, 2), "utf8");
+  return valid;
+}
+
+export function getSearchToolsConfig() {
+  return tryRead(path.join(os.homedir(), ".crewswarm", "search-tools.json")) || {};
+}
+
+export function getRawAgentPrompts() {
+  return (
+    tryRead(path.join(os.homedir(), ".crewswarm", "agent-prompts.json")) || {}
+  );
+}
+
+export function getAgentPrompts() {
+  const prompts = getRawAgentPrompts();
+  const augmented = {};
+  for (const [key, value] of Object.entries(prompts)) {
+    augmented[key] = applySharedChatPromptOverlay(value, key);
+  }
+  return augmented;
+}
+
+export function writeAgentPrompt(agentId, promptText) {
+  const promptsPath = path.join(os.homedir(), ".crewswarm", "agent-prompts.json");
+  const prompts = getRawAgentPrompts();
+  prompts[agentId] = promptText;
+  fs.writeFileSync(promptsPath, JSON.stringify(prompts, null, 2), "utf8");
+  return promptText;
+}