@agntk/agent-harness 0.1.1

package/dist/chunk-GUJTBGVS.js

@@ -0,0 +1,2212 @@
+import {
+  CONFIG_DEFAULTS,
+  CORE_PRIMITIVE_DIRS,
+  FrontmatterSchema,
+  HarnessConfigSchema
+} from "./chunk-KFX54TQM.js";
+import {
+  generate,
+  getModel,
+  streamGenerateWithDetails
+} from "./chunk-FD55B3IO.js";
+
+// src/core/harness.ts
+import { existsSync as existsSync11 } from "fs";
+import { resolve } from "path";
+
+// src/core/config.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import YAML from "yaml";
+var CONFIG_FILENAMES = ["config.yaml", "config.yml", "harness.yaml", "harness.yml"];
+function loadConfig(dir, overrides) {
+  let raw = {};
+  for (const filename of CONFIG_FILENAMES) {
+    const configPath = join(dir, filename);
+    if (existsSync(configPath)) {
+      const content = readFileSync(configPath, "utf-8");
+      raw = YAML.parse(content) || {};
+      break;
+    }
+  }
+  let merged = deepMerge(
+    CONFIG_DEFAULTS,
+    raw
+  );
+  if (overrides) {
+    merged = deepMerge(
+      merged,
+      overrides
+    );
+  }
+  const result = HarnessConfigSchema.safeParse(merged);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new Error(`Invalid config:
+${issues}`);
+  }
+  return result.data;
+}
+function writeDefaultConfig(_dir, agentName = "my-agent") {
+  return `# Agent Harness Configuration
+agent:
+  name: ${agentName}
+  version: "0.1.0"
+
+model:
+  provider: openrouter
+  id: anthropic/claude-sonnet-4
+  max_tokens: 200000
+  max_retries: 2
+  # timeout_ms: 60000
+
+runtime:
+  scratchpad_budget: 10000
+  timezone: America/New_York
+  # heartbeat: "0 6-23 * * *"      # reserved, not yet implemented
+  # daily_summary: "0 22 * * *"     # reserved, not yet implemented
+
+memory:
+  session_retention_days: 7
+  journal_retention_days: 365
+
+channels:
+  primary: cli
+
+extensions:
+  directories: []
+
+# rate_limits:
+#   per_minute: 10
+#   per_hour: 100
+#   per_day: 500
+
+# budget:
+#   daily_limit_usd: 5.00
+#   monthly_limit_usd: 100.00
+#   enforce: true
+`;
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key]) && target[key] && typeof target[key] === "object" && !Array.isArray(target[key])) {
+      result[key] = deepMerge(
+        target[key],
+        source[key]
+      );
+    } else {
+      result[key] = source[key];
+    }
+  }
+  return result;
+}
+
+// src/core/logger.ts
+var LEVEL_ORDER = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  silent: 4
+};
+var globalLevel = "info";
+function shouldLog(level) {
+  return LEVEL_ORDER[level] >= LEVEL_ORDER[globalLevel];
+}
+function formatMessage(prefix, level, msg) {
+  const tag = prefix ? `[${prefix}]` : "";
+  if (level === "debug") return `${tag} ${msg}`.trimStart();
+  if (level === "warn") return `${tag} WARN: ${msg}`.trimStart();
+  if (level === "error") return `${tag} ERROR: ${msg}`.trimStart();
+  return `${tag} ${msg}`.trimStart();
+}
+function createLoggerWithPrefix(prefix) {
+  return {
+    debug(msg, ...args) {
+      if (shouldLog("debug")) console.error(formatMessage(prefix, "debug", msg), ...args);
+    },
+    info(msg, ...args) {
+      if (shouldLog("info")) console.error(formatMessage(prefix, "info", msg), ...args);
+    },
+    warn(msg, ...args) {
+      if (shouldLog("warn")) console.error(formatMessage(prefix, "warn", msg), ...args);
+    },
+    error(msg, ...args) {
+      if (shouldLog("error")) console.error(formatMessage(prefix, "error", msg), ...args);
+    },
+    setLevel(level) {
+      globalLevel = level;
+    },
+    getLevel() {
+      return globalLevel;
+    },
+    child(childPrefix) {
+      const combined = prefix ? `${prefix}:${childPrefix}` : childPrefix;
+      return createLoggerWithPrefix(combined);
+    }
+  };
+}
+function createLogger(prefix = "") {
+  return createLoggerWithPrefix(prefix);
+}
+function setGlobalLogLevel(level) {
+  globalLevel = level;
+}
+function getGlobalLogLevel() {
+  return globalLevel;
+}
+var log = createLogger("harness");
+
+// src/runtime/context-loader.ts
+import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+
+// src/primitives/loader.ts
+import { readFileSync as readFileSync2, readdirSync, existsSync as existsSync2 } from "fs";
+import { join as join2, extname } from "path";
+import matter from "gray-matter";
+var L0_REGEX = /<!--\s*L0:\s*([\s\S]*?)\s*-->/;
+var L1_REGEX = /<!--\s*L1:\s*([\s\S]*?)\s*-->/;
+function parseHarnessDocument(filePath) {
+  const raw = readFileSync2(filePath, "utf-8");
+  const { data, content } = matter(raw);
+  const normalized = { ...data };
+  for (const key of ["created", "updated"]) {
+    if (normalized[key] instanceof Date) {
+      normalized[key] = normalized[key].toISOString().split("T")[0];
+    }
+  }
+  let frontmatter;
+  try {
+    frontmatter = FrontmatterSchema.parse(normalized);
+  } catch {
+    const id = filePath.split("/").pop()?.replace(".md", "") || "unknown";
+    frontmatter = FrontmatterSchema.parse({ id });
+  }
+  const l0Match = content.match(L0_REGEX);
+  const l1Match = content.match(L1_REGEX);
+  const l0 = l0Match ? l0Match[1].trim() : "";
+  const l1 = l1Match ? l1Match[1].trim() : "";
+  const body = content.replace(L0_REGEX, "").replace(L1_REGEX, "").trim();
+  return {
+    path: filePath,
+    frontmatter,
+    l0,
+    l1,
+    body,
+    raw
+  };
+}
+function loadDirectory(dirPath) {
+  return loadDirectoryWithErrors(dirPath).docs;
+}
+function loadDirectoryWithErrors(dirPath) {
+  if (!existsSync2(dirPath)) return { docs: [], errors: [] };
+  const files = readdirSync(dirPath);
+  const docs = [];
+  const errors = [];
+  for (const file of files) {
+    if (extname(file) !== ".md") continue;
+    if (file.startsWith("_")) continue;
+    if (file.startsWith(".")) continue;
+    const filePath = join2(dirPath, file);
+    try {
+      const doc = parseHarnessDocument(filePath);
+      if (doc.frontmatter.status !== "archived" && doc.frontmatter.status !== "deprecated") {
+        docs.push(doc);
+      }
+    } catch (err) {
+      errors.push({
+        path: filePath,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return { docs, errors };
+}
+function loadAllPrimitives(harnessDir, extraDirs) {
+  return loadAllPrimitivesWithErrors(harnessDir, extraDirs).primitives;
+}
+function loadAllPrimitivesWithErrors(harnessDir, extraDirs) {
+  const primitives = /* @__PURE__ */ new Map();
+  const allErrors = [];
+  const directories = [...CORE_PRIMITIVE_DIRS];
+  if (extraDirs) {
+    for (const dir of extraDirs) {
+      if (!directories.includes(dir)) {
+        directories.push(dir);
+      }
+    }
+  }
+  for (const dir of directories) {
+    const { docs, errors } = loadDirectoryWithErrors(join2(harnessDir, dir));
+    primitives.set(dir, docs);
+    allErrors.push(...errors);
+  }
+  return { primitives, errors: allErrors };
+}
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function getAtLevel(doc, level) {
+  switch (level) {
+    case 0:
+      return doc.l0 || doc.frontmatter.id;
+    case 1:
+      return doc.l1 || doc.l0 || doc.body.slice(0, 400);
+    case 2:
+      return doc.body;
+  }
+}
+
+// src/runtime/context-loader.ts
+function buildSystemPrompt(harnessDir, config) {
+  const maxTokens = config.model.max_tokens;
+  const budget = {
+    max_tokens: maxTokens,
+    used_tokens: 0,
+    remaining: maxTokens,
+    loaded_files: []
+  };
+  const warnings = [];
+  const sections = [];
+  const corePath = join3(harnessDir, "CORE.md");
+  if (existsSync3(corePath)) {
+    const core = readFileSync3(corePath, "utf-8");
+    sections.push(`# CORE IDENTITY
+
+${core}`);
+    budget.used_tokens += estimateTokens(core);
+    budget.loaded_files.push("CORE.md");
+  }
+  const statePath = join3(harnessDir, "state.md");
+  if (existsSync3(statePath)) {
+    const state = readFileSync3(statePath, "utf-8");
+    sections.push(`# CURRENT STATE
+
+${state}`);
+    budget.used_tokens += estimateTokens(state);
+    budget.loaded_files.push("state.md");
+  }
+  const systemPath = join3(harnessDir, "SYSTEM.md");
+  if (existsSync3(systemPath)) {
+    const system = readFileSync3(systemPath, "utf-8");
+    sections.push(`# SYSTEM
+
+${system}`);
+    budget.used_tokens += estimateTokens(system);
+    budget.loaded_files.push("SYSTEM.md");
+  }
+  const extDirs = config.extensions?.directories ?? [];
+  const { primitives, errors: parseErrors } = loadAllPrimitivesWithErrors(harnessDir, extDirs);
+  if (parseErrors.length > 0) {
+    for (const pe of parseErrors) {
+      log.warn(`Failed to parse primitive: ${pe.path} \u2014 ${pe.error}`);
+    }
+    warnings.push(`${parseErrors.length} primitive file(s) failed to parse`);
+  }
+  const targetBudget = maxTokens * 0.15;
+  const priorityOrder = ["rules", "instincts", "skills", "playbooks", "tools", "workflows", "agents"];
+  for (const dir of extDirs) {
+    if (!priorityOrder.includes(dir)) {
+      priorityOrder.push(dir);
+    }
+  }
+  const allDocs = [];
+  for (const category of priorityOrder) {
+    const docs = primitives.get(category);
+    if (!docs || docs.length === 0) continue;
+    for (const doc of docs) {
+      allDocs.push({ category, doc });
+    }
+  }
+  if (allDocs.length === 0) {
+    warnings.push("No primitives found \u2014 add rules, instincts, or skills to improve agent behavior");
+  }
+  const primitiveBudget = targetBudget - budget.used_tokens;
+  let totalL2Demand = 0;
+  for (const { doc } of allDocs) {
+    totalL2Demand += estimateTokens(getAtLevel(doc, 2));
+  }
+  let globalLevel2;
+  if (totalL2Demand <= primitiveBudget) {
+    globalLevel2 = 2;
+  } else {
+    let totalL1Demand = 0;
+    for (const { doc } of allDocs) {
+      totalL1Demand += estimateTokens(getAtLevel(doc, 1));
+    }
+    globalLevel2 = totalL1Demand <= primitiveBudget ? 1 : 0;
+  }
+  for (const category of priorityOrder) {
+    const docs = primitives.get(category);
+    if (!docs || docs.length === 0) continue;
+    const categoryLabel = category.toUpperCase();
+    const categoryDocs = [];
+    for (const doc of docs) {
+      let level = globalLevel2;
+      let content = getAtLevel(doc, level);
+      let tokens = estimateTokens(content);
+      while (budget.used_tokens + tokens > targetBudget && level > 0) {
+        level = level - 1;
+        content = getAtLevel(doc, level);
+        tokens = estimateTokens(content);
+      }
+      categoryDocs.push(`### ${doc.frontmatter.id}
+${content}`);
+      budget.used_tokens += tokens;
+      budget.loaded_files.push(doc.path);
+    }
+    if (categoryDocs.length > 0) {
+      sections.push(`# ${categoryLabel}
+
+${categoryDocs.join("\n\n")}`);
+    }
+  }
+  const scratchPath = join3(harnessDir, "memory", "scratch.md");
+  if (existsSync3(scratchPath)) {
+    const scratch = readFileSync3(scratchPath, "utf-8");
+    if (scratch.trim()) {
+      sections.push(`# SCRATCH (Current Working Memory)
+
+${scratch}`);
+      budget.used_tokens += estimateTokens(scratch);
+      budget.loaded_files.push("memory/scratch.md");
+    }
+  }
+  budget.remaining = maxTokens - budget.used_tokens;
+  const usagePercent = budget.used_tokens / maxTokens * 100;
+  if (usagePercent > 12) {
+    warnings.push(
+      `System prompt using ${usagePercent.toFixed(1)}% of total context (${budget.used_tokens}/${maxTokens} tokens) \u2014 some primitives may be truncated`
+    );
+    log.warn(
+      `Context budget high: ${budget.used_tokens}/${maxTokens} tokens (${usagePercent.toFixed(1)}%), ${budget.loaded_files.length} files loaded`
+    );
+  }
+  if (globalLevel2 < 2) {
+    const levelName = globalLevel2 === 0 ? "L0 (summary only)" : "L1 (paragraph summary)";
+    warnings.push(`Primitives loaded at ${levelName} due to budget constraints`);
+  }
+  return {
+    systemPrompt: sections.join("\n\n---\n\n"),
+    budget,
+    parseErrors,
+    warnings
+  };
+}
+
+// src/runtime/state.ts
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync2, existsSync as existsSync5 } from "fs";
+import { join as join5 } from "path";
+
+// src/runtime/file-lock.ts
+import { writeFileSync, unlinkSync, readFileSync as readFileSync4, existsSync as existsSync4, mkdirSync } from "fs";
+import { join as join4, basename } from "path";
+var DEFAULT_STALE_MS = 3e4;
+var DEFAULT_RETRY_MS = 50;
+var DEFAULT_WAIT_MS = 5e3;
+function getLockDir(harnessDir) {
+  return join4(harnessDir, "memory");
+}
+function getLockPath(harnessDir, filePath) {
+  const lockDir = getLockDir(harnessDir);
+  const lockName = basename(filePath).replace(/\.[^.]+$/, "") + ".lock";
+  return join4(lockDir, lockName);
+}
+function readLockInfo(lockPath) {
+  if (!existsSync4(lockPath)) return null;
+  try {
+    const content = readFileSync4(lockPath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (typeof parsed === "object" && parsed !== null && "pid" in parsed && "acquired" in parsed) {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function isStale(info, staleMs) {
+  const age = Date.now() - new Date(info.acquired).getTime();
+  if (age > staleMs) return true;
+  try {
+    process.kill(info.pid, 0);
+    return false;
+  } catch {
+    return true;
+  }
+}
+function tryLock(harnessDir, filePath, options) {
+  const staleMs = options?.staleMs ?? DEFAULT_STALE_MS;
+  const lockPath = getLockPath(harnessDir, filePath);
+  const lockDir = getLockDir(harnessDir);
+  if (!existsSync4(lockDir)) {
+    mkdirSync(lockDir, { recursive: true });
+  }
+  const existing = readLockInfo(lockPath);
+  if (existing) {
+    if (isStale(existing, staleMs)) {
+      try {
+        unlinkSync(lockPath);
+      } catch {
+      }
+    } else {
+      return false;
+    }
+  }
+  const info = {
+    pid: process.pid,
+    acquired: (/* @__PURE__ */ new Date()).toISOString(),
+    file: filePath
+  };
+  try {
+    writeFileSync(lockPath, JSON.stringify(info), { flag: "wx" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function releaseLock(harnessDir, filePath) {
+  const lockPath = getLockPath(harnessDir, filePath);
+  if (!existsSync4(lockPath)) return;
+  const info = readLockInfo(lockPath);
+  if (info && info.pid === process.pid) {
+    try {
+      unlinkSync(lockPath);
+    } catch {
+    }
+  }
+}
+async function acquireLock(harnessDir, filePath, options) {
+  const retryMs = options?.retryIntervalMs ?? DEFAULT_RETRY_MS;
+  const waitMs = options?.waitMs ?? DEFAULT_WAIT_MS;
+  const deadline = Date.now() + waitMs;
+  while (Date.now() < deadline) {
+    if (tryLock(harnessDir, filePath, options)) {
+      return true;
+    }
+    await new Promise((resolve2) => setTimeout(resolve2, retryMs));
+  }
+  return false;
+}
+async function withFileLock(harnessDir, filePath, fn, options) {
+  const acquired = await acquireLock(harnessDir, filePath, options);
+  try {
+    return await fn();
+  } finally {
+    if (acquired) {
+      releaseLock(harnessDir, filePath);
+    }
+  }
+}
+function withFileLockSync(harnessDir, filePath, fn, options) {
+  const acquired = tryLock(harnessDir, filePath, options);
+  try {
+    return fn();
+  } finally {
+    if (acquired) {
+      releaseLock(harnessDir, filePath);
+    }
+  }
+}
+function isLocked(harnessDir, filePath, options) {
+  const staleMs = options?.staleMs ?? DEFAULT_STALE_MS;
+  const lockPath = getLockPath(harnessDir, filePath);
+  const info = readLockInfo(lockPath);
+  if (!info) return false;
+  return !isStale(info, staleMs);
+}
+function breakLock(harnessDir, filePath) {
+  const lockPath = getLockPath(harnessDir, filePath);
+  if (!existsSync4(lockPath)) return false;
+  try {
+    unlinkSync(lockPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/runtime/state.ts
+var DEFAULT_STATE = {
+  mode: "idle",
+  goals: [],
+  active_workflows: [],
+  last_interaction: (/* @__PURE__ */ new Date()).toISOString(),
+  unfinished_business: []
+};
+function loadState(harnessDir) {
+  const statePath = join5(harnessDir, "state.md");
+  if (!existsSync5(statePath)) {
+    return { ...DEFAULT_STATE };
+  }
+  const content = readFileSync5(statePath, "utf-8");
+  return parseStateMd(content);
+}
+function saveState(harnessDir, state) {
+  const statePath = join5(harnessDir, "state.md");
+  const content = renderStateMd(state);
+  withFileLockSync(harnessDir, statePath, () => {
+    writeFileSync2(statePath, content, "utf-8");
+  });
+}
+function parseStateMd(content) {
+  const state = { ...DEFAULT_STATE };
+  const modeMatch = content.match(/## Mode\s*\n(.+)/);
+  if (modeMatch) state.mode = modeMatch[1].trim();
+  const goalsMatch = content.match(/## Goals\s*\n([\s\S]*?)(?=\n## |\n$|$)/);
+  if (goalsMatch) {
+    state.goals = goalsMatch[1].split("\n").filter((l) => l.startsWith("- ")).map((l) => l.replace(/^- /, "").trim());
+  }
+  const workflowsMatch = content.match(/## Active Workflows\s*\n([\s\S]*?)(?=\n## |\n$|$)/);
+  if (workflowsMatch) {
+    state.active_workflows = workflowsMatch[1].split("\n").filter((l) => l.startsWith("- ")).map((l) => l.replace(/^- /, "").trim());
+  }
+  const lastMatch = content.match(/## Last Interaction\s*\n(.+)/);
+  if (lastMatch) state.last_interaction = lastMatch[1].trim();
+  const unfinishedMatch = content.match(/## Unfinished Business\s*\n([\s\S]*?)(?=\n## |\n$|$)/);
+  if (unfinishedMatch) {
+    state.unfinished_business = unfinishedMatch[1].split("\n").filter((l) => l.startsWith("- ")).map((l) => l.replace(/^- /, "").trim());
+  }
+  return state;
+}
+function renderStateMd(state) {
+  const lines = [
+    "# Agent State",
+    "",
+    "## Mode",
+    state.mode,
+    "",
+    "## Goals",
+    ...state.goals.map((g) => `- ${g}`),
+    "",
+    "## Active Workflows",
+    ...state.active_workflows.map((w) => `- ${w}`),
+    "",
+    "## Last Interaction",
+    state.last_interaction,
+    "",
+    "## Unfinished Business",
+    ...state.unfinished_business.map((u) => `- ${u}`),
+    ""
+  ];
+  return lines.join("\n");
+}
+
+// src/runtime/sessions.ts
+import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, existsSync as existsSync6, readdirSync as readdirSync2, unlinkSync as unlinkSync2, copyFileSync } from "fs";
+import { join as join6 } from "path";
+import { randomUUID } from "crypto";
+function createSessionId() {
+  const now = /* @__PURE__ */ new Date();
+  const date = now.toISOString().split("T")[0];
+  const short = randomUUID().slice(0, 8);
+  return `${date}-${short}`;
+}
+function formatToolCalls(toolCalls) {
+  if (!toolCalls || toolCalls.length === 0) return "";
+  const lines = ["\n## Tools Used\n"];
+  for (const tc of toolCalls) {
+    lines.push(`### ${tc.toolName}`);
+    const argsStr = JSON.stringify(tc.args, null, 2);
+    lines.push(`**Args:** \`${argsStr.length > 200 ? argsStr.slice(0, 200) + "..." : argsStr}\``);
+    if (tc.result !== null && tc.result !== void 0) {
+      const resultStr = typeof tc.result === "string" ? tc.result : JSON.stringify(tc.result);
+      lines.push(`**Result:** ${resultStr.length > 300 ? resultStr.slice(0, 300) + "..." : resultStr}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function writeSession(harnessDir, session) {
+  const sessionsDir = join6(harnessDir, "memory", "sessions");
+  if (!existsSync6(sessionsDir)) {
+    mkdirSync2(sessionsDir, { recursive: true });
+  }
+  const filePath = join6(sessionsDir, `${session.id}.md`);
+  const tags = session.delegated_to ? `[session, delegation, ${session.delegated_to}]` : "[session]";
+  const modelLine = session.model_id ? `
+**Model:** ${session.model_id}` : "";
+  const delegateLine = session.delegated_to ? `
+**Delegated to:** ${session.delegated_to}` : "";
+  const toolSection = formatToolCalls(session.tool_calls);
+  const content = `---
+id: ${session.id}
+tags: ${tags}
+created: ${session.started}
+updated: ${session.ended}
+author: agent
+status: active
+duration_minutes: ${Math.round((new Date(session.ended).getTime() - new Date(session.started).getTime()) / 6e4)}
+---
+
+<!-- L0: Session ${session.id} \u2014 ${session.summary.slice(0, 60)} -->
+<!-- L1: ${session.summary} -->
+
+# Session: ${session.id}
+
+**Started:** ${session.started}
+**Ended:** ${session.ended}
+**Tokens:** ${session.tokens_used}
+**Steps:** ${session.steps}${modelLine}${delegateLine}
+
+## Prompt
+${session.prompt}
+
+## Summary
+${session.summary}
+${toolSection}`;
+  withFileLockSync(harnessDir, filePath, () => {
+    writeFileSync3(filePath, content, "utf-8");
+  });
+  return filePath;
+}
+function archiveOldFiles(harnessDir, sessionRetentionDays, journalRetentionDays) {
+  const result = {
+    sessionsArchived: 0,
+    journalsArchived: 0,
+    sessionFiles: [],
+    journalFiles: []
+  };
+  const now = Date.now();
+  const sessionsDir = join6(harnessDir, "memory", "sessions");
+  if (existsSync6(sessionsDir)) {
+    const cutoff = now - sessionRetentionDays * 24 * 60 * 60 * 1e3;
+    const files = readdirSync2(sessionsDir).filter(
+      (f) => f.endsWith(".md") && !f.startsWith(".") && !f.startsWith("_")
+    );
+    for (const file of files) {
+      const dateStr = extractDateFromFilename(file);
+      if (dateStr && new Date(dateStr).getTime() < cutoff) {
+        const yearMonth = dateStr.slice(0, 7);
+        const archiveDir = join6(sessionsDir, "archive", yearMonth);
+        mkdirSync2(archiveDir, { recursive: true });
+        copyFileSync(join6(sessionsDir, file), join6(archiveDir, file));
+        unlinkSync2(join6(sessionsDir, file));
+        result.sessionsArchived++;
+        result.sessionFiles.push(file);
+      }
+    }
+  }
+  const journalDir = join6(harnessDir, "memory", "journal");
+  if (existsSync6(journalDir)) {
+    const cutoff = now - journalRetentionDays * 24 * 60 * 60 * 1e3;
+    const files = readdirSync2(journalDir).filter(
+      (f) => f.endsWith(".md") && !f.startsWith(".") && !f.startsWith("_")
+    );
+    for (const file of files) {
+      const dateStr = extractDateFromFilename(file);
+      if (dateStr && new Date(dateStr).getTime() < cutoff) {
+        const yearMonth = dateStr.slice(0, 7);
+        const archiveDir = join6(journalDir, "archive", yearMonth);
+        mkdirSync2(archiveDir, { recursive: true });
+        copyFileSync(join6(journalDir, file), join6(archiveDir, file));
+        unlinkSync2(join6(journalDir, file));
+        result.journalsArchived++;
+        result.journalFiles.push(file);
+      }
+    }
+  }
+  return result;
+}
+function cleanupOldFiles(harnessDir, sessionRetentionDays, journalRetentionDays) {
+  const result = {
+    sessionsRemoved: 0,
+    journalsRemoved: 0,
+    sessionFiles: [],
+    journalFiles: []
+  };
+  const now = Date.now();
+  const sessionsDir = join6(harnessDir, "memory", "sessions");
+  if (existsSync6(sessionsDir)) {
+    const cutoff = now - sessionRetentionDays * 24 * 60 * 60 * 1e3;
+    const files = readdirSync2(sessionsDir).filter((f) => f.endsWith(".md") && !f.startsWith("."));
+    for (const file of files) {
+      const dateStr = extractDateFromFilename(file);
+      if (dateStr && new Date(dateStr).getTime() < cutoff) {
+        unlinkSync2(join6(sessionsDir, file));
+        result.sessionsRemoved++;
+        result.sessionFiles.push(file);
+      }
+    }
+  }
+  const journalDir = join6(harnessDir, "memory", "journal");
+  if (existsSync6(journalDir)) {
+    const cutoff = now - journalRetentionDays * 24 * 60 * 60 * 1e3;
+    const files = readdirSync2(journalDir).filter((f) => f.endsWith(".md") && !f.startsWith("."));
+    for (const file of files) {
+      const dateStr = extractDateFromFilename(file);
+      if (dateStr && new Date(dateStr).getTime() < cutoff) {
+        unlinkSync2(join6(journalDir, file));
+        result.journalsRemoved++;
+        result.journalFiles.push(file);
+      }
+    }
+  }
+  return result;
+}
+function extractDateFromFilename(filename) {
+  const match = filename.match(/^(\d{4}-\d{2}-\d{2})/);
+  if (!match) return null;
+  const date = new Date(match[1]);
+  return isNaN(date.getTime()) ? null : match[1];
+}
+function listSessions(harnessDir) {
+  const sessionsDir = join6(harnessDir, "memory", "sessions");
+  if (!existsSync6(sessionsDir)) return [];
+  return readdirSync2(sessionsDir).filter((f) => f.endsWith(".md") && !f.startsWith(".")).sort().reverse().map((f) => ({
+    id: f.replace(".md", ""),
+    date: extractDateFromFilename(f) || "unknown",
+    path: join6(sessionsDir, f)
+  }));
+}
+function listExpiredFiles(harnessDir, sessionRetentionDays, journalRetentionDays) {
+  const now = Date.now();
+  const sessionFiles = [];
+  const journalFiles = [];
+  const sessionsDir = join6(harnessDir, "memory", "sessions");
+  if (existsSync6(sessionsDir)) {
+    const cutoff = now - sessionRetentionDays * 24 * 60 * 60 * 1e3;
+    const files = readdirSync2(sessionsDir).filter((f) => f.endsWith(".md") && !f.startsWith("."));
+    for (const file of files) {
+      const dateStr = extractDateFromFilename(file);
+      if (dateStr && new Date(dateStr).getTime() < cutoff) {
+        sessionFiles.push(file);
+      }
+    }
+  }
+  const journalDir = join6(harnessDir, "memory", "journal");
+  if (existsSync6(journalDir)) {
+    const cutoff = now - journalRetentionDays * 24 * 60 * 60 * 1e3;
+    const files = readdirSync2(journalDir).filter((f) => f.endsWith(".md") && !f.startsWith("."));
+    for (const file of files) {
+      const dateStr = extractDateFromFilename(file);
+      if (dateStr && new Date(dateStr).getTime() < cutoff) {
+        journalFiles.push(file);
+      }
+    }
+  }
+  return { sessionFiles, journalFiles };
+}
+
+// src/runtime/cost-tracker.ts
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, existsSync as existsSync7, mkdirSync as mkdirSync3 } from "fs";
+import { join as join7 } from "path";
+var COST_FILE = "costs.json";
+var MAX_ENTRIES = 5e3;
+var DEFAULT_PRICING = [
+  // Anthropic via OpenRouter
+  { model_pattern: "anthropic/claude-sonnet-4", input_per_million: 3, output_per_million: 15 },
+  { model_pattern: "anthropic/claude-opus-4", input_per_million: 15, output_per_million: 75 },
+  { model_pattern: "anthropic/claude-haiku-3.5", input_per_million: 0.8, output_per_million: 4 },
+  // Direct Anthropic
+  { model_pattern: "claude-sonnet-4", input_per_million: 3, output_per_million: 15 },
+  { model_pattern: "claude-opus-4", input_per_million: 15, output_per_million: 75 },
+  { model_pattern: "claude-haiku-3.5", input_per_million: 0.8, output_per_million: 4 },
+  // OpenAI
+  { model_pattern: "openai/gpt-4o", input_per_million: 2.5, output_per_million: 10 },
+  { model_pattern: "gpt-4o", input_per_million: 2.5, output_per_million: 10 },
+  { model_pattern: "openai/gpt-4o-mini", input_per_million: 0.15, output_per_million: 0.6 },
+  { model_pattern: "gpt-4o-mini", input_per_million: 0.15, output_per_million: 0.6 },
+  // Local models
+  { model_pattern: "local/", input_per_million: 0, output_per_million: 0 }
+];
+function getStorePath(harnessDir) {
+  return join7(harnessDir, "memory", COST_FILE);
+}
+function loadCosts(harnessDir) {
+  const storePath = getStorePath(harnessDir);
+  if (!existsSync7(storePath)) {
+    return { entries: [], updated: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+  try {
+    const content = readFileSync6(storePath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (typeof parsed === "object" && parsed !== null && "entries" in parsed && Array.isArray(parsed.entries)) {
+      return parsed;
+    }
+    return { entries: [], updated: (/* @__PURE__ */ new Date()).toISOString() };
+  } catch {
+    return { entries: [], updated: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+}
+function saveCosts(harnessDir, store) {
+  const memoryDir = join7(harnessDir, "memory");
+  if (!existsSync7(memoryDir)) {
+    mkdirSync3(memoryDir, { recursive: true });
+  }
+  if (store.entries.length > MAX_ENTRIES) {
+    store.entries = store.entries.slice(store.entries.length - MAX_ENTRIES);
+  }
+  store.updated = (/* @__PURE__ */ new Date()).toISOString();
+  writeFileSync4(getStorePath(harnessDir), JSON.stringify(store, null, 2), "utf-8");
+}
+function findPricing(modelId, customPricing) {
+  const allPricing = [...customPricing ?? [], ...DEFAULT_PRICING];
+  for (const pricing of allPricing) {
+    if (modelId === pricing.model_pattern || modelId.startsWith(pricing.model_pattern)) {
+      return pricing;
+    }
+  }
+  return null;
+}
+function calculateCost(modelId, inputTokens, outputTokens, customPricing) {
+  const pricing = findPricing(modelId, customPricing);
+  if (!pricing) return 0;
+  const inputCost = inputTokens / 1e6 * pricing.input_per_million;
+  const outputCost = outputTokens / 1e6 * pricing.output_per_million;
+  return Math.round((inputCost + outputCost) * 1e6) / 1e6;
+}
+function recordCost(harnessDir, entry, customPricing) {
+  const store = loadCosts(harnessDir);
+  const costUsd = entry.cost_usd ?? calculateCost(
+    entry.model_id,
+    entry.input_tokens,
+    entry.output_tokens,
+    customPricing
+  );
+  const fullEntry = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    model_id: entry.model_id,
+    provider: entry.provider,
+    input_tokens: entry.input_tokens,
+    output_tokens: entry.output_tokens,
+    cost_usd: costUsd,
+    source: entry.source
+  };
+  store.entries.push(fullEntry);
+  saveCosts(harnessDir, store);
+  return fullEntry;
+}
+function getSpending(harnessDir, from, to) {
+  const store = loadCosts(harnessDir);
+  const fromDate = from ?? (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const toDate = to ?? new Date(Date.now() + 864e5).toISOString().split("T")[0];
+  const filtered = store.entries.filter(
+    (e) => e.timestamp >= fromDate && e.timestamp < toDate + "T99"
+  );
+  const byModel = {};
+  const byProvider = {};
+  let totalCost = 0;
+  let totalInput = 0;
+  let totalOutput = 0;
+  for (const entry of filtered) {
+    totalCost += entry.cost_usd;
+    totalInput += entry.input_tokens;
+    totalOutput += entry.output_tokens;
+    if (!byModel[entry.model_id]) {
+      byModel[entry.model_id] = { cost_usd: 0, input_tokens: 0, output_tokens: 0, count: 0 };
+    }
+    byModel[entry.model_id].cost_usd += entry.cost_usd;
+    byModel[entry.model_id].input_tokens += entry.input_tokens;
+    byModel[entry.model_id].output_tokens += entry.output_tokens;
+    byModel[entry.model_id].count += 1;
+    if (!byProvider[entry.provider]) {
+      byProvider[entry.provider] = { cost_usd: 0, count: 0 };
+    }
+    byProvider[entry.provider].cost_usd += entry.cost_usd;
+    byProvider[entry.provider].count += 1;
+  }
+  return {
+    total_cost_usd: Math.round(totalCost * 1e6) / 1e6,
+    total_input_tokens: totalInput,
+    total_output_tokens: totalOutput,
+    entries: filtered.length,
+    by_model: byModel,
+    by_provider: byProvider
+  };
+}
+function checkBudget(harnessDir, budget) {
+  const now = /* @__PURE__ */ new Date();
+  const today = now.toISOString().split("T")[0];
+  const monthStart = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-01`;
+  const dailySpending = getSpending(harnessDir, today);
+  const monthlySpending = getSpending(harnessDir, monthStart);
+  const alerts = [];
+  const alertPct = budget.alert_threshold_pct ?? 80;
+  const dailyLimit = budget.daily_limit_usd ?? null;
+  const monthlyLimit = budget.monthly_limit_usd ?? null;
+  let dailyPct = null;
+  let dailyRemaining = null;
+  if (dailyLimit !== null) {
+    dailyPct = dailyLimit > 0 ? dailySpending.total_cost_usd / dailyLimit * 100 : 0;
+    dailyRemaining = Math.max(0, dailyLimit - dailySpending.total_cost_usd);
+    if (dailySpending.total_cost_usd >= dailyLimit) {
+      alerts.push(`Daily budget exceeded: $${dailySpending.total_cost_usd.toFixed(4)} / $${dailyLimit.toFixed(2)}`);
+    } else if (dailyPct >= alertPct) {
+      alerts.push(`Daily budget at ${dailyPct.toFixed(0)}%: $${dailySpending.total_cost_usd.toFixed(4)} / $${dailyLimit.toFixed(2)}`);
+    }
+  }
+  let monthlyPct = null;
+  let monthlyRemaining = null;
+  if (monthlyLimit !== null) {
+    monthlyPct = monthlyLimit > 0 ? monthlySpending.total_cost_usd / monthlyLimit * 100 : 0;
+    monthlyRemaining = Math.max(0, monthlyLimit - monthlySpending.total_cost_usd);
+    if (monthlySpending.total_cost_usd >= monthlyLimit) {
+      alerts.push(`Monthly budget exceeded: $${monthlySpending.total_cost_usd.toFixed(4)} / $${monthlyLimit.toFixed(2)}`);
+    } else if (monthlyPct >= alertPct) {
+      alerts.push(`Monthly budget at ${monthlyPct.toFixed(0)}%: $${monthlySpending.total_cost_usd.toFixed(4)} / $${monthlyLimit.toFixed(2)}`);
+    }
+  }
+  return {
+    daily_spent_usd: dailySpending.total_cost_usd,
+    daily_limit_usd: dailyLimit,
+    daily_remaining_usd: dailyRemaining,
+    daily_pct: dailyPct,
+    monthly_spent_usd: monthlySpending.total_cost_usd,
+    monthly_limit_usd: monthlyLimit,
+    monthly_remaining_usd: monthlyRemaining,
+    monthly_pct: monthlyPct,
+    alerts
+  };
+}
+function clearCosts(harnessDir, modelId) {
+  const store = loadCosts(harnessDir);
+  const before = store.entries.length;
+  if (modelId) {
+    store.entries = store.entries.filter((e) => e.model_id !== modelId);
+  } else {
+    store.entries = [];
+  }
+  saveCosts(harnessDir, store);
+  return before - store.entries.length;
+}
+
+// src/runtime/health.ts
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, existsSync as existsSync8, mkdirSync as mkdirSync4 } from "fs";
+import { join as join8 } from "path";
+var HEALTH_FILE = "health.json";
+function getHealthPath(harnessDir) {
+  return join8(harnessDir, "memory", HEALTH_FILE);
+}
+function defaultMetrics() {
+  return {
+    lastSuccessfulRun: null,
+    lastFailedRun: null,
+    lastError: null,
+    consecutiveFailures: 0,
+    totalRuns: 0,
+    totalSuccesses: 0,
+    totalFailures: 0,
+    bootedAt: null,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function loadHealth(harnessDir) {
+  const healthPath = getHealthPath(harnessDir);
+  if (!existsSync8(healthPath)) {
+    return defaultMetrics();
+  }
+  try {
+    const content = readFileSync7(healthPath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (typeof parsed === "object" && parsed !== null && "totalRuns" in parsed) {
+      return parsed;
+    }
+    return defaultMetrics();
+  } catch {
+    return defaultMetrics();
+  }
+}
+function saveHealth(harnessDir, metrics) {
+  const memoryDir = join8(harnessDir, "memory");
+  if (!existsSync8(memoryDir)) {
+    mkdirSync4(memoryDir, { recursive: true });
+  }
+  metrics.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  writeFileSync5(getHealthPath(harnessDir), JSON.stringify(metrics, null, 2), "utf-8");
+}
+function recordSuccess(harnessDir) {
+  const metrics = loadHealth(harnessDir);
+  metrics.totalRuns++;
+  metrics.totalSuccesses++;
+  metrics.consecutiveFailures = 0;
+  metrics.lastSuccessfulRun = (/* @__PURE__ */ new Date()).toISOString();
+  saveHealth(harnessDir, metrics);
+}
+function recordFailure(harnessDir, error) {
+  const metrics = loadHealth(harnessDir);
+  metrics.totalRuns++;
+  metrics.totalFailures++;
+  metrics.consecutiveFailures++;
+  metrics.lastFailedRun = (/* @__PURE__ */ new Date()).toISOString();
+  metrics.lastError = error ?? null;
+  saveHealth(harnessDir, metrics);
+}
+function recordBoot(harnessDir) {
+  const metrics = loadHealth(harnessDir);
+  metrics.bootedAt = (/* @__PURE__ */ new Date()).toISOString();
+  saveHealth(harnessDir, metrics);
+}
+function getHealthStatus(harnessDir) {
+  const metrics = loadHealth(harnessDir);
+  const checks = [];
+  const requiredFiles = ["CORE.md", "config.yaml", "state.md"];
+  const missingFiles = requiredFiles.filter((f) => !existsSync8(join8(harnessDir, f)));
+  if (missingFiles.length === 0) {
+    checks.push({ name: "core-files", status: "pass", message: "All core files present" });
+  } else {
+    checks.push({ name: "core-files", status: "fail", message: `Missing: ${missingFiles.join(", ")}` });
+  }
+  const memoryDir = join8(harnessDir, "memory");
+  if (existsSync8(memoryDir)) {
+    checks.push({ name: "memory-dir", status: "pass", message: "Memory directory exists" });
+  } else {
+    checks.push({ name: "memory-dir", status: "fail", message: "Memory directory missing" });
+  }
+  const apiKeys = [
+    { name: "OpenRouter", envVar: "OPENROUTER_API_KEY" },
+    { name: "Anthropic", envVar: "ANTHROPIC_API_KEY" },
+    { name: "OpenAI", envVar: "OPENAI_API_KEY" }
+  ];
+  const presentKeys = apiKeys.filter((k) => process.env[k.envVar]);
+  if (presentKeys.length > 0) {
+    checks.push({
+      name: "api-keys",
+      status: "pass",
+      message: `API keys: ${presentKeys.map((k) => k.name).join(", ")}`
+    });
+  } else {
+    checks.push({ name: "api-keys", status: "warn", message: "No API keys found in environment" });
+  }
+  if (metrics.consecutiveFailures === 0) {
+    checks.push({ name: "run-health", status: "pass", message: "No consecutive failures" });
+  } else if (metrics.consecutiveFailures < 3) {
+    checks.push({
+      name: "run-health",
+      status: "warn",
+      message: `${metrics.consecutiveFailures} consecutive failure(s)`
+    });
+  } else {
+    checks.push({
+      name: "run-health",
+      status: "fail",
+      message: `${metrics.consecutiveFailures} consecutive failures \u2014 last error: ${metrics.lastError ?? "unknown"}`
+    });
+  }
+  if (metrics.lastSuccessfulRun) {
+    const hoursSinceSuccess = (Date.now() - new Date(metrics.lastSuccessfulRun).getTime()) / 36e5;
+    if (hoursSinceSuccess < 24) {
+      checks.push({ name: "last-success", status: "pass", message: `Last success: ${metrics.lastSuccessfulRun}` });
+    } else {
+      checks.push({
+        name: "last-success",
+        status: "warn",
+        message: `Last success was ${Math.round(hoursSinceSuccess)}h ago`
+      });
+    }
+  } else if (metrics.totalRuns > 0) {
+    checks.push({ name: "last-success", status: "warn", message: "No successful runs recorded" });
+  }
+  let costToday = 0;
+  let costThisMonth = 0;
+  try {
+    const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const monthStart = `${(/* @__PURE__ */ new Date()).getFullYear()}-${String((/* @__PURE__ */ new Date()).getMonth() + 1).padStart(2, "0")}-01`;
+    costToday = getSpending(harnessDir, today).total_cost_usd;
+    costThisMonth = getSpending(harnessDir, monthStart).total_cost_usd;
+  } catch {
+  }
+  const failCount = checks.filter((c) => c.status === "fail").length;
+  const warnCount = checks.filter((c) => c.status === "warn").length;
+  let status;
+  if (failCount > 0) {
+    status = "unhealthy";
+  } else if (warnCount > 0) {
+    status = "degraded";
+  } else {
+    status = "healthy";
+  }
+  return { status, checks, metrics, costToday, costThisMonth };
+}
+function resetHealth(harnessDir) {
+  saveHealth(harnessDir, defaultMetrics());
+}
+
+// src/runtime/rate-limiter.ts
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync6, existsSync as existsSync9, mkdirSync as mkdirSync5 } from "fs";
+import { join as join9 } from "path";
+var RATE_FILE = "rate-limits.json";
+var MAX_EVENTS = 1e4;
+function getStorePath2(harnessDir) {
+  return join9(harnessDir, "memory", RATE_FILE);
+}
+function loadRateLimits(harnessDir) {
+  const storePath = getStorePath2(harnessDir);
+  if (!existsSync9(storePath)) {
+    return { events: [], updated: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+  try {
+    const content = readFileSync8(storePath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (typeof parsed === "object" && parsed !== null && "events" in parsed && Array.isArray(parsed.events)) {
+      return parsed;
+    }
+    return { events: [], updated: (/* @__PURE__ */ new Date()).toISOString() };
+  } catch {
+    return { events: [], updated: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+}
+function saveRateLimits(harnessDir, store) {
+  const memoryDir = join9(harnessDir, "memory");
+  if (!existsSync9(memoryDir)) {
+    mkdirSync5(memoryDir, { recursive: true });
+  }
+  if (store.events.length > MAX_EVENTS) {
+    store.events = store.events.slice(store.events.length - MAX_EVENTS);
+  }
+  store.updated = (/* @__PURE__ */ new Date()).toISOString();
+  writeFileSync6(getStorePath2(harnessDir), JSON.stringify(store, null, 2), "utf-8");
+}
+function pruneExpired(store, now, maxWindowMs) {
+  const cutoff = now - maxWindowMs;
+  store.events = store.events.filter((e) => e.timestamp > cutoff);
+}
+function checkRateLimit(harnessDir, limit, now) {
+  const currentTime = now ?? Date.now();
+  const store = loadRateLimits(harnessDir);
+  const windowStart = currentTime - limit.window_ms;
+  const eventsInWindow = store.events.filter(
+    (e) => e.key === limit.key && e.timestamp > windowStart
+  );
+  const current = eventsInWindow.length;
+  const allowed = current < limit.max_requests;
+  let retryAfterMs = 0;
+  if (!allowed && eventsInWindow.length > 0) {
+    const oldest = eventsInWindow.reduce((min, e) => Math.min(min, e.timestamp), Infinity);
+    retryAfterMs = Math.max(0, oldest + limit.window_ms - currentTime);
+  }
+  return {
+    allowed,
+    key: limit.key,
+    current,
+    max: limit.max_requests,
+    window_ms: limit.window_ms,
+    retry_after_ms: retryAfterMs
+  };
+}
+function recordEvent(harnessDir, key, now) {
+  const currentTime = now ?? Date.now();
+  const store = loadRateLimits(harnessDir);
+  store.events.push({ key, timestamp: currentTime });
+  pruneExpired(store, currentTime, 36e5);
+  saveRateLimits(harnessDir, store);
+}
+function tryAcquire(harnessDir, limit, now) {
+  const currentTime = now ?? Date.now();
+  const check = checkRateLimit(harnessDir, limit, currentTime);
+  if (check.allowed) {
+    recordEvent(harnessDir, limit.key, currentTime);
+  }
+  return check;
+}
+function getUsage(harnessDir, key, windowMs, now) {
+  const currentTime = now ?? Date.now();
+  const store = loadRateLimits(harnessDir);
+  const windowStart = currentTime - windowMs;
+  const eventsInWindow = store.events.filter(
+    (e) => e.key === key && e.timestamp > windowStart
+  );
+  if (eventsInWindow.length === 0) {
+    return { count: 0, oldest: null, newest: null };
+  }
+  const timestamps = eventsInWindow.map((e) => e.timestamp);
+  return {
+    count: eventsInWindow.length,
+    oldest: Math.min(...timestamps),
+    newest: Math.max(...timestamps)
+  };
+}
+function clearRateLimits(harnessDir, key) {
+  const store = loadRateLimits(harnessDir);
+  const before = store.events.length;
+  if (key) {
+    store.events = store.events.filter((e) => e.key !== key);
+  } else {
+    store.events = [];
+  }
+  saveRateLimits(harnessDir, store);
+  return before - store.events.length;
+}
+
+// src/runtime/guardrails.ts
+var RATE_KEY = "llm-calls";
+function buildRateLimits(config) {
+  const limits = [];
+  const rl = config.rate_limits;
+  if (rl?.per_minute) {
+    limits.push({ key: `${RATE_KEY}:minute`, max_requests: rl.per_minute, window_ms: 6e4 });
+  }
+  if (rl?.per_hour) {
+    limits.push({ key: `${RATE_KEY}:hour`, max_requests: rl.per_hour, window_ms: 36e5 });
+  }
+  if (rl?.per_day) {
+    limits.push({ key: `${RATE_KEY}:day`, max_requests: rl.per_day, window_ms: 864e5 });
+  }
+  return limits;
+}
+function checkGuardrails(harnessDir, config) {
+  const limits = buildRateLimits(config);
+  for (const limit of limits) {
+    const check = checkRateLimit(harnessDir, limit);
+    if (!check.allowed) {
+      const windowLabel = limit.window_ms <= 6e4 ? "minute" : limit.window_ms <= 36e5 ? "hour" : "day";
+      return {
+        allowed: false,
+        reason: `Rate limit exceeded: ${check.current}/${check.max} calls per ${windowLabel}. Retry after ${Math.ceil(check.retry_after_ms / 1e3)}s.`,
+        rateLimitCheck: check,
+        budgetStatus: null,
+        retryAfterMs: check.retry_after_ms
+      };
+    }
+  }
+  const budgetConfig = config.budget;
+  if (budgetConfig?.enforce !== false && (budgetConfig?.daily_limit_usd || budgetConfig?.monthly_limit_usd)) {
+    const status = checkBudget(harnessDir, {
+      daily_limit_usd: budgetConfig.daily_limit_usd,
+      monthly_limit_usd: budgetConfig.monthly_limit_usd
+    });
+    const exceeded = status.alerts.some((a) => a.includes("exceeded"));
+    if (exceeded) {
+      return {
+        allowed: false,
+        reason: status.alerts.filter((a) => a.includes("exceeded")).join("; "),
+        rateLimitCheck: null,
+        budgetStatus: status,
+        retryAfterMs: 0
+      };
+    }
+  }
+  const now = Date.now();
+  for (const limit of limits) {
+    recordEvent(harnessDir, limit.key, now);
+  }
+  return {
+    allowed: true,
+    reason: null,
+    rateLimitCheck: null,
+    budgetStatus: null,
+    retryAfterMs: 0
+  };
+}
+
+// src/runtime/tool-executor.ts
+import { tool as aiTool, jsonSchema } from "ai";
+
+// src/runtime/tools.ts
+import { existsSync as existsSync10 } from "fs";
+import { join as join10 } from "path";
+function extractAuth(body) {
+  const authSection = body.match(/## Authentication\s*\n([\s\S]*?)(?=\n## |\n$|$)/i);
+  if (!authSection) return [];
+  const envVarPattern = /`([A-Z][A-Z0-9_]+)`/g;
+  const vars = [];
+  const seen = /* @__PURE__ */ new Set();
+  let match;
+  while ((match = envVarPattern.exec(authSection[1])) !== null) {
+    const envVar = match[1];
+    if (!seen.has(envVar)) {
+      seen.add(envVar);
+      vars.push({
+        envVar,
+        present: process.env[envVar] !== void 0 && process.env[envVar] !== ""
+      });
+    }
+  }
+  return vars;
+}
+function extractOperations(body) {
+  const opsSection = body.match(/## (?:Common )?Operations\s*\n([\s\S]*?)(?=\n## |\n$|$)/i);
+  if (!opsSection) return [];
+  const ops = [];
+  const lines = opsSection[1].split("\n");
+  let currentSection = "";
+  for (const line of lines) {
+    const headingMatch = line.match(/^### (.+)/);
+    if (headingMatch) {
+      currentSection = headingMatch[1].trim();
+      continue;
+    }
+    const opMatch = line.match(/`?(GET|POST|PUT|DELETE|PATCH)\s+(\S+?)`?(?:\s|$)/);
+    if (opMatch) {
+      const name = currentSection ? `${currentSection}: ${opMatch[2].split("/").pop() || opMatch[2]}` : opMatch[2].split("/").pop() || opMatch[2];
+      ops.push({
+        name,
+        method: opMatch[1],
+        endpoint: opMatch[2]
+      });
+    }
+  }
+  return ops;
+}
+function extractRateLimits(body) {
+  const section = body.match(/## Rate Limits\s*\n([\s\S]*?)(?=\n## |\n$|$)/i);
+  if (!section) return [];
+  return section[1].split("\n").filter((l) => l.startsWith("- ")).map((l) => l.replace(/^- /, "").trim());
+}
+function extractGotchas(body) {
+  const section = body.match(/## Gotchas\s*\n([\s\S]*?)(?=\n## |\n$|$)/i);
+  if (!section) return [];
+  return section[1].split("\n").filter((l) => l.startsWith("- ")).map((l) => l.replace(/^- /, "").trim());
+}
+function parseToolDefinition(doc) {
+  return {
+    id: doc.frontmatter.id,
+    doc,
+    tags: doc.frontmatter.tags,
+    status: doc.frontmatter.status,
+    auth: extractAuth(doc.body),
+    operations: extractOperations(doc.body),
+    rateLimits: extractRateLimits(doc.body),
+    gotchas: extractGotchas(doc.body)
+  };
+}
+function loadTools(harnessDir) {
+  const toolsDir = join10(harnessDir, "tools");
+  if (!existsSync10(toolsDir)) return [];
+  const docs = loadDirectory(toolsDir);
+  return docs.map(parseToolDefinition);
+}
+function getToolById(harnessDir, toolId) {
+  const tools = loadTools(harnessDir);
+  return tools.find((t) => t.id === toolId) ?? null;
+}
+function listToolSummaries(harnessDir) {
+  const tools = loadTools(harnessDir);
+  return tools.map((t) => ({
+    id: t.id,
+    l0: t.doc.l0,
+    tags: t.tags,
+    status: t.status,
+    authReady: t.auth.length === 0 || t.auth.every((a) => a.present),
+    operationCount: t.operations.length
+  }));
+}
+function checkToolAuth(harnessDir, toolId) {
+  const tools = toolId ? [getToolById(harnessDir, toolId)].filter((t) => t !== null) : loadTools(harnessDir);
+  return tools.map((t) => ({
+    tool: t.id,
+    auth: t.auth
+  }));
+}
+
+// src/runtime/tool-executor.ts
+function resolveEndpoint(endpoint, input) {
+  return endpoint.replace(/\{(\w+)\}/g, (_match, key) => {
+    const value = input[key];
+    if (value === void 0 || value === null) {
+      return `{${key}}`;
+    }
+    return encodeURIComponent(String(value));
+  });
+}
+function buildOperationSchema(operation) {
+  const params = [];
+  const paramRegex = /\{(\w+)\}/g;
+  let match;
+  while ((match = paramRegex.exec(operation.endpoint)) !== null) {
+    params.push(match[1]);
+  }
+  const properties = {};
+  for (const param of params) {
+    properties[param] = { type: "string", description: `Value for ${param}` };
+  }
+  if (["POST", "PUT", "PATCH"].includes(operation.method)) {
+    properties["body"] = { type: "string", description: "Request body (JSON string)" };
+  }
+  properties["query"] = { type: "string", description: "Query parameters (key=value&key2=value2)" };
+  return {
+    type: "object",
+    properties,
+    required: params
+  };
+}
+async function executeHttpOperation(operation, baseUrl, authHeaders, input, timeoutMs) {
+  const resolvedPath = resolveEndpoint(operation.endpoint, input);
+  let url = resolvedPath.startsWith("http") ? resolvedPath : `${baseUrl}${resolvedPath}`;
+  const query = input["query"];
+  if (typeof query === "string" && query.length > 0) {
+    const separator = url.includes("?") ? "&" : "?";
+    url = `${url}${separator}${query}`;
+  }
+  const headers = {
+    "Content-Type": "application/json",
+    "Accept": "application/json",
+    ...authHeaders
+  };
+  const fetchOptions = {
+    method: operation.method,
+    headers,
+    signal: AbortSignal.timeout(timeoutMs)
+  };
+  if (["POST", "PUT", "PATCH"].includes(operation.method)) {
+    const body = input["body"];
+    if (typeof body === "string") {
+      fetchOptions.body = body;
+    } else if (body !== void 0 && body !== null) {
+      fetchOptions.body = JSON.stringify(body);
+    }
+  }
+  const response = await fetch(url, fetchOptions);
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => "Unknown error");
+    throw new Error(`HTTP ${response.status} ${response.statusText}: ${errorText.slice(0, 500)}`);
+  }
+  const contentType = response.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    return response.json();
+  }
+  return response.text();
+}
+function sanitizeToolName(name) {
+  return name.replace(/[^a-zA-Z0-9_-]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").slice(0, 64);
+}
+function extractBaseUrl(toolDef) {
+  for (const op of toolDef.operations) {
+    if (op.endpoint.startsWith("http")) {
+      try {
+        const url = new URL(op.endpoint);
+        return `${url.protocol}//${url.host}`;
+      } catch {
+      }
+    }
+  }
+  const urlMatch = toolDef.doc.body.match(/(?:base[_ ]?url|api[_ ]?url|endpoint)\s*[:=]\s*`?(https?:\/\/[^\s`"']+)/i);
+  if (urlMatch) {
+    try {
+      const url = new URL(urlMatch[1]);
+      return `${url.protocol}//${url.host}`;
+    } catch {
+    }
+  }
+  return "";
+}
+function buildAuthHeaders(toolDef) {
+  const headers = {};
+  for (const auth of toolDef.auth) {
+    const value = process.env[auth.envVar];
+    if (!value) continue;
+    const envLower = auth.envVar.toLowerCase();
+    if (envLower.includes("bot_token")) {
+      headers["Authorization"] = `Bot ${value}`;
+    } else if (envLower.includes("token") || envLower.includes("api_key") || envLower.includes("apikey")) {
+      headers["Authorization"] = `Bearer ${value}`;
+    } else {
+      headers["Authorization"] = `Bearer ${value}`;
+    }
+  }
+  return headers;
+}
+function convertToolDefinition(toolDef, config) {
+  const tools = {};
+  const baseUrl = extractBaseUrl(toolDef);
+  const allowHttp = config.allowHttpExecution !== false;
+  const timeoutMs = config.toolTimeoutMs ?? 3e4;
+  for (const operation of toolDef.operations) {
+    const toolName = sanitizeToolName(`${toolDef.id}_${operation.name}`);
+    const opSchema = buildOperationSchema(operation);
+    tools[toolName] = aiTool({
+      description: `[${toolDef.id}] ${operation.method} ${operation.endpoint} \u2014 ${toolDef.doc.l0}`,
+      inputSchema: jsonSchema(opSchema),
+      execute: async (input) => {
+        const typedInput = input;
+        if (!allowHttp) {
+          return { error: "HTTP tool execution is disabled" };
+        }
+        const missingAuth = toolDef.auth.filter((a) => !process.env[a.envVar]);
+        if (missingAuth.length > 0) {
+          return {
+            error: `Missing required auth: ${missingAuth.map((a) => a.envVar).join(", ")}`
+          };
+        }
+        const authHeaders = buildAuthHeaders(toolDef);
+        try {
+          const result = await executeHttpOperation(
+            operation,
+            baseUrl,
+            authHeaders,
+            typedInput,
+            timeoutMs
+          );
+          return result;
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          log.error(`Tool ${toolName} execution failed: ${message}`);
+          return { error: message };
+        }
+      }
+    });
+  }
+  return tools;
+}
+function convertProgrammaticTool(pt) {
+  const toolName = sanitizeToolName(pt.name);
+  return {
+    [toolName]: aiTool({
+      description: pt.description,
+      inputSchema: pt.inputSchema,
+      execute: async (input) => {
+        try {
+          return await pt.execute(input);
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          log.error(`Tool ${toolName} execution failed: ${message}`);
+          return { error: message };
+        }
+      }
+    })
+  };
+}
+function buildToolSet(harnessDir, config, mcpTools) {
+  const executorConfig = config ?? {};
+  const tools = {};
+  const toolDefs = loadTools(harnessDir);
+  for (const toolDef of toolDefs) {
+    if (toolDef.status !== "active") continue;
+    if (toolDef.operations.length === 0) continue;
+    const converted = convertToolDefinition(toolDef, executorConfig);
+    Object.assign(tools, converted);
+  }
+  if (executorConfig.tools) {
+    for (const pt of executorConfig.tools) {
+      const converted = convertProgrammaticTool(pt);
+      Object.assign(tools, converted);
+    }
+  }
+  if (mcpTools) {
+    Object.assign(tools, mcpTools);
+  }
+  return tools;
+}
+function createToolCallTracker() {
+  const calls = [];
+  let totalDurationMs = 0;
+  return {
+    record(result) {
+      calls.push(result);
+      totalDurationMs += result.durationMs;
+    },
+    getRecord() {
+      return { calls: [...calls], totalDurationMs };
+    }
+  };
+}
+function getToolSetSummary(tools) {
+  return Object.entries(tools).map(([name, t]) => {
+    const desc = t.description ?? "";
+    return `${name}: ${desc}`;
+  });
+}
+
+// src/runtime/mcp.ts
+import { createMCPClient } from "@ai-sdk/mcp";
+import { Experimental_StdioMCPTransport } from "@ai-sdk/mcp/mcp-stdio";
+function buildClientConfig(name, serverConfig) {
+  switch (serverConfig.transport) {
+    case "stdio": {
+      if (!serverConfig.command) {
+        throw new Error(`MCP server "${name}": stdio transport requires "command" field`);
+      }
+      const stderr = getGlobalLogLevel() === "debug" ? "inherit" : "pipe";
+      return {
+        transport: new Experimental_StdioMCPTransport({
+          command: serverConfig.command,
+          args: serverConfig.args,
+          env: serverConfig.env ? { ...process.env, ...serverConfig.env } : void 0,
+          cwd: serverConfig.cwd,
+          stderr
+        }),
+        name: `harness-mcp-${name}`
+      };
+    }
+    case "http": {
+      if (!serverConfig.url) {
+        throw new Error(`MCP server "${name}": http transport requires "url" field`);
+      }
+      return {
+        transport: {
+          type: "http",
+          url: serverConfig.url,
+          headers: serverConfig.headers
+        },
+        name: `harness-mcp-${name}`
+      };
+    }
+    case "sse": {
+      if (!serverConfig.url) {
+        throw new Error(`MCP server "${name}": sse transport requires "url" field`);
+      }
+      return {
+        transport: {
+          type: "sse",
+          url: serverConfig.url,
+          headers: serverConfig.headers
+        },
+        name: `harness-mcp-${name}`
+      };
+    }
+    default:
+      throw new Error(`MCP server "${name}": unknown transport "${serverConfig.transport}"`);
+  }
+}
+async function connectToServer(name, serverConfig) {
+  const clientConfig = buildClientConfig(name, serverConfig);
+  const client = await createMCPClient(clientConfig);
+  const tools = await client.tools();
+  const toolCount = Object.keys(tools).length;
+  return { name, client, toolCount, tools };
+}
+function createMcpManager(config) {
+  const servers = config.mcp?.servers ?? {};
+  const connections = [];
+  const summaries = [];
+  return {
+    hasServers() {
+      return Object.keys(servers).length > 0;
+    },
+    async connect() {
+      const entries = Object.entries(servers);
+      if (entries.length === 0) {
+        return;
+      }
+      log.info(`Connecting to ${entries.length} MCP server(s)...`);
+      for (const [name, serverConfig] of entries) {
+        const enabled = serverConfig.enabled !== false;
+        if (!enabled) {
+          summaries.push({
+            name,
+            transport: serverConfig.transport,
+            enabled: false,
+            connected: false,
+            toolCount: 0,
+            toolNames: []
+          });
+          log.debug(`MCP server "${name}" is disabled, skipping`);
+          continue;
+        }
+        try {
+          const connection = await connectToServer(name, serverConfig);
+          connections.push(connection);
+          const toolNames = Object.keys(connection.tools);
+          summaries.push({
+            name,
+            transport: serverConfig.transport,
+            enabled: true,
+            connected: true,
+            toolCount: connection.toolCount,
+            toolNames
+          });
+          log.info(`MCP "${name}": connected, ${connection.toolCount} tool(s) [${toolNames.join(", ")}]`);
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          summaries.push({
+            name,
+            transport: serverConfig.transport,
+            enabled: true,
+            connected: false,
+            toolCount: 0,
+            toolNames: [],
+            error: message
+          });
+          log.warn(`MCP "${name}": connection failed \u2014 ${message}`);
+        }
+      }
+      const totalTools = connections.reduce((sum, c) => sum + c.toolCount, 0);
+      if (totalTools > 0) {
+        log.info(`MCP: ${totalTools} tool(s) loaded from ${connections.length} server(s)`);
+      }
+    },
+    getTools() {
+      const merged = {};
+      for (const connection of connections) {
+        Object.assign(merged, connection.tools);
+      }
+      return merged;
+    },
+    getSummaries() {
+      const serverNames = Object.keys(servers);
+      const checkedNames = new Set(summaries.map((s) => s.name));
+      for (const name of serverNames) {
+        if (!checkedNames.has(name)) {
+          const serverConfig = servers[name];
+          summaries.push({
+            name,
+            transport: serverConfig.transport,
+            enabled: serverConfig.enabled !== false,
+            connected: false,
+            toolCount: 0,
+            toolNames: []
+          });
+        }
+      }
+      return [...summaries];
+    },
+    async close() {
+      const closePromises = connections.map(async (connection) => {
+        try {
+          await connection.client.close();
+          log.debug(`MCP "${connection.name}": closed`);
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          log.warn(`MCP "${connection.name}": close failed \u2014 ${message}`);
+        }
+      });
+      await Promise.all(closePromises);
+      connections.length = 0;
+    }
+  };
+}
+async function loadMcpTools(config) {
+  const manager = createMcpManager(config);
+  await manager.connect();
+  return {
+    tools: manager.getTools(),
+    summaries: manager.getSummaries(),
+    close: () => manager.close()
+  };
+}
+function validateMcpConfig(config) {
+  const errors = [];
+  const servers = config.mcp?.servers ?? {};
+  for (const [name, serverConfig] of Object.entries(servers)) {
+    if (serverConfig.transport === "stdio") {
+      if (!serverConfig.command) {
+        errors.push({ server: name, error: 'stdio transport requires "command" field' });
+      }
+    } else if (serverConfig.transport === "http" || serverConfig.transport === "sse") {
+      if (!serverConfig.url) {
+        errors.push({ server: name, error: `${serverConfig.transport} transport requires "url" field` });
+      }
+    } else {
+      errors.push({ server: name, error: `unknown transport "${serverConfig.transport}"` });
+    }
+  }
+  return errors;
+}
+
+// src/core/harness.ts
+function createHarness(options) {
+  const dir = resolve(options.dir);
+  if (!existsSync11(dir)) {
+    throw new Error(`Harness directory not found: ${dir}`);
+  }
+  const config = loadConfig(dir, options.config);
+  if (options.model) {
+    config.model = { ...config.model, id: options.model };
+  }
+  if (options.provider) {
+    config.model = { ...config.model, provider: options.provider };
+  }
+  const model = getModel(config, options.apiKey);
+  const hooks = options.hooks ?? {};
+  let state;
+  let systemPrompt;
+  let booted = false;
+  let toolSet = {};
+  let mcpManager;
+  const agent = {
+    name: config.agent.name,
+    config,
+    async boot() {
+      state = loadState(dir);
+      const previousMode = state.mode;
+      state.mode = "active";
+      state.last_interaction = (/* @__PURE__ */ new Date()).toISOString();
+      const ctx = buildSystemPrompt(dir, config);
+      systemPrompt = ctx.systemPrompt;
+      let mcpTools = {};
+      mcpManager = createMcpManager(config);
+      if (mcpManager.hasServers()) {
+        try {
+          await mcpManager.connect();
+          mcpTools = mcpManager.getTools();
+        } catch (err) {
+          log.warn(`MCP connection failed during boot: ${err instanceof Error ? err.message : String(err)}. Continuing without MCP tools.`);
+        }
+      }
+      toolSet = buildToolSet(dir, options.toolExecutor, mcpTools);
+      const toolCount = Object.keys(toolSet).length;
+      booted = true;
+      log.info(
+        `Booted "${config.agent.name}" | ${ctx.budget.loaded_files.length} files loaded | ~${ctx.budget.used_tokens} tokens used | ${ctx.budget.remaining} remaining` + (toolCount > 0 ? ` | ${toolCount} tools` : "")
+      );
+      for (const warning of ctx.warnings) {
+        log.warn(warning);
+      }
+      if (previousMode !== "active" && hooks.onStateChange) {
+        await hooks.onStateChange({ agent, previous: previousMode, current: "active" });
+      }
+      try {
+        recordBoot(dir);
+      } catch {
+      }
+      if (hooks.onBoot) {
+        await hooks.onBoot({ agent, config, state });
+      }
+    },
+    async run(prompt) {
+      if (!booted) await agent.boot();
+      const guard = checkGuardrails(dir, config);
+      if (!guard.allowed) {
+        const error = new Error(`Guardrail blocked: ${guard.reason}`);
+        try {
+          recordFailure(dir, error.message);
+        } catch {
+        }
+        if (hooks.onError) {
+          try {
+            await hooks.onError({ agent, error, prompt });
+          } catch {
+          }
+        }
+        throw error;
+      }
+      const sessionId = createSessionId();
+      const started = (/* @__PURE__ */ new Date()).toISOString();
+      const hasTools = Object.keys(toolSet).length > 0;
+      let result;
+      try {
+        result = await generate({
+          model,
+          system: systemPrompt,
+          prompt,
+          maxRetries: config.model.max_retries,
+          timeoutMs: config.model.timeout_ms,
+          ...hasTools ? { tools: toolSet, maxToolSteps: options.toolExecutor?.maxToolCalls ?? 5 } : {}
+        });
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        try {
+          recordFailure(dir, error.message);
+        } catch {
+        }
+        if (hooks.onError) {
+          try {
+            await hooks.onError({ agent, error, prompt });
+          } catch {
+          }
+        }
+        throw error;
+      }
+      const ended = (/* @__PURE__ */ new Date()).toISOString();
+      const session = {
+        id: sessionId,
+        started,
+        ended,
+        prompt,
+        summary: result.text.slice(0, 200),
+        tokens_used: result.usage.totalTokens,
+        steps: result.steps,
+        model_id: config.model.id,
+        tool_calls: result.toolCalls.length > 0 ? result.toolCalls : void 0
+      };
+      try {
+        writeSession(dir, session);
+      } catch (err) {
+        log.warn(`Failed to write session ${sessionId}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      try {
+        recordCost(dir, {
+          model_id: config.model.id,
+          provider: config.model.provider ?? "openrouter",
+          input_tokens: result.usage.inputTokens,
+          output_tokens: result.usage.outputTokens,
+          source: `run:${sessionId}`
+        });
+      } catch (err) {
+        log.warn(`Failed to record cost: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      try {
+        recordSuccess(dir);
+      } catch (err) {
+        log.warn(`Failed to record health: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      try {
+        state.last_interaction = ended;
+        saveState(dir, state);
+      } catch (err) {
+        log.warn(`Failed to save state: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      const runResult = {
+        text: result.text,
+        usage: result.usage,
+        session_id: sessionId,
+        steps: result.steps,
+        toolCalls: result.toolCalls
+      };
+      if (hooks.onSessionEnd) {
+        try {
+          await hooks.onSessionEnd({ agent, sessionId, prompt, result: runResult });
+        } catch (err) {
+          log.warn(`onSessionEnd hook error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+      return runResult;
+    },
+    stream(prompt) {
+      const sessionId = createSessionId();
+      let resolveResult;
+      let rejectResult;
+      const resultPromise = new Promise((res, rej) => {
+        resolveResult = res;
+        rejectResult = rej;
+      });
+      resultPromise.catch(() => {
+      });
+      async function* generateStream() {
+        if (!booted) await agent.boot();
+        const guard = checkGuardrails(dir, config);
+        if (!guard.allowed) {
+          const error = new Error(`Guardrail blocked: ${guard.reason}`);
+          try {
+            recordFailure(dir, error.message);
+          } catch {
+          }
+          if (hooks.onError) {
+            try {
+              await hooks.onError({ agent, error, prompt });
+            } catch {
+            }
+          }
+          rejectResult(error);
+          throw error;
+        }
+        const started = (/* @__PURE__ */ new Date()).toISOString();
+        let fullText = "";
+        const hasTools = Object.keys(toolSet).length > 0;
+        let streamResult;
+        try {
+          streamResult = streamGenerateWithDetails({
+            model,
+            system: systemPrompt,
+            prompt,
+            maxRetries: config.model.max_retries,
+            timeoutMs: config.model.timeout_ms,
+            ...hasTools ? { tools: toolSet, maxToolSteps: options.toolExecutor?.maxToolCalls ?? 5 } : {}
+          });
+        } catch (err) {
+          const error = err instanceof Error ? err : new Error(String(err));
+          try {
+            recordFailure(dir, error.message);
+          } catch {
+          }
+          if (hooks.onError) {
+            try {
+              await hooks.onError({ agent, error, prompt });
+            } catch {
+            }
+          }
+          rejectResult(error);
+          throw error;
+        }
+        try {
+          for await (const chunk of streamResult.textStream) {
+            fullText += chunk;
+            yield chunk;
+          }
+        } catch (err) {
+          const error = err instanceof Error ? err : new Error(String(err));
+          try {
+            recordFailure(dir, error.message);
+          } catch {
+          }
+          if (hooks.onError) {
+            try {
+              await hooks.onError({ agent, error, prompt });
+            } catch {
+            }
+          }
+          rejectResult(error);
+          throw error;
+        }
+        let usage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+        let steps = 1;
+        let toolCalls = [];
+        try {
+          [usage, steps, toolCalls] = await Promise.all([
+            streamResult.usage,
+            streamResult.steps,
+            streamResult.toolCalls
+          ]);
+        } catch (err) {
+          log.warn(`Failed to resolve post-stream metadata: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        const ended = (/* @__PURE__ */ new Date()).toISOString();
+        const session = {
+          id: sessionId,
+          started,
+          ended,
+          prompt,
+          summary: fullText.slice(0, 200),
+          tokens_used: usage.totalTokens,
+          steps,
+          model_id: config.model.id,
+          tool_calls: toolCalls.length > 0 ? toolCalls : void 0
+        };
+        try {
+          writeSession(dir, session);
+        } catch (err) {
+          log.warn(`Failed to write session ${sessionId}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        try {
+          recordCost(dir, {
+            model_id: config.model.id,
+            provider: config.model.provider ?? "openrouter",
+            input_tokens: usage.inputTokens,
+            output_tokens: usage.outputTokens,
+            source: `stream:${sessionId}`
+          });
+        } catch (err) {
+          log.warn(`Failed to record cost: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        try {
+          recordSuccess(dir);
+        } catch (err) {
+          log.warn(`Failed to record health: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        try {
+          state.last_interaction = ended;
+          saveState(dir, state);
+        } catch (err) {
+          log.warn(`Failed to save state: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        const runResult = {
+          text: fullText,
+          usage,
+          session_id: sessionId,
+          steps,
+          toolCalls
+        };
+        if (hooks.onSessionEnd) {
+          try {
+            await hooks.onSessionEnd({ agent, sessionId, prompt, result: runResult });
+          } catch (err) {
+            log.warn(`onSessionEnd hook error: ${err instanceof Error ? err.message : String(err)}`);
+          }
+        }
+        resolveResult(runResult);
+      }
+      return {
+        textStream: generateStream(),
+        result: resultPromise
+      };
+    },
+    async shutdown() {
+      if (!booted) return;
+      if (hooks.onShutdown) {
+        try {
+          await hooks.onShutdown({ agent, state });
+        } catch (err) {
+          log.warn(`onShutdown hook error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+      if (mcpManager) {
+        try {
+          await mcpManager.close();
+        } catch (err) {
+          log.warn(`MCP shutdown error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        mcpManager = void 0;
+      }
+      const previousMode = state.mode;
+      state.mode = "idle";
+      try {
+        saveState(dir, state);
+      } catch (err) {
+        log.warn(`Failed to save state during shutdown: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      booted = false;
+      if (previousMode !== "idle" && hooks.onStateChange) {
+        try {
+          await hooks.onStateChange({ agent, previous: previousMode, current: "idle" });
+        } catch (err) {
+          log.warn(`onStateChange hook error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+      log.info(`Shutdown "${config.agent.name}"`);
+    },
+    getSystemPrompt() {
+      return systemPrompt || "";
+    },
+    getState() {
+      return state || loadState(dir);
+    }
+  };
+  return agent;
+}
+
+export {
+  loadConfig,
+  writeDefaultConfig,
+  createLogger,
+  setGlobalLogLevel,
+  getGlobalLogLevel,
+  log,
+  parseHarnessDocument,
+  loadDirectory,
+  loadDirectoryWithErrors,
+  loadAllPrimitives,
+  loadAllPrimitivesWithErrors,
+  estimateTokens,
+  getAtLevel,
+  buildSystemPrompt,
+  tryLock,
+  releaseLock,
+  acquireLock,
+  withFileLock,
+  withFileLockSync,
+  isLocked,
+  breakLock,
+  loadState,
+  saveState,
+  createSessionId,
+  writeSession,
+  archiveOldFiles,
+  cleanupOldFiles,
+  listSessions,
+  listExpiredFiles,
+  loadCosts,
+  saveCosts,
+  findPricing,
+  calculateCost,
+  recordCost,
+  getSpending,
+  checkBudget,
+  clearCosts,
+  loadHealth,
+  saveHealth,
+  recordSuccess,
+  recordFailure,
+  recordBoot,
+  getHealthStatus,
+  resetHealth,
+  loadRateLimits,
+  saveRateLimits,
+  checkRateLimit,
+  recordEvent,
+  tryAcquire,
+  getUsage,
+  clearRateLimits,
+  buildRateLimits,
+  checkGuardrails,
+  parseToolDefinition,
+  loadTools,
+  getToolById,
+  listToolSummaries,
+  checkToolAuth,
+  resolveEndpoint,
+  buildOperationSchema,
+  executeHttpOperation,
+  buildAuthHeaders,
+  convertToolDefinition,
+  buildToolSet,
+  createToolCallTracker,
+  getToolSetSummary,
+  createMcpManager,
+  loadMcpTools,
+  validateMcpConfig,
+  createHarness
+};
+//# sourceMappingURL=chunk-GUJTBGVS.js.map