aegiscode 6.1.0 → 6.2.0

package/src/permissions.js

@@ -0,0 +1,102 @@
+'use strict';
+
+/**
+ * Real enforcement for the /permissions rules (src/config.js) in the
+ * direct-provider tool loop. The `claude` CLI path already has its own real
+ * approval UX from the real binary, so this only applies to
+ * Bash/Read/Write/Edit/Glob/Grep run by a provider model.
+ *
+ * Scope decision (Phase 12): the multi-directory-change Bash heuristic,
+ * explicit /permissions allow|deny|ask rules, and `defaultMode: 'ask'` when
+ * the permissions file *explicitly* writes it (rules.explicitAsk) are
+ * enforced here. The file-free default ('ask' in DEFAULT_PERMISSIONS) is
+ * NOT consulted — honoring the implicit default would prompt on every tool
+ * call out of the box and make the agentic loop unusable by default.
+ * /confirm and /yolo still toggle defaultMode for the explicit case.
+ *
+ * Not tools.js's Glob-tool globToRegex: that one is filesystem-glob (`*`
+ * stops at `/`, matching one path segment) because it walks a directory
+ * tree. Rule subjects here are just as often a Bash command string, where
+ * `/` is ordinary text ("rm -rf /tmp/x") — a `Bash(npm run *)` rule (see
+ * DEFAULT_PERMISSIONS's own example) needs `*` to match the rest of the
+ * line, slashes included. So `*` and `?` here are plain "match anything"
+ * wildcards, not path-segment-bounded ones; reimplemented rather than
+ * imported so this module has no import-cycle with tools.js (executeTool's
+ * home, which calls into this one).
+ *
+ * Ported from aegiscodex-dev/src/permissions.js (ESM → CommonJS).
+ */
+
+const RULE_RE = /^(\w+)(?:\((.*)\))?$/;
+
+function globToRegex(pattern) {
+  let re = '^';
+  for (const c of pattern) {
+    if (c === '*') re += '.*';
+    else if (c === '?') re += '.';
+    else if (/[.+^${}()|[\]\\]/.test(c)) re += `\\${c}`;
+    else re += c;
+  }
+  return new RegExp(re + '$');
+}
+
+/** The subject a rule's pattern matches against, per tool. */
+function subjectFor(toolName, args = {}) {
+  if (toolName === 'Bash') return String(args.command || '');
+  if (toolName === 'Read' || toolName === 'Write' || toolName === 'Edit') return String(args.file_path || '');
+  if (toolName === 'Glob' || toolName === 'Grep') return String(args.pattern || '');
+  return '';
+}
+
+function matchRule(rule, toolName, subject) {
+  const m = RULE_RE.exec(String(rule || '').trim());
+  if (!m) return false;
+  const [, tool, pattern] = m;
+  if (tool !== toolName) return false;
+  if (pattern === undefined) return true; // bare "Bash" matches every call
+  try { return globToRegex(pattern).test(subject); } catch { return false; }
+}
+
+const matchesAny = (list, toolName, subject) =>
+  Array.isArray(list) && list.some((r) => matchRule(r, toolName, subject));
+
+/**
+ * A Bash command that changes directory more than once needs a second look:
+ * each `&&`/`;`/`|`/newline-separated segment starting with `cd` counts.
+ * Mirrors the captured Claude Code 2.1.228 heuristic ("Multiple directory
+ * changes in one command require approval for clarity") — a hardcoded UX
+ * safety rail, not a configurable rule.
+ */
+function isMultiDirCommand(command) {
+  const segments = String(command || '').split(/&&|\|\||;|\n/).map((s) => s.trim());
+  const cdCount = segments.filter((s) => /^cd(\s|$)/.test(s)).length;
+  return cdCount > 1;
+}
+
+/**
+ * Evaluate a tool call against the persisted /permissions rules.
+ * Returns 'allow' | 'deny' | 'ask'. Precedence: an explicit deny rule always
+ * wins (a security floor). An explicit allow rule is the real "always
+ * allow" escape hatch, so it's checked next and suppresses the multi-cd
+ * heuristic below it — same as upstream, where an always-allow rule for
+ * Bash stops it asking again. With no allow rule, the multi-cd heuristic
+ * forces 'ask' on its own; then explicit ask rules. Anything left
+ * unmatched falls through to rules.explicitAsk (an explicitly written
+ * `defaultMode: 'ask'` prompts on the residual); otherwise 'allow' — see
+ * the scope note above, the implicit defaultMode is intentionally not
+ * consulted.
+ */
+function evalPermission(toolName, args, rules = {}) {
+  const subject = subjectFor(toolName, args);
+  if (matchesAny(rules.deny, toolName, subject)) return 'deny';
+  if (matchesAny(rules.allow, toolName, subject)) return 'allow';
+  if (toolName === 'Bash' && isMultiDirCommand(args && args.command)) return 'ask';
+  if (matchesAny(rules.ask, toolName, subject)) return 'ask';
+  if (rules.explicitAsk && rules.defaultMode === 'ask') return 'ask';
+  return 'allow';
+}
+
+module.exports = {
+  isMultiDirCommand,
+  evalPermission,
+};

package/src/render.js

@@ -245,7 +245,11 @@ function renderTurn(ctx, turn, width = 80) {
     if (turn.streaming) body[body.length - 1] += `${t.white}${GLYPH.block}${RESET}`;
     lines.push(...body);
   } else if (role === 'tool') {
-    lines.push(`${t.white}${GLYPH.block}${RESET} ${t.gray}${turn.label || 'tool'}${RESET}`);
+    // turn.ok is only known once the call has actually run (the agent loop's
+    // tool-activity event fires after execution); undefined means "no result
+    // yet to report" (the plain registry-tool path, which never set it).
+    const status = turn.ok === undefined ? '' : turn.ok ? ` ${t.green}✓${RESET}` : ` ${t.red}${ERR}${RESET}`;
+    lines.push(`${t.white}${GLYPH.block}${RESET} ${t.gray}${turn.label || 'tool'}${RESET}${status}`);
     const args =
       turn.args == null
         ? ''
@@ -357,6 +361,33 @@ function renderToolResult(ctx, name, text, width = 80) {
   return lines;
 }
 
+/**
+ * The tool-approval card: the mutating call the model wants to run (a diff
+ * for writeFile/editFile, the command for exec) and the three answers. One
+ * inline question, matching aegiscodex-dev's Bash/edit approval dialog.
+ */
+function renderApproval(ctx, info = {}, width = 80) {
+  const t = themeOf(ctx);
+  const lines = [renderHeading(ctx, `confirm ${info.tool || 'tool'}`, width)];
+  const body = info.diff
+    ? info.diff
+    : info.args == null
+      ? ''
+      : typeof info.args === 'string'
+        ? info.args
+        : JSON.stringify(info.args);
+  for (const l of wrapBlock(body, Math.max(8, width - 2))) {
+    lines.push(l ? `  ${t.gray}${l}${RESET}` : '');
+  }
+  lines.push('');
+  lines.push(
+    `  ${t.coral}${GLYPH.bullet}${RESET} ${t.white}y${RESET}es once` +
+      `  ${t.dim}${GLYPH.bullet}${RESET} ${t.white}s${RESET}ession` +
+      `  ${t.dim}${GLYPH.bullet}${RESET} ${t.white}n${RESET}o ${t.dim}(default)${RESET}`
+  );
+  return lines;
+}
+
 /** A transient notice. Kinds map gray / coral / red / green with the matching
  *  glyph: info `·`, warn `⚠`, error `✗`, ok `✔`. */
 const NOTICE = {
@@ -381,6 +412,7 @@ module.exports = {
   renderWorking,
   renderHeading,
   renderToolResult,
+  renderApproval,
   renderNotice,
   mdLines,
   inline,

package/src/summarize.js

@@ -0,0 +1,90 @@
+'use strict';
+
+/**
+ * Transcript summarization for /compact and /recap.
+ *
+ * Dependency-free port of aegiscodex-dev/src/summarize.js. The reference
+ * spawns `claude -p "Summarize…"` (via platform.resolveExecutable); here the
+ * backend is *injected* instead, so this module pulls in nothing but tokens.js:
+ *
+ *   async summarizeTranscript(transcript, { callModel, model, signal } = {})
+ *   async recapLine(transcript, { callModel, model, signal } = {})
+ *
+ * `callModel(prompt) -> string` (async) is the caller's own model seam. When
+ * `callModel` is not a function the module falls back to a purely local
+ * extraction — the first user text, the last assistant text and the turn count
+ * — and never throws. On abort (signal.aborted) it resolves null so handlers
+ * can report "cancelled"; on any other backend failure it resolves the local
+ * extraction.
+ */
+
+const { estimateTokens } = require('./tokens.js');
+
+// Guard: don't push more than this many chars into a prompt.
+const MAX_INPUT_CHARS = 120_000;
+const MAX_REPLY_CHARS = 2_000;
+
+function extractiveSummary(transcript) {
+  const users = transcript.filter((m) => m.role === 'user').map((m) => m.text || '');
+  const lastAsst = [...transcript].reverse().find((m) => m.role === 'assistant');
+  const topics = users.slice(0, 3).map((t) => `“${t.length > 48 ? t.slice(0, 45) + '…' : t}”`);
+  const parts = [];
+  if (users.length) parts.push(`Covered ${users.length} prompt${users.length > 1 ? 's' : ''}: ${topics.join('; ')}.`);
+  if (lastAsst) {
+    const tail = (lastAsst.text || '').split(/\s+/).slice(0, 30).join(' ');
+    parts.push(`Last reply began: ${tail.length > 100 ? tail.slice(0, 97) + '…' : tail}`);
+  }
+  if (!parts.length) return 'Session with no exchanges yet.';
+  return parts.join(' ');
+}
+
+function demoSummary(transcript) {
+  return `[demo summary] ${extractiveSummary(transcript)}`;
+}
+
+/** Summarize the whole transcript in a few sentences. Resolves null on abort. */
+async function summarizeTranscript(transcript, { callModel, model, signal } = {}) {
+  if (!transcript || !transcript.length) return 'Session with no exchanges yet.';
+  if (typeof callModel !== 'function') return demoSummary(transcript);
+  return callBackend('summarize', transcript, model, signal, callModel, () => demoSummary(transcript));
+}
+
+/** A single-line recap. Resolves null on abort. */
+async function recapLine(transcript, { callModel, model, signal } = {}) {
+  if (!transcript || !transcript.length) return 'No exchanges yet.';
+  if (typeof callModel !== 'function') return `[demo recap] ${extractiveSummary(transcript)}`;
+  return callBackend('recap', transcript, model, signal, callModel, () => `[demo recap] ${extractiveSummary(transcript)}`);
+}
+
+async function callBackend(kind, transcript, model, signal, callModel, fallback) {
+  const text = transcriptToText(transcript).slice(0, MAX_INPUT_CHARS);
+  // NB: the ternary binds exactly as in the reference — the recap branch does
+  // not append the transcript text. Ported verbatim.
+  const prompt = kind === 'recap'
+    ? 'Recap the following conversation in one sentence. Be factual and specific.'
+    : 'Summarize the following conversation. Preserve every requirement, decision, and open question, in 2-4 sentences.'
+    + '\n\n' + text;
+
+  try {
+    if (signal && signal.aborted) return null;
+    const out = await callModel(prompt, { model, signal });
+    if (signal && signal.aborted) return null;
+    if (typeof out === 'string' && out.trim()) return out.trim().slice(0, MAX_REPLY_CHARS);
+    return fallback();
+  } catch {
+    return fallback();
+  }
+}
+
+function transcriptToText(transcript) {
+  return transcript
+    .filter((m) => m.role === 'user' || m.role === 'assistant' || m.role === 'note')
+    .map((m) => `${m.role}: ${m.text || ''}`)
+    .join('\n\n');
+}
+
+module.exports = {
+  summarizeTranscript,
+  recapLine,
+  estimateTokens,
+};

package/src/system.js

@@ -0,0 +1,37 @@
+'use strict';
+
+/**
+ * Small system helpers: best-effort URL opening (never blocks or errors) and
+ * a few constants shared by the support/easter-egg commands.
+ *
+ * Ported from aegiscodex-dev/src/system.js (ESM → CommonJS). The URLS table
+ * pointed at Anthropic/Claude support endpoints; those are re-homed to the
+ * AEGIS base (https://aegiscloud.org) and the project repo. Deep paths that
+ * had no AEGIS equivalent collapse to the base rather than inventing a route.
+ */
+
+const { spawn } = require('node:child_process');
+
+/** Best-effort open of a URL in the system browser. Returns true if launched. */
+function openUrl(url) {
+  try {
+    const platform = process.platform;
+    const cmd = platform === 'darwin' ? ['open'] : platform === 'win32' ? ['cmd', '/c', 'start', ''] : ['xdg-open'];
+    const child = spawn(cmd[0], [...cmd.slice(1), url], { stdio: 'ignore', detached: true });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// AEGIS support URLs (used by /troubleshooting, /feedback…).
+const URLS = {
+  troubleshooting: 'https://aegiscloud.org',
+  feedback: 'https://aegiscloud.org',
+  issues: 'https://github.com/aegisinfo/aegiscode-plugin/issues/new',
+  docs: 'https://aegiscloud.org',
+  radio: 'https://www.youtube.com/watch?v=cP8jB6YQWbQ',
+};
+
+module.exports = { openUrl, URLS };

package/src/tokens.js

@@ -0,0 +1,166 @@
+'use strict';
+
+/**
+ * Token + cost estimation. Tokens are estimated from text length (~4
+ * chars/token, the usual rule of thumb) and priced against the per-model rates
+ * below. Everything is labeled approximate in the UI.
+ *
+ * Ported from aegiscodex-dev/src/tokens.js (ESM → CommonJS).
+ */
+
+// Per-million-token USD rates. Cache-read/write matter for long sessions.
+const RATES = {
+  sonnet:  { input: 3.00, output: 15.00, cacheRead: 0.30, cacheWrite: 3.75 },
+  default: { input: 3.00, output: 15.00, cacheRead: 0.30, cacheWrite: 3.75 },
+  fable:   { input: 5.00, output: 25.00, cacheRead: 0.50, cacheWrite: 6.25 },
+  opus:    { input: 5.00, output: 25.00, cacheRead: 0.50, cacheWrite: 6.25 },
+};
+
+// System prompt + tool definitions overhead, roughly, in tokens.
+const SYSTEM_TOKENS = 18000;
+const TOOL_TOKENS = 12000;
+// Default context window we budget against (Sonnet 5 class).
+const CONTEXT_WINDOW = 200000;
+
+// Real per-provider context budgets for the /context meter. The default above
+// is the Claude-class window the UI was built around; providers with a
+// different window map here so the meter shows the truth instead of a
+// Sonnet-flavored estimate.
+//
+// DeepSeek V4 — verified live 2026-09-11 against api.deepseek.com:
+//   - a 942,031-token prompt was ACCEPTED (HTTP 200)
+//   - a 1,122,032-token prompt was REJECTED, verbatim: "This model's maximum
+//     context length is 1048576 tokens."
+// so the window is 1M. The old 256k figure here understated it 4x and made the
+// /context meter lie. Max output is 393216 — the API rejects anything larger
+// with "the valid range of max_tokens is [1, 393216]".
+// Keyed by provider name or model-id prefix (longest prefix wins via the
+// iteration order below — exact id matches take priority).
+const CONTEXT_WINDOWS = {
+  deepseek: 1_048_576,
+  openrouter: 256_000,
+  together: 256_000,
+  xai: 256_000,
+  groq: 128_000,
+  ollama: 128_000,
+  openai: 200_000,
+  anthropic: 200_000,
+  google: 1_000_000,
+  gemini: 1_000_000,
+};
+
+/** The context budget to show/guard against for a model id, provider, or raw model string. */
+function contextWindowFor(model) {
+  const id = String(model || '').toLowerCase();
+  if (!id) return CONTEXT_WINDOW;
+  if (CONTEXT_WINDOWS[id]) return CONTEXT_WINDOWS[id];
+  for (const [prefix, win] of Object.entries(CONTEXT_WINDOWS)) {
+    if (id.startsWith(prefix)) return win;
+  }
+  return CONTEXT_WINDOW;
+}
+
+/** Rough token estimate: ~4 chars per token (heuristic, labeled approximate). */
+function estimateTokens(text) {
+  if (!text) return 0;
+  return Math.max(1, Math.ceil([...String(text)].length / 4));
+}
+
+/**
+ * Bucket the transcript's token usage.
+ *   input   — user prompts + system + tools (per exchange)
+ *   output  — assistant replies
+ *   cacheRead  — what a resumed session reads back (prior context, approximated
+ *                as all prior user+assistant text)
+ *   cacheWrite — the newest user+assistant chunk written to cache
+ */
+function transcriptUsage(transcript, model = 'sonnet') {
+  const userMsgs = transcript.filter((m) => m.role === 'user');
+  const asstMsgs = transcript.filter((m) => m.role === 'assistant');
+  const input = userMsgs.reduce((a, m) => a + estimateTokens(m.text || ''), 0);
+  const output = asstMsgs.reduce((a, m) => a + estimateTokens(m.text || ''), 0);
+  const cacheRead = Math.max(0, input - (userMsgs.length ? estimateTokens(userMsgs[userMsgs.length - 1].text || '') : 0));
+  const cacheWrite = userMsgs.length ? estimateTokens(userMsgs[userMsgs.length - 1].text || '') : 0;
+  return { input, output, cacheRead, cacheWrite };
+}
+
+/** Dollar cost of a usage record at the given model's rates. */
+function usageCost(usage, model = 'sonnet') {
+  const r = RATES[model] || RATES.sonnet;
+  const toD = (n, rate) => (n / 1_000_000) * rate;
+  return toD(usage.input, r.input)
+    + toD(usage.output, r.output)
+    + toD(usage.cacheRead, r.cacheRead)
+    + toD(usage.cacheWrite, r.cacheWrite);
+}
+
+/** Full session accounting: per-bucket tokens, cost, and context used %. */
+function sessionAccounting(transcript, model = 'sonnet') {
+  const usage = transcriptUsage(transcript, model);
+  const system = SYSTEM_TOKENS;
+  const tools = TOOL_TOKENS;
+  const history = usage.input + usage.output;
+  const used = system + tools + history;
+  const contextWindow = contextWindowFor(model);
+  return {
+    usage,
+    system,
+    tools,
+    history,
+    used,
+    contextWindow,
+    pct: Math.min(100, Math.round((used / contextWindow) * 100)),
+    cost: usageCost(usage, model),
+  };
+}
+
+/**
+ * Phase 4: build the same accounting shape from summed history.jsonl token
+ * records (live usage numbers when `real`, estimated otherwise). Real usage
+ * already includes system prompt + tools in cacheRead, so `used` counts
+ * input + output + cache instead of re-adding the constants.
+ */
+function accountingFromUsage(usage, model = 'sonnet', { exchanges = 0, real = false, costUsd } = {}) {
+  const cost = typeof costUsd === 'number' ? costUsd : usageCost(usage, model);
+  const used = real
+    ? usage.input + usage.output + usage.cacheRead + usage.cacheWrite
+    : SYSTEM_TOKENS + TOOL_TOKENS + usage.input + usage.output;
+  const contextWindow = contextWindowFor(model);
+  return {
+    usage,
+    system: SYSTEM_TOKENS,
+    tools: TOOL_TOKENS,
+    history: usage.input + usage.output,
+    used,
+    contextWindow,
+    pct: Math.min(100, Math.round((used / contextWindow) * 100)),
+    cost,
+    exchanges,
+    real,
+  };
+}
+
+function fmtTokens(n) {
+  if (n >= 1000) return `${(n / 1000).toFixed(1)}k`;
+  return String(n);
+}
+
+function fmtCost(d) {
+  return `$${d.toFixed(4)}`;
+}
+
+module.exports = {
+  RATES,
+  SYSTEM_TOKENS,
+  TOOL_TOKENS,
+  CONTEXT_WINDOW,
+  CONTEXT_WINDOWS,
+  contextWindowFor,
+  estimateTokens,
+  transcriptUsage,
+  usageCost,
+  sessionAccounting,
+  accountingFromUsage,
+  fmtTokens,
+  fmtCost,
+};

package/vendor/desktop/lib/local/agents.js

@@ -0,0 +1,102 @@
+'use strict';
+
+/**
+ * agents.js — subagent prompt presets for the desktop `task` tool, ported
+ * from aegiscodex-dev's src/agents.js (same roles, same synthesis presets).
+ * A preset is a system prompt: `task` runs it through the normal engine.chat
+ * loop as a nested turn (its own tool rounds, same model class), not a
+ * separate runtime, so the presets are pure prompt composition.
+ *
+ * Text is adapted to the desktop's own tool vocabulary (readFile/writeFile/
+ * editFile/listDir/glob/grep/exec/task — see tools.js) so a subagent's
+ * instructions never name a tool the desktop doesn't actually advertise.
+ */
+
+/** Role → system prompt. */
+const AGENT_PRESETS = {
+  synthesizer: `You are a senior technical lead. Given analysis from multiple specialist agents, synthesize their findings into a clear, actionable summary.
+Structure your response as: key findings, recommended approach, top action items.
+Be direct, concrete, and avoid repeating everything the agents said.
+Focus on delivering a decision-ready synthesis.`,
+
+  architect: `You are a System Architect. Design the new application architecture.
+Define: project structure, tech stack, directory layout, key modules, data flow, API design.
+Consider: scalability, maintainability, testing strategy, deployment.
+Output a concrete file tree and architecture decisions log. Be specific.`,
+
+  scaffolder: `You are a Project Scaffolder. Build the complete application from scratch.
+
+YOUR JOB IS TO CREATE ALL PROJECT FILES - not just describe them.
+
+Use writeFile to create: package.json, tsconfig.json, source files, configs, tests.
+Generate COMPLETE, WORKING code - not stubs or placeholders.
+Set up build scripts, lint config, and any necessary tooling.
+
+After creating files, use exec to run: npm/pnpm install, then build/compile.
+Fix any errors until the project builds successfully.
+
+Be thorough - a real, runnable project is the goal.`,
+
+  planner: `You are a Refactoring Planner. Given the analyzer findings, create a step-by-step plan.
+Each step: file path, what to change, why, risk level (LOW/MEDIUM/HIGH).
+Include before/after snippets. Order by impact. Be concrete.`,
+
+  implementer: `You are an Implementation Engineer. Execute the refactoring plan.
+Use editFile and writeFile to make actual code changes.
+After each change, use readFile to verify correctness. Keep existing code style.
+Run build commands with exec to ensure nothing is broken.`,
+
+  reviewer: `You are a Code Reviewer. Review the approach and code.
+Check: logic errors, type safety, error handling, performance, security.
+Be critical but constructive. Report specific issues with file paths.`,
+
+  debugger: `You are a Debugging Specialist. Analyze potential issues and edge cases.
+Identify: failure modes, error handling gaps, testing considerations.
+Think about what could go wrong and how to prevent it.`,
+
+  scanner: `You are a Security Vulnerability Scanner.
+Scan for: hardcoded API keys/secrets, SQL injection, XSS, unsafe eval/exec, path traversal.
+Use grep with targeted patterns. Report every finding with: file path, severity (CRITICAL/HIGH/MEDIUM/LOW), line number.`,
+
+  analyzer: `You are a Code Analyzer. Find refactoring opportunities.
+Look for: duplicated code, long functions (>20 lines), complex conditionals, unused imports,
+circular dependencies, inconsistent patterns. Report with file paths and line numbers.`,
+};
+
+/** System prompt for a `general` (or unrecognized) subagent type. */
+const GENERAL_AGENT_PROMPT =
+  'You are a capable autonomous coding subagent. Complete the assigned task end to end using ' +
+  'the available tools (exec, readFile, writeFile, editFile, listDir, glob, grep). Work in the ' +
+  'current repository, verify your work, and finish with a concise report of what you did and ' +
+  'what you found. You cannot ask follow-up questions — make reasonable assumptions and proceed. ' +
+  'When a large sub-task is better handled by a focused specialist, delegate it with the task tool.';
+
+/** Human-readable role label for a preset id (falls back to the id). */
+function agentRoleLabel(role) {
+  const labels = {
+    synthesizer: 'Technical Lead', architect: 'System Architect',
+    scaffolder: 'Project Scaffolder', planner: 'Refactoring Planner',
+    implementer: 'Implementation Engineer', reviewer: 'Code Reviewer',
+    debugger: 'Debugging Specialist', scanner: 'Vulnerability Scanner',
+    analyzer: 'Code Analyzer', general: 'General',
+  };
+  return labels[role] || role;
+}
+
+/** Every preset id, in palette order (excludes the 'general' fallback). */
+function agentRoles() {
+  return Object.keys(AGENT_PRESETS);
+}
+
+/** Resolve a subagent_type to its system prompt (unknown/absent → general). */
+function agentSystemPrompt(role) {
+  return AGENT_PRESETS[role] || GENERAL_AGENT_PROMPT;
+}
+
+module.exports = {
+  AGENT_PRESETS,
+  GENERAL_AGENT_PROMPT,
+  agentRoleLabel,
+  agentRoles,
+  agentSystemPrompt,
+};