@rowan-agent/agent 0.4.9 → 0.4.11

package/dist/index.cjs

@@ -1,4474 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/harness/env/path.ts
-var path_exports = {};
-__export(path_exports, {
-  BINARY_WORKSPACE_DIR: () => BINARY_WORKSPACE_DIR,
-  PACKAGED_ENV: () => PACKAGED_ENV,
-  RUNTIME_ENV: () => RUNTIME_ENV,
-  WORKSPACE_ENV: () => WORKSPACE_ENV,
-  detectRuntimeMode: () => detectRuntimeMode,
-  findSourceWorkspaceRoot: () => findSourceWorkspaceRoot,
-  normalizeRelativePath: () => normalizeRelativePath,
-  resolveInWorkspace: () => resolveInWorkspace,
-  resolveProjectRowanDir: () => resolveProjectRowanDir,
-  resolveWorkspacePath: () => resolveWorkspacePath,
-  resolveWorkspacePaths: () => resolveWorkspacePaths,
-  resolveWorkspaceRoot: () => resolveWorkspaceRoot
-});
-function nonEmptyEnv(env, key) {
-  const value = env[key]?.trim();
-  return value ? value : void 0;
-}
-function isTruthyEnvValue(value) {
-  return value === "1" || value?.toLowerCase() === "true" || value?.toLowerCase() === "yes";
-}
-function resolveUserPath(path, homeDir) {
-  if (path === "~") {
-    return homeDir;
-  }
-  if (path.startsWith("~/") || path.startsWith("~\\")) {
-    return (0, import_node_path.join)(homeDir, path.slice(2));
-  }
-  return (0, import_node_path.resolve)(path);
-}
-function isSourceWorkspaceRoot(path) {
-  const packagePath = (0, import_node_path.join)(path, "package.json");
-  if (!(0, import_node_fs.existsSync)(packagePath)) {
-    return false;
-  }
-  try {
-    const manifest = JSON.parse((0, import_node_fs.readFileSync)(packagePath, "utf8"));
-    return manifest.name === "rowan-agent" || Array.isArray(manifest.workspaces);
-  } catch {
-    return false;
-  }
-}
-function findSourceWorkspaceRoot(startDir = process.cwd()) {
-  let current = (0, import_node_path.resolve)(startDir);
-  const { root } = (0, import_node_path.parse)(current);
-  while (true) {
-    if (isSourceWorkspaceRoot(current)) {
-      return current;
-    }
-    if (current === root) {
-      return (0, import_node_path.resolve)(startDir);
-    }
-    current = (0, import_node_path.dirname)(current);
-  }
-}
-function detectRuntimeMode(input = {}) {
-  const env = input.env ?? process.env;
-  const explicitMode = nonEmptyEnv(env, RUNTIME_ENV)?.toLowerCase();
-  if (explicitMode === "source" || explicitMode === "binary") {
-    return explicitMode;
-  }
-  if (isTruthyEnvValue(nonEmptyEnv(env, PACKAGED_ENV))) {
-    return "binary";
-  }
-  const executable = (0, import_node_path.basename)(input.execPath ?? process.execPath).toLowerCase().replace(/\.exe$/, "");
-  return executable === "bun" ? "source" : "binary";
-}
-function defaultWorkspaceStartDir(options) {
-  if (options.cwd) {
-    return options.cwd;
-  }
-  return process.cwd();
-}
-function resolveWorkspaceRoot(options = {}) {
-  const env = options.env ?? process.env;
-  const homeDir = options.homeDir ?? (0, import_node_os.homedir)();
-  const override = nonEmptyEnv(env, WORKSPACE_ENV);
-  if (override) {
-    return resolveUserPath(override, homeDir);
-  }
-  return findSourceWorkspaceRoot(defaultWorkspaceStartDir(options));
-}
-function resolveWorkspacePaths(options = {}) {
-  const mode = options.mode ?? detectRuntimeMode(options);
-  const cwd = resolveWorkspaceRoot({ ...options, mode });
-  return {
-    mode,
-    cwd,
-    rowanDir: resolveProjectRowanDir(cwd, options.rowanDir)
-  };
-}
-function resolveProjectRowanDir(cwd, rowanDir = BINARY_WORKSPACE_DIR) {
-  const inputPath = rowanDir.trim() || BINARY_WORKSPACE_DIR;
-  if ((0, import_node_path.isAbsolute)(inputPath)) {
-    throw new Error(`Project Rowan dir must be a relative path: ${rowanDir}`);
-  }
-  return resolveWorkspacePath({ root: cwd }, inputPath).absolutePath;
-}
-function resolveInWorkspace(path, rootOrPaths) {
-  if (path === "~" || path.startsWith("~/") || path.startsWith("~\\")) {
-    return resolveUserPath(path, (0, import_node_os.homedir)());
-  }
-  if ((0, import_node_path.isAbsolute)(path)) {
-    return path;
-  }
-  const root = typeof rootOrPaths === "string" ? rootOrPaths : rootOrPaths.cwd;
-  return (0, import_node_path.resolve)(root, path);
-}
-function normalizeRelativePath(path) {
-  return path.split(import_node_path.sep).join("/");
-}
-function normalizeWorkspaceInputPath(path = ".") {
-  const trimmed = path.trim();
-  if (!trimmed || trimmed === "/" || trimmed === "\\") {
-    return ".";
-  }
-  return path;
-}
-function resolveWorkspacePath(context, path = ".") {
-  const root = (0, import_node_path.resolve)(context.root);
-  const inputPath = normalizeWorkspaceInputPath(path);
-  const absolutePath = (0, import_node_path.resolve)(root, inputPath);
-  const relativePath = (0, import_node_path.relative)(root, absolutePath);
-  if (relativePath === ".." || relativePath.startsWith(`..${import_node_path.sep}`) || (0, import_node_path.isAbsolute)(relativePath)) {
-    throw new Error(`Path escapes workspace root: ${path}`);
-  }
-  return {
-    root,
-    inputPath,
-    absolutePath,
-    relativePath: normalizeRelativePath(relativePath || ".")
-  };
-}
-var import_node_fs, import_node_os, import_node_path, WORKSPACE_ENV, RUNTIME_ENV, PACKAGED_ENV, BINARY_WORKSPACE_DIR;
-var init_path = __esm({
-  "src/harness/env/path.ts"() {
-    "use strict";
-    import_node_fs = require("fs");
-    import_node_os = require("os");
-    import_node_path = require("path");
-    WORKSPACE_ENV = "ROWAN_WORKSPACE";
-    RUNTIME_ENV = "ROWAN_RUNTIME";
-    PACKAGED_ENV = "ROWAN_PACKAGED";
-    BINARY_WORKSPACE_DIR = ".rowan";
-  }
-});
-
-// src/harness/loader.ts
-function parseFrontmatter(raw) {
-  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
-  if (!match) return { frontmatter: {}, body: raw };
-  const lines = match[1].split("\n");
-  const frontmatter = {};
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    const idx = line.indexOf(":");
-    if (idx === -1) continue;
-    const key = line.slice(0, idx).trim();
-    const value = line.slice(idx + 1).trim();
-    if (!key) continue;
-    if (value === "" && i + 1 < lines.length) {
-      const nested = {};
-      while (i + 1 < lines.length) {
-        const next = lines[i + 1];
-        if (!next.startsWith("  ") || next.trim() === "") break;
-        const nIdx = next.indexOf(":");
-        if (nIdx === -1) break;
-        const nKey = next.slice(0, nIdx).trim();
-        const nValue = next.slice(nIdx + 1).trim();
-        nested[nKey] = nValue;
-        i++;
-      }
-      if (Object.keys(nested).length) {
-        frontmatter[key] = nested;
-      }
-      continue;
-    }
-    frontmatter[key] = parseValue(value);
-  }
-  return { frontmatter, body: raw.slice(match[0].length) };
-}
-function parseValue(value) {
-  const arrayMatch = value.match(/^\[(.*)\]$/);
-  if (arrayMatch) {
-    return arrayMatch[1].split(",").map((s) => s.trim()).filter(Boolean);
-  }
-  if (value.toLowerCase() === "true") return true;
-  if (value.toLowerCase() === "false") return false;
-  if (/^\d+$/.test(value)) return Number(value);
-  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-    return value.slice(1, -1);
-  }
-  return value;
-}
-async function loadMarkdown(filePath) {
-  const raw = await (0, import_promises.readFile)(filePath, "utf8");
-  const { frontmatter, body } = parseFrontmatter(raw);
-  return { frontmatter, body, raw };
-}
-function isExplicitPath(input) {
-  return input.includes("/") || input.includes("\\") || Boolean((0, import_node_path2.extname)(input));
-}
-function inferResourceName(path, markerFile) {
-  const file = (0, import_node_path2.basename)(path);
-  if (file.toLowerCase() === markerFile.toLowerCase()) {
-    return (0, import_node_path2.basename)((0, import_node_path2.dirname)(path));
-  }
-  const extension = (0, import_node_path2.extname)(file);
-  return extension ? file.slice(0, -extension.length) : file;
-}
-function resolveResourcePath(input, resourceType, markerFile, workspace) {
-  const ws = workspace ?? resolveWorkspacePaths();
-  if ((0, import_node_path2.isAbsolute)(input)) {
-    return input;
-  }
-  if (!isExplicitPath(input)) {
-    return (0, import_node_path2.join)(ws.rowanDir, resourceType, input, markerFile);
-  }
-  const workspacePath = resolveInWorkspace(input, ws);
-  if ((0, import_node_fs2.existsSync)(workspacePath)) {
-    return workspacePath;
-  }
-  return (0, import_node_path2.resolve)(input);
-}
-var import_node_fs2, import_promises, import_node_path2;
-var init_loader = __esm({
-  "src/harness/loader.ts"() {
-    "use strict";
-    import_node_fs2 = require("fs");
-    import_promises = require("fs/promises");
-    import_node_path2 = require("path");
-    init_path();
-  }
-});
-
-// src/harness/config.ts
-function interpolateEnvVars(value) {
-  return value.replace(ENV_VAR_PATTERN, (match, varName) => {
-    const resolved = process.env[varName];
-    if (resolved === void 0 || resolved === "") {
-      throw new Error(
-        `Environment variable "${varName}" is not set but is referenced in config.yaml via "${match}".`
-      );
-    }
-    return resolved;
-  });
-}
-async function loadConfigFile(workspace) {
-  let configPath;
-  let configFilename;
-  for (const candidate of CONFIG_CANDIDATES) {
-    const p = (0, import_node_path3.join)(workspace.rowanDir, candidate);
-    if ((0, import_node_fs3.existsSync)(p)) {
-      configPath = p;
-      configFilename = candidate;
-      break;
-    }
-  }
-  if (!configPath || !configFilename) {
-    return void 0;
-  }
-  const raw = await (0, import_promises2.readFile)(configPath, "utf8");
-  let parsed;
-  try {
-    parsed = (0, import_yaml.parse)(raw);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to parse .rowan/${configFilename}: ${message}`);
-  }
-  if (parsed === null || parsed === void 0) {
-    return void 0;
-  }
-  return validateConfigFile(parsed, configFilename);
-}
-function validateConfigFile(parsed, configFilename) {
-  if (typeof parsed !== "object" || parsed === null) {
-    throw new Error(`.rowan/${configFilename} must be a YAML object at the top level.`);
-  }
-  const obj = parsed;
-  const providers = obj.providers;
-  if (!Array.isArray(providers)) {
-    throw new Error(`.rowan/${configFilename} must have a "providers" array.`);
-  }
-  const validatedProviders = providers.map((p, i) => {
-    if (typeof p !== "object" || p === null) {
-      throw new Error(`providers[${i}] must be an object.`);
-    }
-    const provider = p;
-    if (typeof provider.id !== "string" || !provider.id) {
-      throw new Error(`providers[${i}].id is required and must be a non-empty string.`);
-    }
-    if (typeof provider.baseUrl !== "string" || !provider.baseUrl) {
-      throw new Error(`providers[${i}].baseUrl is required and must be a non-empty string.`);
-    }
-    if (typeof provider.apiKey !== "string" || !provider.apiKey) {
-      throw new Error(`providers[${i}].apiKey is required and must be a non-empty string.`);
-    }
-    if (typeof provider.protocol !== "string" || !provider.protocol) {
-      throw new Error(`providers[${i}].protocol is required and must be a non-empty string.`);
-    }
-    if (!Array.isArray(provider.models) || provider.models.length === 0) {
-      throw new Error(`providers[${i}].models must be a non-empty array.`);
-    }
-    const interpolatedApiKey = interpolateEnvVars(provider.apiKey);
-    const validatedModels = provider.models.map((m, j) => {
-      if (typeof m !== "object" || m === null) {
-        throw new Error(`providers[${i}].models[${j}] must be an object.`);
-      }
-      const model = m;
-      if (typeof model.id !== "string" || !model.id) {
-        throw new Error(`providers[${i}].models[${j}].id is required and must be a non-empty string.`);
-      }
-      return model;
-    });
-    return {
-      id: provider.id,
-      baseUrl: provider.baseUrl,
-      apiKey: interpolatedApiKey,
-      protocol: provider.protocol,
-      ...typeof provider.name === "string" ? { name: provider.name } : {},
-      ...typeof provider.timeoutMs === "number" ? { timeoutMs: provider.timeoutMs } : {},
-      ...typeof provider.maxRetries === "number" ? { maxRetries: provider.maxRetries } : {},
-      ...typeof provider.retryDelayMs === "number" ? { retryDelayMs: provider.retryDelayMs } : {},
-      ...provider.headers && typeof provider.headers === "object" ? { headers: provider.headers } : {},
-      models: validatedModels
-    };
-  });
-  const result = { providers: validatedProviders };
-  if (obj.model && typeof obj.model === "object") {
-    const modelRef = obj.model;
-    if (typeof modelRef.provider !== "string" || typeof modelRef.id !== "string") {
-      throw new Error(`.rowan/${configFilename} "model" must have "provider" and "id" string fields.`);
-    }
-    result.model = { provider: modelRef.provider, id: modelRef.id };
-  }
-  if (obj.logLevel !== void 0) {
-    const valid = ["debug", "info", "warn", "error", "silent"];
-    if (typeof obj.logLevel !== "string" || !valid.includes(obj.logLevel)) {
-      throw new Error(`.rowan/${configFilename} "logLevel" must be one of: ${valid.join(", ")}.`);
-    }
-    result.logLevel = obj.logLevel;
-  }
-  return result;
-}
-function resolveDefaultModel(config) {
-  if (config.model) {
-    return { provider: config.model.provider, id: config.model.id };
-  }
-  for (const provider of config.providers) {
-    for (const model of provider.models) {
-      if (model.primary) {
-        return { provider: provider.id, id: model.id };
-      }
-    }
-  }
-  for (const provider of config.providers) {
-    if (provider.models.length > 0) {
-      return { provider: provider.id, id: provider.models[0].id };
-    }
-  }
-  return void 0;
-}
-function registerConfigModels(config) {
-  for (const provider of config.providers) {
-    for (const fileModel of provider.models) {
-      const model = {
-        id: fileModel.id,
-        name: fileModel.name ?? fileModel.id,
-        protocol: provider.protocol,
-        provider: provider.id,
-        baseUrl: provider.baseUrl,
-        reasoning: fileModel.reasoning ?? DEFAULT_REASONING,
-        input: fileModel.input ?? DEFAULT_INPUT,
-        cost: { ...DEFAULT_COST, ...fileModel.cost },
-        contextWindow: fileModel.contextWindow ?? DEFAULT_CONTEXT_WINDOW,
-        maxTokens: fileModel.maxTokens ?? DEFAULT_MAX_TOKENS,
-        apiKey: provider.apiKey,
-        timeoutMs: provider.timeoutMs ?? DEFAULT_TIMEOUT_MS,
-        ...provider.maxRetries !== void 0 ? { maxRetries: provider.maxRetries } : {},
-        ...provider.retryDelayMs !== void 0 ? { retryDelayMs: provider.retryDelayMs } : {},
-        ...provider.headers ? { headers: provider.headers } : {}
-      };
-      (0, import_models.registerModel)(model);
-    }
-  }
-}
-function parseModelRef(input) {
-  if (!input) return void 0;
-  const slashIndex = input.indexOf("/");
-  if (slashIndex === -1) {
-    return { provider: "*", id: input };
-  }
-  return {
-    provider: input.slice(0, slashIndex),
-    id: input.slice(slashIndex + 1)
-  };
-}
-var import_node_fs3, import_promises2, import_node_path3, import_yaml, import_models, DEFAULT_REASONING, DEFAULT_INPUT, DEFAULT_CONTEXT_WINDOW, DEFAULT_MAX_TOKENS, DEFAULT_COST, DEFAULT_TIMEOUT_MS, ENV_VAR_PATTERN, CONFIG_CANDIDATES;
-var init_config = __esm({
-  "src/harness/config.ts"() {
-    "use strict";
-    import_node_fs3 = require("fs");
-    import_promises2 = require("fs/promises");
-    import_node_path3 = require("path");
-    import_yaml = require("yaml");
-    import_models = require("@rowan-agent/models");
-    DEFAULT_REASONING = false;
-    DEFAULT_INPUT = ["text"];
-    DEFAULT_CONTEXT_WINDOW = 128e3;
-    DEFAULT_MAX_TOKENS = 16384;
-    DEFAULT_COST = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
-    DEFAULT_TIMEOUT_MS = 6e4;
-    ENV_VAR_PATTERN = /\$\{([^}]+)\}/g;
-    CONFIG_CANDIDATES = ["config.yaml", "config.yml"];
-  }
-});
-
-// src/harness/context/resource-formatter.ts
-function escapeXml(value) {
-  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
-}
-function buildStructuredSection(tag, items) {
-  const lines = [];
-  for (const item of items) {
-    lines.push(`  <${tag}>`);
-    for (const [key, value] of Object.entries(item)) {
-      lines.push(`    <${key}>${escapeXml(value)}</${key}>`);
-    }
-    lines.push(`  </${tag}>`);
-  }
-  return lines.join("\n");
-}
-function buildSkillsDescription(skills) {
-  const visibleSkills = skills.filter((skill) => !skill.disableModelInvocation);
-  if (visibleSkills.length === 0) return "";
-  const lines = ["<available_skills>"];
-  for (const skill of visibleSkills) {
-    lines.push("  <skill>");
-    lines.push(`    <name>${escapeXml(skill.name)}</name>`);
-    lines.push(`    <description>${escapeXml(skill.description)}</description>`);
-    lines.push(`    <location>${escapeXml(skill.filePath)}</location>`);
-    lines.push("  </skill>");
-  }
-  lines.push("</available_skills>");
-  return lines.join("\n");
-}
-function formatResourceOutput(resource) {
-  const parts = [`<${resource.type} name="${escapeXml(resource.name)}" location="${escapeXml(resource.location)}">`];
-  if (resource.baseDir) {
-    parts.push(`References are relative to ${resource.baseDir}.`);
-    parts.push("");
-  }
-  parts.push(resource.content);
-  parts.push(`</${resource.type}>`);
-  return parts.join("\n");
-}
-function detectResourceType(filePath) {
-  const normalized = filePath.replace(/\\/g, "/");
-  if (normalized.includes("/.rowan/skills/") && normalized.endsWith("/SKILL.md")) return "skill";
-  if (normalized.includes("/.rowan/phases/") && normalized.endsWith("/PHASE.md")) return "phase";
-  if (normalized.endsWith(".md")) return "markdown";
-  if (/\.(ts|js|tsx|jsx|py|rs|go|java|c|cpp|rb|sh|sql|yaml|yml|json|toml)$/.test(normalized)) return "code";
-  return "file";
-}
-function jsonToXml(value, depth) {
-  const indent = "  ".repeat(depth);
-  if (value === null || value === void 0) return "";
-  if (typeof value !== "object") return `${indent}${escapeXml(String(value))}`;
-  if (Array.isArray(value)) {
-    return value.map((item) => {
-      if (typeof item === "object" && item !== null) {
-        return `${indent}<item>
-${jsonToXml(item, depth + 1)}
-${indent}</item>`;
-      }
-      return `${indent}<item>${escapeXml(String(item))}</item>`;
-    }).join("\n");
-  }
-  return Object.entries(value).map(([key, val]) => {
-    const tag = escapeXml(key);
-    if (typeof val === "object" && val !== null) {
-      return `${indent}<${tag}>
-${jsonToXml(val, depth + 1)}
-${indent}</${tag}>`;
-    }
-    return `${indent}<${tag}>${escapeXml(String(val))}</${tag}>`;
-  }).join("\n");
-}
-function buildPhaseDirectiveMessage(phase, output, toolUseId) {
-  const parts = [];
-  parts.push(`<phase name="${escapeXml(phase.name)}">`);
-  parts.push(`  <content>${phase.content}</content>`);
-  if (output.results && output.results.length > 0) {
-    parts.push(`  <prev_phase_outputs>`);
-    if (output.instruction) {
-      parts.push(`    <instruction>${escapeXml(output.instruction)}</instruction>`);
-    }
-    for (const r of output.results) {
-      parts.push(`    <phase name="${escapeXml(r.name)}">`);
-      if (r.output !== void 0) {
-        parts.push(jsonToXml(r.output, 3));
-      }
-      parts.push(`    </phase>`);
-    }
-    parts.push(`  </prev_phase_outputs>`);
-  }
-  parts.push(`</phase>`);
-  return [{
-    type: "tool_result",
-    toolUseId,
-    content: parts.join("\n"),
-    isError: false
-  }];
-}
-var init_resource_formatter = __esm({
-  "src/harness/context/resource-formatter.ts"() {
-    "use strict";
-  }
-});
-
-// src/harness/phases/loader.ts
-var loader_exports = {};
-__export(loader_exports, {
-  loadPhase: () => loadPhase,
-  loadPhases: () => loadPhases,
-  readPhaseContent: () => readPhaseContent,
-  reloadPhases: () => reloadPhases
-});
-async function loadPhase(input, workspace) {
-  const resolved = resolveResourcePath(input, PHASE_DIR, PHASE_MARKER, workspace);
-  const { frontmatter, body } = await loadMarkdown(resolved);
-  const id = inferResourceName(resolved, PHASE_MARKER);
-  if (!frontmatter.name) {
-    throw new Error(`Phase "${id}" at "${resolved}" is missing required field "name" in PHASE.md frontmatter.`);
-  }
-  if (!frontmatter.description) {
-    throw new Error(`Phase "${id}" at "${resolved}" is missing required field "description" in PHASE.md frontmatter.`);
-  }
-  const baseDir = (0, import_node_path4.dirname)(resolved);
-  const phase = {
-    id,
-    name: frontmatter.name,
-    description: frontmatter.description,
-    tools: frontmatter.tools,
-    skills: frontmatter.skills,
-    target: frontmatter.target,
-    input: frontmatter.input,
-    isolated: frontmatter.isolated,
-    filePath: resolved,
-    baseDir,
-    content: body,
-    model: parseModelRef(frontmatter.model)
-  };
-  const codePath = await discoverPhaseCode(baseDir);
-  if (codePath) {
-    const code = await loadPhaseCode(codePath);
-    if (code.factory) {
-      phase.factory = code.factory;
-    } else if (code.run) {
-      phase.run = code.run;
-    }
-  }
-  return phase;
-}
-function readPhaseContent(phase) {
-  return formatResourceOutput({
-    type: "phase",
-    name: phase.name,
-    location: phase.filePath,
-    content: phase.content,
-    baseDir: phase.baseDir
-  });
-}
-async function loadPhases(workspace, paths) {
-  const phases = /* @__PURE__ */ new Map();
-  if (paths && paths.length > 0) {
-    for (const path of paths) {
-      try {
-        const phase = await loadPhase(path, workspace);
-        phases.set(phase.id, phase);
-      } catch (error) {
-        console.warn(`Failed to load phase "${path}":`, error);
-      }
-    }
-    return { phases, entryPhaseId: null };
-  }
-  const ws = workspace ?? (await Promise.resolve().then(() => (init_path(), path_exports))).resolveWorkspacePaths();
-  const phasesDir = (0, import_node_path4.join)(ws.rowanDir, PHASE_DIR);
-  if (!(0, import_node_fs4.existsSync)(phasesDir)) {
-    return { phases, entryPhaseId: null };
-  }
-  const entries = await (0, import_promises3.readdir)(phasesDir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    const phaseFile = (0, import_node_path4.join)(phasesDir, entry.name, PHASE_MARKER);
-    if (!(0, import_node_fs4.existsSync)(phaseFile)) continue;
-    try {
-      const phase = await loadPhase(entry.name, ws);
-      phases.set(phase.id, phase);
-    } catch (error) {
-      console.warn(`Failed to load phase "${entry.name}":`, error);
-    }
-  }
-  return { phases, entryPhaseId: null };
-}
-async function discoverPhaseCode(baseDir) {
-  const candidates = ["index.ts", "index.js"];
-  for (const candidate of candidates) {
-    const fullPath = (0, import_node_path4.join)(baseDir, candidate);
-    if ((0, import_node_fs4.existsSync)(fullPath)) {
-      return fullPath;
-    }
-  }
-  return null;
-}
-async function loadPhaseCode(codePath) {
-  const { createJiti: createJiti2 } = await import("jiti");
-  const jiti = createJiti2(import_meta.url, {
-    moduleCache: false
-  });
-  const mod = await jiti.import(codePath, { default: true });
-  const fn = typeof mod === "function" ? mod : mod?.default;
-  if (typeof fn === "function") {
-    return { factory: fn };
-  }
-  if (typeof mod?.run === "function") {
-    return { run: mod.run };
-  }
-  throw new Error(`Phase code at "${codePath}" must export a default function or a run() function.`);
-}
-async function reloadPhases(registry, workspace) {
-  for (const [id, phase] of registry.phases) {
-    if (!phase.filePath) {
-      continue;
-    }
-    try {
-      const fresh = await loadPhase(phase.filePath, workspace);
-      registry.phases.set(id, fresh);
-    } catch (error) {
-      console.warn(`Failed to reload phase "${id}":`, error);
-    }
-  }
-}
-var import_node_fs4, import_promises3, import_node_path4, import_meta, PHASE_MARKER, PHASE_DIR;
-var init_loader2 = __esm({
-  "src/harness/phases/loader.ts"() {
-    "use strict";
-    import_node_fs4 = require("fs");
-    import_promises3 = require("fs/promises");
-    import_node_path4 = require("path");
-    init_loader();
-    init_config();
-    init_resource_formatter();
-    import_meta = {};
-    PHASE_MARKER = "PHASE.md";
-    PHASE_DIR = "phases";
-  }
-});
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  Agent: () => Agent,
-  AgentEventStream: () => AgentEventStream,
-  EventStream: () => EventStream,
-  ExtensionRunner: () => ExtensionRunner,
-  HooksManager: () => HooksManager,
-  LocalJsonlSessionManager: () => LocalJsonlSessionManager,
-  appendUserTurn: () => appendUserTurn,
-  buildModelRequest: () => buildModelRequest,
-  buildSystemPrompt: () => buildSystemPrompt,
-  conversationMessages: () => conversationMessages,
-  createCoreTools: () => createCoreTools,
-  createEventBus: () => createEventBus,
-  createExtension: () => createExtension,
-  createExtensionAPI: () => createExtensionAPI,
-  createExtensionRunner: () => createExtensionRunner,
-  createExtensionRuntime: () => createExtensionRuntime,
-  createId: () => createId,
-  createMessage: () => createMessage,
-  createSession: () => createSession,
-  createSourceInfo: () => createSourceInfo,
-  createTimestamp: () => createTimestamp,
-  discoverAndLoadExtensions: () => discoverAndLoadExtensions,
-  getGlobalHooks: () => getGlobalHooks,
-  interpolateEnvVars: () => interpolateEnvVars,
-  latestUserInput: () => latestUserInput,
-  loadConfigFile: () => loadConfigFile,
-  loadExtensionFromFactory: () => loadExtensionFromFactory,
-  loadExtensions: () => loadExtensions,
-  loadPhases: () => loadPhases,
-  loadSkill: () => loadSkill,
-  loadSkills: () => loadSkills,
-  messageContentText: () => messageContentText,
-  parseModelRef: () => parseModelRef,
-  registerConfigModels: () => registerConfigModels,
-  resetGlobalHooks: () => resetGlobalHooks,
-  resolveDefaultModel: () => resolveDefaultModel,
-  resolveInWorkspace: () => resolveInWorkspace,
-  resolveSkillPath: () => resolveSkillPath,
-  resolveWorkspacePaths: () => resolveWorkspacePaths,
-  serializeSkills: () => serializeSkills
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/utils.ts
-function createId(prefix) {
-  return `${prefix}_${crypto.randomUUID().slice(0, 8)}`;
-}
-function createTimestamp(date = /* @__PURE__ */ new Date()) {
-  const offset = date.getTimezoneOffset();
-  const local = new Date(date.getTime() - offset * 6e4);
-  const iso = local.toISOString().slice(0, -1);
-  const sign = offset <= 0 ? "+" : "-";
-  const abs = Math.abs(offset);
-  const hh = String(Math.floor(abs / 60)).padStart(2, "0");
-  const mm = String(abs % 60).padStart(2, "0");
-  return `${iso}${sign}${hh}:${mm}`;
-}
-
-// src/loop/errors.ts
-var EmptyResponseError = class extends Error {
-  code = "empty_response";
-  constructor(message = "Model returned an empty response.") {
-    super(message);
-    this.name = "EmptyResponseError";
-  }
-};
-var LoopGuard = {
-  /** Returns abort result if signal is aborted */
-  checkAbort(signal) {
-    if (signal?.aborted) {
-      return { stopReason: "aborted", message: "Agent run aborted." };
-    }
-    return { stopReason: "none" };
-  }
-};
-
-// src/loop/outcomes.ts
-function parseToolResult(content) {
-  try {
-    const parsed = JSON.parse(content);
-    if (typeof parsed.toolCallId === "string" && typeof parsed.toolName === "string" && typeof parsed.ok === "boolean") {
-      return {
-        toolCallId: parsed.toolCallId,
-        toolName: parsed.toolName,
-        ok: parsed.ok,
-        content: parsed.content,
-        ...parsed.error ? { error: parsed.error } : {}
-      };
-    }
-  } catch {
-    return void 0;
-  }
-  return void 0;
-}
-function extractToolResults(transcript) {
-  const results = [];
-  for (const msg of transcript) {
-    if (msg.role !== "tool") continue;
-    if (typeof msg.content === "string") {
-      const result = parseToolResult(msg.content);
-      if (result) {
-        results.push(result);
-      }
-      continue;
-    }
-    for (const part of msg.content) {
-      if (part.type !== "tool_result") continue;
-      const result = parseToolResult(part.content);
-      if (result) {
-        results.push(result);
-      }
-    }
-  }
-  return results;
-}
-var createOutcome = {
-  phaseNotFound(output) {
-    return { id: createId("out"), message: `Phase "${output.phase ?? "Unknown"}" not found.` };
-  },
-  default(output, transcript) {
-    const toolResults = transcript ? extractToolResults(transcript) : [];
-    const message = output.message || output.routeReason || `${output.phase ?? "Unknown"} phase completed.`;
-    const outcome = {
-      id: createId("out"),
-      message
-    };
-    if (toolResults.length > 0) {
-      outcome.toolResults = toolResults;
-    }
-    return outcome;
-  },
-  aborted() {
-    return { id: createId("out"), message: "Agent run aborted." };
-  },
-  error(message) {
-    return { id: createId("out"), message };
-  }
-};
-
-// src/loop/state.ts
-function snapshotMessage(message) {
-  return {
-    ...message,
-    ...message.metadata ? { metadata: { ...message.metadata } } : {}
-  };
-}
-function snapshotMessages(messages) {
-  return messages.map(snapshotMessage);
-}
-
-// src/types.ts
-function createMessage(role, content, metadata) {
-  return {
-    id: createId("msg"),
-    role,
-    content,
-    createdAt: createTimestamp(),
-    ...metadata ? { metadata } : {}
-  };
-}
-function messageContentText(content) {
-  if (typeof content === "string") {
-    return content;
-  }
-  return content.map((part) => {
-    if (part.type === "text") return part.text;
-    if (part.type === "thinking") return part.thinking;
-    if (part.type === "tool_result") return part.content;
-    if (part.type === "tool_use") return JSON.stringify(part.input);
-    if (part.type === "image") return `[image:${part.mimeType}]`;
-    return "";
-  }).filter(Boolean).join("\n");
-}
-function contentBlocksToMessageContent(blocks) {
-  return blocks.map((block) => {
-    if (block.type === "text") {
-      return { type: "text", text: block.text };
-    }
-    if (block.type === "thinking") {
-      return { type: "thinking", thinking: block.thinking };
-    }
-    let input = block.args;
-    try {
-      input = JSON.parse(block.args);
-    } catch {
-    }
-    return { type: "tool_use", id: block.id, name: block.name, input };
-  });
-}
-
-// src/loop/stream-collector.ts
-async function invokeModel(input) {
-  const events = input.config.stream(input.request, { signal: input.config.signal });
-  const result = await collectStreamResult({
-    config: input.config,
-    message: input.message,
-    events,
-    metadataPhase: input.phaseId
-  });
-  const response = result.doneResponse ?? {
-    content: result.text,
-    toolCalls: result.toolCalls.map((tc) => ({
-      id: tc.id,
-      name: tc.name,
-      arguments: tc.args
-    })),
-    stopReason: result.stopReason
-  };
-  return {
-    text: result.text,
-    contentBlocks: result.contentBlocks,
-    toolCalls: result.toolCalls,
-    stopReason: result.stopReason,
-    transcript: {
-      request: input.request,
-      response
-    }
-  };
-}
-async function collectStreamResult(input) {
-  let activeMessageId;
-  let lastPartial;
-  let stopReason;
-  let doneResponse;
-  for await (const event of input.events) {
-    const abortResult = LoopGuard.checkAbort(input.config.signal);
-    if (abortResult.stopReason !== "none") {
-      return { text: abortResult.message, contentBlocks: [], toolCalls: [], stopReason: "aborted" };
-    }
-    if (event.type === "model_requested") {
-      input.config.emit?.({
-        type: "model_requested",
-        model: event.model,
-        usage: event.usage,
-        ts: createTimestamp()
-      });
-    }
-    if (event.type === "error") {
-      throw event.error;
-    }
-    if (event.type === "start") {
-      lastPartial = event.partial;
-    }
-    if (event.type === "text_delta") {
-      lastPartial = event.partial;
-      if (!activeMessageId) {
-        activeMessageId = input.message.start("assistant", event.text, {
-          phase: input.metadataPhase
-        });
-      } else {
-        await input.message.update(activeMessageId, event.text);
-      }
-    }
-    if (event.type === "tool_call_start" || event.type === "tool_call_delta" || event.type === "tool_call_end") {
-      lastPartial = event.partial;
-    }
-    if (event.type === "thinking_delta") {
-      lastPartial = event.partial;
-    }
-    if (event.type === "done") {
-      doneResponse = event.response;
-      stopReason = event.response?.stopReason;
-      const contentBlocks2 = lastPartial?.contentBlocks ?? [];
-      if (!activeMessageId && contentBlocks2.length > 0) {
-        activeMessageId = input.message.start("assistant", "", {
-          phase: input.metadataPhase
-        });
-      }
-      const shouldStoreContentParts = contentBlocks2.some((block) => block.type !== "text");
-      if (activeMessageId && shouldStoreContentParts) {
-        input.message.replaceContent(activeMessageId, contentBlocksToMessageContent(contentBlocks2));
-      }
-      if (activeMessageId) {
-        await input.message.end(activeMessageId);
-        activeMessageId = void 0;
-      }
-    }
-  }
-  if (activeMessageId) {
-    await input.message.end(activeMessageId);
-  }
-  const hasContent = (lastPartial?.contentBlocks?.length ?? 0) > 0 || (doneResponse?.content?.length ?? 0) > 0;
-  if (!hasContent && stopReason !== "error" && stopReason !== "aborted") {
-    throw new EmptyResponseError();
-  }
-  if (doneResponse) {
-    const toolCalls2 = (doneResponse.toolCalls ?? []).map((tc) => ({
-      id: tc.id,
-      name: tc.name,
-      args: tc.arguments
-    }));
-    return {
-      text: doneResponse.content,
-      contentBlocks: lastPartial?.contentBlocks ?? [],
-      toolCalls: toolCalls2,
-      stopReason: doneResponse.stopReason,
-      doneResponse
-    };
-  }
-  const contentBlocks = lastPartial?.contentBlocks ?? [];
-  const text = contentBlocks.filter((b) => b.type === "text").map((b) => b.text).join("");
-  const toolCalls = contentBlocks.filter((b) => b.type === "tool_call").map((b) => {
-    let parsedArgs = b.args;
-    try {
-      parsedArgs = JSON.parse(b.args);
-    } catch {
-    }
-    return { id: b.id, name: b.name, args: parsedArgs };
-  });
-  return { text, contentBlocks, toolCalls, stopReason };
-}
-
-// src/extensions/api.ts
-function createExtensionAPI(hooks, _extensionPath, options, runtime, eventBus) {
-  let idCounter = 0;
-  const createId2 = (prefix) => {
-    idCounter++;
-    return `${prefix}_${Date.now().toString(36)}_${idCounter}`;
-  };
-  const formatJson = (value) => {
-    try {
-      return JSON.stringify(value, null, 2) ?? "undefined";
-    } catch {
-      return "[unserializable]";
-    }
-  };
-  const assertActive = () => runtime?.assertActive?.();
-  const noopContext = {
-    cwd: "",
-    signal: void 0,
-    isIdle: () => false,
-    abort: () => {
-    },
-    exec: async () => ({ exitCode: 1, stdout: "", stderr: "not available" })
-  };
-  const ctx = options?.context ?? noopContext;
-  const phaseIn = options?.phase;
-  let outputPayload = phaseIn?.state?.payload;
-  let nextPhase;
-  let outputMessage;
-  return {
-    on: (eventType, handler) => {
-      assertActive();
-      hooks?.on(eventType, handler);
-    },
-    off: (eventType, handler) => {
-      assertActive();
-      hooks?.off(eventType, handler);
-    },
-    registerTool: (tool) => {
-      assertActive();
-      options?.registerTool?.(tool);
-    },
-    registerPhase: (registration) => {
-      assertActive();
-      options?.registerPhase?.(registration);
-    },
-    registerProvider: (config) => {
-      assertActive();
-      options?.registerProvider?.(config);
-    },
-    unregisterProvider: (name) => {
-      assertActive();
-      options?.unregisterProvider?.(name);
-    },
-    manifest: options?.manifest,
-    utils: {
-      createId: createId2,
-      formatJson
-    },
-    context: ctx,
-    events: eventBus ?? { on: () => () => {
-    }, off: () => {
-    }, emit: () => {
-    }, has: () => false, count: () => 0 },
-    session: {
-      getContext: () => {
-        if (!options?.session) throw new Error("session.getContext() is not available in this context.");
-        return options.session;
-      }
-    },
-    phase: {
-      getPayload: () => outputPayload,
-      setPayload: (p) => {
-        outputPayload = p;
-      },
-      setMessage: (msg) => {
-        outputMessage = msg;
-      },
-      getCurrentPhase: () => phaseIn?.state?.current ?? "",
-      setNextPhase: (id) => {
-        nextPhase = id;
-      },
-      getNextPhase: () => nextPhase,
-      getMessage: () => outputMessage
-    }
-  };
-}
-
-// src/harness/phases/index.ts
-init_loader2();
-
-// src/harness/tools/index.ts
-var import_promises4 = require("fs/promises");
-var import_node_path5 = require("path");
-var import_typebox2 = __toESM(require("typebox"), 1);
-var import_schema = __toESM(require("typebox/schema"), 1);
-init_resource_formatter();
-init_loader();
-init_path();
-
-// src/harness/tools/route-tool.ts
-var import_typebox = __toESM(require("typebox"), 1);
-init_resource_formatter();
-var PhaseRouteTool = "route";
-function buildPhaseEntry(p) {
-  const entry = { id: p.id, description: p.description };
-  if (p.tools && p.tools.length > 0) {
-    entry.available_tools = p.tools.join(", ");
-  }
-  if (p.skills && p.skills.length > 0) {
-    entry.available_skills = p.skills.join(", ");
-  }
-  if (p.input && Object.keys(p.input).length > 0) {
-    entry.required_input = Object.entries(p.input).map(([key, desc]) => `- ${key}: ${desc}`).join("\n");
-  }
-  return entry;
-}
-function buildRouteDescription(availablePhases) {
-  const phasesBlock = buildStructuredSection("phase", [
-    ...availablePhases.map(buildPhaseEntry),
-    { id: "stop", description: "Terminate the workflow and return final result to the user" }
-  ]);
-  return [
-    "Route execution to one or more phases concurrently, or stop execution.",
-    "",
-    "Rules:",
-    "- `decision` lists phase executions; use phase 'stop' to terminate.",
-    "- Each target may include `phase`, `reason`, `payload`.",
-    "- A phase may appear multiple times as independent execution instances.",
-    "- `payload` MUST match the phase's `payload_schema`",
-    "- `instruction` is optional shared guidance for all phases.",
-    "- Executions are independent and concurrent; order is irrelevant.",
-    "",
-    "<available_phases>",
-    phasesBlock,
-    "</available_phases>"
-  ].join("\n");
-}
-function createRouteTool(availablePhases) {
-  const DecisionTarget = import_typebox.default.Object({
-    phase: import_typebox.default.Union([
-      ...availablePhases.map((p) => import_typebox.default.Literal(p.id)),
-      import_typebox.default.Literal("stop")
-    ]),
-    reason: import_typebox.default.Optional(import_typebox.default.String({ description: "Brief reason for this decision" })),
-    payload: import_typebox.default.Optional(import_typebox.default.Unknown({ description: "Structured input for the target phase" }))
-  });
-  return {
-    name: PhaseRouteTool,
-    description: buildRouteDescription(availablePhases),
-    promptSnippet: "Route to next phase on completion.",
-    promptGuidelines: [
-      "Call route immediately when the phase is complete."
-    ],
-    parameters: import_typebox.default.Object({
-      decision: import_typebox.default.Array(DecisionTarget, { description: "Phase executions to start" }),
-      instruction: import_typebox.default.Optional(import_typebox.default.String({ description: "Overall instruction, passed as context" }))
-    }),
-    // No-op: this tool is intercepted by phases, never executed via tool execution
-    execute: async (args, context) => ({
-      toolCallId: context.toolCallId,
-      toolName: PhaseRouteTool,
-      ok: true,
-      content: ""
-    })
-  };
-}
-function extractRouteCall(toolCalls) {
-  const routeCall = toolCalls.find((t) => t.name === PhaseRouteTool);
-  if (!routeCall) return void 0;
-  let args;
-  if (typeof routeCall.args === "string") {
-    try {
-      args = JSON.parse(routeCall.args);
-    } catch {
-      return void 0;
-    }
-  } else {
-    args = routeCall.args;
-  }
-  const decisionRaw = args.decision;
-  let decision = [];
-  if (Array.isArray(decisionRaw)) {
-    decision = decisionRaw.map((d) => {
-      const obj = d;
-      return {
-        phase: typeof obj?.phase === "string" ? obj.phase : "stop",
-        reason: typeof obj?.reason === "string" ? obj.reason : void 0,
-        payload: obj?.payload
-      };
-    });
-  }
-  return {
-    decision,
-    instruction: typeof args.instruction === "string" ? args.instruction : void 0
-  };
-}
-
-// src/harness/tools/index.ts
-var DEFAULT_MAX_READ_BYTES = 64e3;
-var DEFAULT_BASH_TIMEOUT_MS = 3e4;
-var DEFAULT_MAX_BASH_OUTPUT_BYTES = 64e3;
-var ReadArgsSchema = import_typebox2.default.Object({
-  path: import_typebox2.default.String(),
-  maxBytes: import_typebox2.default.Optional(import_typebox2.default.Number()),
-  type: import_typebox2.default.Optional(import_typebox2.default.Union([
-    import_typebox2.default.Literal("skill"),
-    import_typebox2.default.Literal("phase"),
-    import_typebox2.default.Literal("markdown"),
-    import_typebox2.default.Literal("code"),
-    import_typebox2.default.Literal("file")
-  ]))
-});
-var ReadArgsValidator = import_schema.default.Compile(ReadArgsSchema);
-var WriteArgsSchema = import_typebox2.default.Object({
-  path: import_typebox2.default.String(),
-  content: import_typebox2.default.String()
-});
-var WriteArgsValidator = import_schema.default.Compile(WriteArgsSchema);
-var EditArgsSchema = import_typebox2.default.Object({
-  path: import_typebox2.default.String(),
-  oldText: import_typebox2.default.String(),
-  newText: import_typebox2.default.String(),
-  replaceAll: import_typebox2.default.Optional(import_typebox2.default.Boolean())
-});
-var EditArgsValidator = import_schema.default.Compile(EditArgsSchema);
-var BashArgsSchema = import_typebox2.default.Object({
-  command: import_typebox2.default.String(),
-  cwd: import_typebox2.default.Optional(import_typebox2.default.String()),
-  timeoutMs: import_typebox2.default.Optional(import_typebox2.default.Number()),
-  maxOutputBytes: import_typebox2.default.Optional(import_typebox2.default.Number())
-});
-var BashArgsValidator = import_schema.default.Compile(BashArgsSchema);
-var validatorCache = /* @__PURE__ */ new WeakMap();
-function validatorFor(schema) {
-  const cached = validatorCache.get(schema);
-  if (cached) {
-    return cached;
-  }
-  const validator = import_schema.default.Compile(schema);
-  validatorCache.set(schema, validator);
-  return validator;
-}
-function normalizeCoreToolInputPath(path = ".") {
-  const trimmed = path.trim();
-  if (!trimmed || trimmed === "/" || trimmed === "\\") {
-    return ".";
-  }
-  return path;
-}
-function createCoreToolContext(input = {}) {
-  return {
-    root: (0, import_node_path5.resolve)(input.root ?? process.cwd()),
-    maxReadBytes: input.maxReadBytes ?? DEFAULT_MAX_READ_BYTES,
-    bashTimeoutMs: input.bashTimeoutMs ?? DEFAULT_BASH_TIMEOUT_MS,
-    maxBashOutputBytes: input.maxBashOutputBytes ?? DEFAULT_MAX_BASH_OUTPUT_BYTES
-  };
-}
-function resolveCoreToolPath(context, path = ".") {
-  const root = (0, import_node_path5.resolve)(context.root);
-  const inputPath = normalizeCoreToolInputPath(path);
-  const absolutePath = (0, import_node_path5.resolve)(root, inputPath);
-  const relativePath = (0, import_node_path5.relative)(root, absolutePath);
-  if (relativePath === ".." || relativePath.startsWith(`..${import_node_path5.sep}`) || (0, import_node_path5.isAbsolute)(relativePath)) {
-    throw new Error(`Path escapes workspace root: ${path}`);
-  }
-  return {
-    root,
-    inputPath,
-    absolutePath,
-    relativePath: normalizeRelativePath(relativePath || ".")
-  };
-}
-function toolResult(input) {
-  return {
-    toolCallId: input.context.toolCallId,
-    toolName: input.toolName,
-    ok: input.ok,
-    content: input.content,
-    ...input.error ? { error: input.error } : {}
-  };
-}
-async function executeRuntimeToolCall(input) {
-  const tool = input.tools.find((candidate) => candidate.name === input.toolCall.name);
-  if (!tool) {
-    const result = toolResult({
-      context: input.toolContext,
-      toolName: input.toolCall.name,
-      ok: false,
-      content: null,
-      error: `Unknown tool: ${input.toolCall.name}`
-    });
-    await input.observe?.({ type: "tool_end", toolName: input.toolCall.name, result });
-    return result;
-  }
-  let args;
-  try {
-    args = validatorFor(tool.parameters).Parse(input.toolCall.args);
-  } catch (error) {
-    const result = toolResult({
-      context: input.toolContext,
-      toolName: tool.name,
-      ok: false,
-      content: null,
-      error: error instanceof Error ? error.message : String(error)
-    });
-    await input.observe?.({ type: "tool_end", toolName: tool.name, result });
-    return result;
-  }
-  let decision;
-  if (input.beforeToolCall) {
-    await input.observe?.({ type: "approval_requested", tool, args });
-    decision = await input.beforeToolCall({ tool, args });
-    await input.observe?.({
-      type: "approval_result",
-      tool,
-      args,
-      decision: decision ?? { allow: true }
-    });
-  }
-  if (decision && !decision.allow) {
-    const result = toolResult({
-      context: input.toolContext,
-      toolName: tool.name,
-      ok: false,
-      content: null,
-      error: decision.reason
-    });
-    await input.observe?.({ type: "tool_blocked", tool, reason: decision.reason });
-    return result;
-  }
-  await input.observe?.({ type: "tool_start", tool, args });
-  try {
-    const rawResult = await tool.execute(args, input.toolContext, input.signal);
-    let result = {
-      ...rawResult,
-      toolCallId: input.toolCall.id,
-      toolName: tool.name
-    };
-    if (input.afterToolCall) {
-      await input.observe?.({
-        type: "result_review_requested",
-        tool,
-        result
-      });
-      result = await input.afterToolCall({ tool, result });
-      await input.observe?.({
-        type: "result_review_result",
-        tool,
-        result
-      });
-    }
-    await input.observe?.({ type: "tool_end", toolName: tool.name, result });
-    return result;
-  } catch (error) {
-    const result = toolResult({
-      context: input.toolContext,
-      toolName: tool.name,
-      ok: false,
-      content: null,
-      error: error instanceof Error ? error.message : "Tool execution failed."
-    });
-    await input.observe?.({ type: "tool_end", toolName: tool.name, result });
-    return result;
-  }
-}
-function positiveNumber(value, name) {
-  if (!Number.isFinite(value) || value <= 0) {
-    return `${name} must be a positive number.`;
-  }
-  return void 0;
-}
-async function captureStream(stream, maxBytes) {
-  const reader = stream.getReader();
-  const chunks = [];
-  let totalBytes = 0;
-  let truncated = false;
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) {
-      break;
-    }
-    if (!value) {
-      continue;
-    }
-    const remainingBytes = maxBytes - totalBytes;
-    if (remainingBytes > 0) {
-      const kept = value.subarray(0, remainingBytes);
-      chunks.push(kept);
-      totalBytes += kept.byteLength;
-    }
-    if (value.byteLength > remainingBytes || totalBytes >= maxBytes) {
-      truncated = true;
-      await reader.cancel().catch(() => void 0);
-      break;
-    }
-  }
-  const bytes = new Uint8Array(totalBytes);
-  let offset = 0;
-  for (const chunk of chunks) {
-    bytes.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return {
-    text: new TextDecoder().decode(bytes),
-    truncated
-  };
-}
-function createReadTool(context) {
-  return {
-    name: "read",
-    description: "Reads a text file within the workspace.",
-    parameters: ReadArgsSchema,
-    promptSnippet: "Read a text file (max 64KB default).",
-    promptGuidelines: [
-      "Always read a file before editing or writing to understand its current content.",
-      "Use maxBytes to limit output for large files."
-    ],
-    async execute(args, toolContext) {
-      const parsed = ReadArgsValidator.Parse(args);
-      const resolved = resolveCoreToolPath(context, parsed.path);
-      const maxBytes = parsed.maxBytes ?? context.maxReadBytes;
-      const invalidLimit = positiveNumber(maxBytes, "maxBytes");
-      if (invalidLimit) {
-        return toolResult({
-          context: toolContext,
-          toolName: "read",
-          ok: false,
-          content: null,
-          error: invalidLimit
-        });
-      }
-      const fileStat = await (0, import_promises4.stat)(resolved.absolutePath);
-      if (!fileStat.isFile()) {
-        return toolResult({
-          context: toolContext,
-          toolName: "read",
-          ok: false,
-          content: null,
-          error: `Not a file: ${resolved.relativePath}`
-        });
-      }
-      const bytes = await (0, import_promises4.readFile)(resolved.absolutePath);
-      const sliced = bytes.subarray(0, maxBytes);
-      const text = new TextDecoder().decode(sliced);
-      const resourceType = parsed.type ?? detectResourceType(resolved.absolutePath);
-      let name;
-      let baseDir;
-      if (resourceType === "skill" || resourceType === "phase") {
-        const { frontmatter } = parseFrontmatter(text);
-        const marker = resourceType === "skill" ? "SKILL.md" : "PHASE.md";
-        name = frontmatter.name ?? inferResourceName(resolved.absolutePath, marker);
-        baseDir = (0, import_node_path5.dirname)(resolved.absolutePath);
-      } else {
-        name = inferResourceName(resolved.absolutePath, (0, import_node_path5.basename)(resolved.absolutePath));
-      }
-      return toolResult({
-        context: toolContext,
-        toolName: "read",
-        ok: true,
-        content: {
-          path: resolved.relativePath,
-          content: formatResourceOutput({ type: resourceType, name, location: resolved.absolutePath, content: text, baseDir }),
-          sizeBytes: bytes.byteLength,
-          truncated: bytes.byteLength > maxBytes
-        }
-      });
-    }
-  };
-}
-function createWriteTool(context) {
-  return {
-    name: "write",
-    description: "Writes provided text content to a workspace file, creating parent directories as needed.",
-    parameters: WriteArgsSchema,
-    promptSnippet: "Write content to a file (creates parent dirs automatically).",
-    promptGuidelines: [
-      "Use write for new files or full file rewrites.",
-      "For partial edits, prefer the edit tool to avoid overwriting unchanged content."
-    ],
-    async execute(args, toolContext) {
-      const parsed = WriteArgsValidator.Parse(args);
-      const resolved = resolveCoreToolPath(context, parsed.path);
-      await (0, import_promises4.mkdir)((0, import_node_path5.dirname)(resolved.absolutePath), { recursive: true });
-      await (0, import_promises4.writeFile)(resolved.absolutePath, parsed.content, "utf8");
-      return toolResult({
-        context: toolContext,
-        toolName: "write",
-        ok: true,
-        content: {
-          path: resolved.relativePath,
-          bytesWritten: new TextEncoder().encode(parsed.content).byteLength
-        }
-      });
-    }
-  };
-}
-function createEditTool(context) {
-  return {
-    name: "edit",
-    description: "Edits a workspace text file by replacing exact oldText with newText.",
-    parameters: EditArgsSchema,
-    promptSnippet: "Replace exact text in a file (oldText \u2192 newText).",
-    promptGuidelines: [
-      "Read the file first to get the exact oldText to replace.",
-      "oldText must be an exact match including whitespace and indentation.",
-      "If oldText appears multiple times, set replaceAll=true or provide more surrounding context."
-    ],
-    async execute(args, toolContext) {
-      const parsed = EditArgsValidator.Parse(args);
-      if (!parsed.oldText) {
-        return toolResult({
-          context: toolContext,
-          toolName: "edit",
-          ok: false,
-          content: null,
-          error: "oldText must not be empty."
-        });
-      }
-      const resolved = resolveCoreToolPath(context, parsed.path);
-      const current = await (0, import_promises4.readFile)(resolved.absolutePath, "utf8");
-      if (!current.includes(parsed.oldText)) {
-        return toolResult({
-          context: toolContext,
-          toolName: "edit",
-          ok: false,
-          content: null,
-          error: `oldText not found in ${resolved.relativePath}.`
-        });
-      }
-      const matches = current.split(parsed.oldText).length - 1;
-      if (matches > 1 && !parsed.replaceAll) {
-        return toolResult({
-          context: toolContext,
-          toolName: "edit",
-          ok: false,
-          content: null,
-          error: `oldText appears ${matches} times in ${resolved.relativePath}; set replaceAll=true or provide more context.`
-        });
-      }
-      const replacements = parsed.replaceAll ? matches : 1;
-      const next = parsed.replaceAll ? current.split(parsed.oldText).join(parsed.newText) : current.replace(parsed.oldText, parsed.newText);
-      await (0, import_promises4.writeFile)(resolved.absolutePath, next, "utf8");
-      return toolResult({
-        context: toolContext,
-        toolName: "edit",
-        ok: true,
-        content: {
-          path: resolved.relativePath,
-          replacements,
-          bytesWritten: new TextEncoder().encode(next).byteLength
-        }
-      });
-    }
-  };
-}
-function createBashTool(context) {
-  return {
-    name: "bash",
-    description: "Runs a bash command within the workspace.",
-    parameters: BashArgsSchema,
-    promptSnippet: "Execute a bash command (30s timeout, 64KB output limit).",
-    promptGuidelines: [
-      "Use bash for build commands, tests, git operations, and system tools.",
-      "Prefer dedicated tools (read/write/edit) for file operations.",
-      "Set timeoutMs for long-running commands."
-    ],
-    async execute(args, toolContext, signal) {
-      const parsed = BashArgsValidator.Parse(args);
-      const timeoutMs = parsed.timeoutMs ?? context.bashTimeoutMs;
-      const maxOutputBytes = parsed.maxOutputBytes ?? context.maxBashOutputBytes;
-      const invalidTimeout = positiveNumber(timeoutMs, "timeoutMs");
-      const invalidOutputLimit = positiveNumber(maxOutputBytes, "maxOutputBytes");
-      if (invalidTimeout || invalidOutputLimit) {
-        return toolResult({
-          context: toolContext,
-          toolName: "bash",
-          ok: false,
-          content: null,
-          error: invalidTimeout ?? invalidOutputLimit
-        });
-      }
-      const cwd = resolveCoreToolPath(context, parsed.cwd ?? ".");
-      let timedOut = false;
-      let aborted = false;
-      const proc = Bun.spawn(["bash", "-lc", parsed.command], {
-        cwd: cwd.absolutePath,
-        stdout: "pipe",
-        stderr: "pipe"
-      });
-      const kill = () => {
-        proc.kill();
-      };
-      const timeout = setTimeout(() => {
-        timedOut = true;
-        kill();
-      }, timeoutMs);
-      const onAbort = () => {
-        aborted = true;
-        kill();
-      };
-      signal?.addEventListener("abort", onAbort, { once: true });
-      try {
-        const [stdout, stderr, exitCode] = await Promise.all([
-          captureStream(proc.stdout, maxOutputBytes),
-          captureStream(proc.stderr, maxOutputBytes),
-          proc.exited
-        ]);
-        const ok = exitCode === 0 && !timedOut && !aborted;
-        return toolResult({
-          context: toolContext,
-          toolName: "bash",
-          ok,
-          content: {
-            command: parsed.command,
-            cwd: cwd.relativePath,
-            exitCode,
-            stdout: stdout.text,
-            stderr: stderr.text,
-            stdoutTruncated: stdout.truncated,
-            stderrTruncated: stderr.truncated
-          },
-          ...ok ? {} : {
-            error: timedOut ? `Command timed out after ${timeoutMs}ms.` : aborted ? "Command aborted." : `Command exited with ${exitCode}.`
-          }
-        });
-      } finally {
-        clearTimeout(timeout);
-        signal?.removeEventListener("abort", onAbort);
-      }
-    }
-  };
-}
-function createCoreTools(input = {}) {
-  const context = createCoreToolContext(input);
-  return [
-    createReadTool(context),
-    createWriteTool(context),
-    createEditTool(context),
-    createBashTool(context)
-  ];
-}
-
-// src/harness/context/system-prompt.ts
-init_resource_formatter();
-function buildSystemPrompt(options) {
-  const { systemPrompt, promptGuidelines, appendSystemPrompt, tools, skills, cwd } = options;
-  const date = createTimestamp();
-  const guidelinesList = [];
-  const guidelinesSet = /* @__PURE__ */ new Set();
-  const addGuideline = (guideline) => {
-    const normalized = guideline.trim();
-    if (normalized.length === 0 || guidelinesSet.has(normalized)) return;
-    guidelinesSet.add(normalized);
-    guidelinesList.push(normalized);
-  };
-  const visibleTools = (tools ?? []).filter((t) => !!t.promptSnippet);
-  const toolsList = visibleTools.length > 0 ? visibleTools.map((t) => `- ${t.name}: ${t.promptSnippet}`).join("\n") : "(none)";
-  for (const tool of tools ?? []) {
-    for (const g of tool.promptGuidelines ?? []) {
-      addGuideline(g);
-    }
-  }
-  const skillsBlock = skills && skills.length > 0 ? buildSkillsDescription(skills) : "";
-  for (const g of promptGuidelines ?? []) {
-    addGuideline(g);
-  }
-  const guidelines = guidelinesList.map((g) => `- ${g}`).join("\n");
-  const skillsSection = skillsBlock ? `The following skills provide specialized instructions for specific tasks.
-Read the full skill file when the task matches its description.
-When a skill file references a relative path, resolve it against the skill directory (parent of SKILL.md) and use that absolute path in tool commands.
-
-${skillsBlock}
-` : "";
-  let prompt = `${systemPrompt}
-
-**Important:** Tool and skill availability varies by phase. Only use tools that are available in your current phase context.
-
-Available tools:
-${toolsList}
-
-${skillsSection}
-Guidelines:
-${guidelines}`;
-  if (date || cwd) {
-    const contextParts = [];
-    if (date) contextParts.push(`Current date: ${date}`);
-    if (cwd) contextParts.push(`Working directory: ${cwd}`);
-    prompt += `
-
-${contextParts.join("\n")}`;
-  }
-  if (appendSystemPrompt) {
-    prompt += `
-
-${appendSystemPrompt}`;
-  }
-  return prompt;
-}
-
-// src/harness/context/prompt-builder.ts
-function serializeSkills(skills) {
-  return skills.map((skill) => ({
-    name: skill.name,
-    description: skill.description,
-    filePath: skill.filePath,
-    disableModelInvocation: skill.disableModelInvocation
-  }));
-}
-function latestUserInput(messages) {
-  for (let index = messages.length - 1; index >= 0; index -= 1) {
-    const message = messages[index];
-    if (message.role === "user") {
-      return messageContentText(message.content);
-    }
-  }
-  return "";
-}
-function conversationMessages(messages) {
-  return messages.flatMap((message) => {
-    if (message.role === "user") {
-      return [{ role: "user", content: message.content }];
-    }
-    if (message.role === "assistant") {
-      return [{ role: "assistant", content: message.content }];
-    }
-    if (message.role === "tool") {
-      return [{ role: "tool", content: message.content }];
-    }
-    return [];
-  });
-}
-function buildModelRequest(input, options) {
-  const toolMeta = input.tools.map((t) => ({
-    name: t.name,
-    description: t.description,
-    promptSnippet: t.promptSnippet,
-    promptGuidelines: t.promptGuidelines
-  }));
-  let systemText = buildSystemPrompt({
-    systemPrompt: input.systemPrompt,
-    tools: toolMeta,
-    skills: input.skills.length > 0 ? serializeSkills(input.skills) : void 0,
-    promptGuidelines: input.promptGuidelines,
-    appendSystemPrompt: input.appendSystemPrompt
-  });
-  const messages = [...conversationMessages(input.messages)];
-  const modelTools = input.tools.map((t) => ({
-    name: t.name,
-    description: t.description,
-    parameters: t.parameters
-  }));
-  return {
-    model: options?.model ?? { provider: "", id: "" },
-    system: systemText,
-    messages,
-    tools: modelTools.length > 0 ? modelTools : void 0
-  };
-}
-
-// src/harness/context/compaction.ts
-function needsCompaction(messages, options = {}) {
-  const maxMessages = options.maxMessages ?? 50;
-  return messages.length > maxMessages;
-}
-function buildSummary(messages) {
-  const parts = [];
-  let currentRole;
-  let currentContent = [];
-  function flush() {
-    if (currentRole && currentContent.length > 0) {
-      const combined = currentContent.join("\n");
-      const truncated = combined.length > 500 ? combined.slice(0, 500) + "..." : combined;
-      parts.push(`[${currentRole}]: ${truncated}`);
-    }
-    currentContent = [];
-  }
-  for (const msg of messages) {
-    if (msg.role !== currentRole) {
-      flush();
-      currentRole = msg.role;
-    }
-    currentContent.push(messageContentText(msg.content));
-  }
-  flush();
-  return parts.join("\n\n");
-}
-function compactMessages(messages, options = {}) {
-  if (!needsCompaction(messages, options)) {
-    return { compacted: false, messages };
-  }
-  const keepRecent = options.keepRecent ?? 10;
-  const minCompact = options.minCompact ?? 20;
-  const firstUserIdx = messages.findIndex(
-    (m) => m.role === "user"
-  );
-  const recentStart = Math.max(messages.length - keepRecent, firstUserIdx + 1);
-  const oldMessages = messages.slice(firstUserIdx >= 0 ? firstUserIdx + 1 : 0, recentStart);
-  if (oldMessages.length < minCompact) {
-    return { compacted: false, messages };
-  }
-  const recentMessages = messages.slice(recentStart);
-  const summary = buildSummary(oldMessages);
-  const result = [];
-  if (firstUserIdx >= 0) {
-    result.push(messages[firstUserIdx]);
-  }
-  result.push(
-    createMessage("assistant", `[Context compaction summary]
-
-${summary}`, {
-      type: "compaction_summary",
-      compactedCount: oldMessages.length
-    })
-  );
-  result.push(...recentMessages);
-  return {
-    compacted: true,
-    messages: result,
-    summarizedCount: oldMessages.length,
-    summary
-  };
-}
-
-// src/loop/runners.ts
-init_resource_formatter();
-function resolvePhaseOutput(result) {
-  return result ? { ...result } : { message: "Phase completed.", route: "stop" };
-}
-function removePhaseMessage(messages, msgId) {
-  if (!msgId) return;
-  const idx = messages.findIndex((m) => m.id === msgId);
-  if (idx !== -1) messages.splice(idx, 1);
-}
-function normalizePayload(payload) {
-  if (typeof payload === "string") {
-    try {
-      return JSON.parse(payload);
-    } catch {
-    }
-  }
-  return payload;
-}
-function applyFirstDecision(route, output) {
-  const first = route.decision[0];
-  if (!first) return;
-  output.route = first.phase;
-  if (first.reason) output.routeReason = first.reason;
-  if (first.payload !== void 0) output.payload = normalizePayload(first.payload);
-}
-function injectPhaseContent(phase, output, messageManager) {
-  try {
-    const phaseContent = phase.filePath ? readPhaseContent(phase) : phase.content ?? phase.description ?? "";
-    const content = buildPhaseDirectiveMessage(
-      { name: phase.id, content: phaseContent },
-      output,
-      `phase_${phase.id}`
-    );
-    const msgId = messageManager.start("tool", content, { phase: phase.id });
-    messageManager.end(msgId);
-    return msgId;
-  } catch {
-    return void 0;
-  }
-}
-function buildInstanceIds(phases) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const p of phases) {
-    counts.set(p, (counts.get(p) ?? 0) + 1);
-  }
-  const hasDupes = [...counts.values()].some((c) => c > 1);
-  if (!hasDupes) return phases;
-  const idx = /* @__PURE__ */ new Map();
-  return phases.map((p) => {
-    const n = (idx.get(p) ?? 0) + 1;
-    idx.set(p, n);
-    return `${p}#${n}`;
-  });
-}
-function emitTurn(context, emitFn, type, extra) {
-  emitFn?.({
-    type,
-    content: snapshotMessages(context.messages),
-    ...extra,
-    ts: createTimestamp()
-  });
-}
-function createRunResult(config, state, outcome) {
-  return {
-    sessionId: config.sessionId,
-    messages: snapshotMessages(config.context.messages),
-    outcome,
-    metrics: state.metrics
-  };
-}
-async function completeRun(config, state, outcome) {
-  state.metrics.endedAt = createTimestamp();
-  state.metrics.durationMs = Date.now() - state.metrics.startedAtMs;
-  await config.onOutcome?.(outcome);
-  return createRunResult(config, state, outcome);
-}
-function buildToolsWithRouting(config, availablePhases) {
-  const tools = [...config.context.tools];
-  if (availablePhases.length > 0) {
-    tools.push(createRouteTool(availablePhases));
-  }
-  return tools;
-}
-function createMessageManager(context, emitFn, onMessage) {
-  const activeMessages = /* @__PURE__ */ new Map();
-  return {
-    visible: () => [...context.messages],
-    start(role, content, metadata) {
-      const msg = createMessage(role, content, metadata);
-      activeMessages.set(msg.id, msg);
-      emitFn?.({ type: "message_start", message: snapshotMessage(msg), ts: createTimestamp() });
-      return msg.id;
-    },
-    async update(messageId, delta) {
-      const msg = activeMessages.get(messageId);
-      if (!msg) return;
-      msg.content = typeof msg.content === "string" ? msg.content + delta : [...msg.content, { type: "text", text: delta }];
-      emitFn?.({ type: "message_update", message: snapshotMessage(msg), delta, ts: createTimestamp() });
-    },
-    replaceContent(messageId, content) {
-      const msg = activeMessages.get(messageId);
-      if (!msg) return;
-      msg.content = content;
-    },
-    async end(messageId) {
-      const msg = activeMessages.get(messageId);
-      if (!msg) return;
-      activeMessages.delete(messageId);
-      context.messages.push(msg);
-      emitFn?.({ type: "message_end", message: snapshotMessage(msg), ts: createTimestamp() });
-      await onMessage?.(msg);
-    }
-  };
-}
-function createToolExecutionManager(emitFn) {
-  return {
-    async start(toolCallId, toolName, args) {
-      emitFn?.({ type: "tool_execution_start", toolCallId, toolName, args, ts: createTimestamp() });
-    },
-    async end(toolCallId, toolName, result, isError) {
-      emitFn?.({ type: "tool_execution_end", toolCallId, toolName, result, isError, ts: createTimestamp() });
-    }
-  };
-}
-function createToolResultContent(result) {
-  return [
-    {
-      type: "tool_result",
-      toolUseId: result.toolCallId,
-      content: JSON.stringify(result),
-      isError: !result.ok
-    }
-  ];
-}
-async function executePhaseWithModel(ctx) {
-  const executableToolNames = new Set(
-    ctx.context.tools.filter((tool) => tool.name !== PhaseRouteTool).map((tool) => tool.name)
-  );
-  let output = {
-    message: "",
-    route: "stop",
-    phase: ctx.phase.name,
-    toolCalls: []
-  };
-  while (true) {
-    const roundContext = {
-      ...ctx.context,
-      messages: ctx.messageManager.visible()
-    };
-    const collected = await ctx.execution.invokeModel(roundContext);
-    output = {
-      message: collected.text,
-      route: "stop",
-      phase: ctx.phase.name,
-      toolCalls: collected.toolCalls
-    };
-    const executableToolCalls = collected.toolCalls.filter(
-      (toolCall) => executableToolNames.has(toolCall.name)
-    );
-    if (executableToolCalls.length === 0) {
-      return output;
-    }
-    for (const toolCall of executableToolCalls) {
-      const result = await ctx.execution.executeTool(roundContext, toolCall);
-      const messageId = ctx.messageManager.start("tool", createToolResultContent(result), {
-        phase: ctx.phase.id
-      });
-      await ctx.messageManager.end(messageId);
-    }
-  }
-}
-async function runTurn(context, emitFn, fn) {
-  emitTurn(context, emitFn, "turn_start");
-  try {
-    return await fn();
-  } finally {
-    emitTurn(context, emitFn, "turn_end");
-  }
-}
-async function startPhaseLoop(config, state) {
-  const entryPhaseId = config.phases?.entryPhaseId ?? "default";
-  const phases = /* @__PURE__ */ new Map();
-  phases.set("default", {
-    id: "default",
-    name: "Execution Phase",
-    description: "Executes concrete task operations and produces artifacts.",
-    filePath: "",
-    baseDir: "",
-    content: "Execute tasks using current context.\nNo planning. No evaluation.\nRoute to next phase or stop when done."
-  });
-  if (config.phases) {
-    for (const [id, phase] of config.phases.phases) {
-      phases.set(id, phase);
-    }
-  }
-  const registry = {
-    phases,
-    entryPhaseId
-  };
-  return runPhaseLoop(config, state, registry);
-}
-async function runPhaseLoop(config, state, registry) {
-  let currentPhaseId = registry.entryPhaseId;
-  let isContinuing = false;
-  let previousPayload = void 0;
-  let previousPhaseMsgId = void 0;
-  let previousResults = [];
-  let pendingInstruction = void 0;
-  while (currentPhaseId) {
-    await reloadPhases(registry);
-    if (config.phases) {
-      config.phases.phases = registry.phases;
-    }
-    const availablePhases = [];
-    for (const [, phase2] of registry.phases) {
-      availablePhases.push({ id: phase2.id, name: phase2.name, description: phase2.description, tools: phase2.tools, skills: phase2.skills, input: phase2.input, isolated: phase2.isolated });
-    }
-    const abortResult = LoopGuard.checkAbort(config.signal);
-    if (abortResult.stopReason !== "none") {
-      return completeRun(config, state, createOutcome.aborted());
-    }
-    state.metrics.iterations++;
-    if (needsCompaction(config.context.messages)) {
-      const compacted = compactMessages(config.context.messages);
-      if (compacted.compacted) {
-        config.context.messages = compacted.messages;
-        state.metrics.compactionCount++;
-        config.emit?.({
-          type: "message_start",
-          message: {
-            id: "compaction",
-            role: "assistant",
-            content: `[Compacted ${compacted.summarizedCount} older messages to stay within context limits]`,
-            createdAt: createTimestamp(),
-            metadata: { type: "compaction_notice" }
-          },
-          ts: createTimestamp()
-        });
-      }
-    }
-    const phase = registry.phases.get(currentPhaseId);
-    if (!phase) {
-      throw new Error(`Phase "${currentPhaseId}" not found`);
-    }
-    state.currentPhase = currentPhaseId;
-    const allTools = buildToolsWithRouting(config, availablePhases);
-    const messageManager = createMessageManager(config.context, config.emit, config.onMessage);
-    const toolExecutionManager = createToolExecutionManager(config.emit);
-    const execution = createPhaseExecution(config, state, allTools, phase, messageManager, toolExecutionManager, registry);
-    const phaseTools = phase.tools ? allTools.filter((t) => t.name === PhaseRouteTool || phase.tools.includes(t.name)) : allTools;
-    const phaseSkills = phase.skills ? config.context.skills.filter((s) => phase.skills.includes(s.name)) : config.context.skills;
-    let phaseContext = {
-      systemPrompt: config.context.systemPrompt,
-      messages: messageManager.visible(),
-      tools: phaseTools,
-      skills: phaseSkills,
-      state: {
-        current: currentPhaseId,
-        available: Array.from(registry.phases.keys()),
-        iterations: state.metrics.iterations,
-        payload: previousPayload
-      }
-    };
-    const enteringNewPhase = !isContinuing;
-    if (enteringNewPhase) {
-      config.emit?.({ type: "phase_start", phase: currentPhaseId, ts: createTimestamp() });
-    }
-    isContinuing = false;
-    if (config.beforePhase) {
-      const extBefore = await config.beforePhase(currentPhaseId, phaseContext);
-      if (extBefore.abort) {
-        config.emit?.({ type: "phase_end", phase: currentPhaseId, ts: createTimestamp() });
-        return completeRun(config, state, extBefore.abort);
-      }
-      if (extBefore.skip) {
-        config.emit?.({ type: "phase_end", phase: currentPhaseId, ts: createTimestamp() });
-        if (extBefore.skip.route === "stop") {
-          return completeRun(config, state, {
-            id: "skip",
-            message: extBefore.skip.message || "Skipped."
-          });
-        }
-        currentPhaseId = extBefore.skip.route;
-        continue;
-      }
-      if (extBefore.input) {
-        phaseContext = extBefore.input;
-      }
-    }
-    removePhaseMessage(config.context.messages, previousPhaseMsgId);
-    previousPhaseMsgId = void 0;
-    if (enteringNewPhase) {
-      previousPhaseMsgId = injectPhaseContent(phase, { results: previousResults, instruction: pendingInstruction }, messageManager);
-      previousResults = [];
-      pendingInstruction = void 0;
-    }
-    const runtime = { phase, config, state, execution, messageManager, registry, context: phaseContext };
-    let output = await executePhase(runtime);
-    let routeToolCalled = false;
-    let routeDecision;
-    if (output.toolCalls && output.toolCalls.length > 0) {
-      routeDecision = extractRouteCall(output.toolCalls);
-      if (routeDecision) {
-        routeToolCalled = true;
-        applyFirstDecision(routeDecision, output);
-      }
-    }
-    if (config.afterPhase) {
-      const extAfter = await config.afterPhase(currentPhaseId, output);
-      if (extAfter.abort) {
-        config.emit?.({ type: "phase_end", phase: currentPhaseId, ts: createTimestamp() });
-        return completeRun(config, state, extAfter.abort);
-      }
-      if (extAfter.retry && (phase.run || phase.factory)) {
-        output = await executePhase(runtime);
-        routeDecision = output.toolCalls ? extractRouteCall(output.toolCalls) : void 0;
-        if (routeDecision) applyFirstDecision(routeDecision, output);
-      }
-      if (extAfter.output) {
-        output = extAfter.output;
-      }
-    }
-    if (output.route === "continue") {
-      isContinuing = true;
-      continue;
-    }
-    config.emit?.({ type: "phase_end", phase: currentPhaseId, ts: createTimestamp() });
-    if (routeDecision && routeDecision.decision.length > 1) {
-      const contextSnapshot = snapshotMessages(config.context.messages);
-      const parallelTasks = /* @__PURE__ */ new Map();
-      const instanceIds = buildInstanceIds(routeDecision.decision.map((t) => t.phase));
-      for (let i = 0; i < routeDecision.decision.length; i++) {
-        const target = routeDecision.decision[i];
-        const pt = registry.phases.get(target.phase);
-        if (!pt) continue;
-        const instanceId = instanceIds[i];
-        const context = pt.isolated ? [] : contextSnapshot;
-        const payload = target.payload !== void 0 ? normalizePayload(target.payload) : void 0;
-        const promise = executeParallelPhase(config, state, registry, pt, payload, context, availablePhases, currentPhaseId);
-        parallelTasks.set(instanceId, { promise, phaseId: target.phase });
-      }
-      const successfulResults = await waitForBackgroundTasks(parallelTasks);
-      previousResults = successfulResults.map((r) => ({ name: r.instanceId, output: r.payload }));
-      pendingInstruction = routeDecision.instruction;
-      const entryPhaseId = phase.target ?? registry.entryPhaseId ?? "default";
-      if (entryPhaseId === "stop") {
-        return completeRun(config, state, createOutcome.default(output, config.context.messages));
-      }
-      currentPhaseId = entryPhaseId;
-      previousPayload = void 0;
-      continue;
-    }
-    let nextRoute;
-    if (phase.target) {
-      nextRoute = phase.target;
-    } else if (output.route) {
-      nextRoute = output.route;
-    } else {
-      nextRoute = "stop";
-    }
-    if (nextRoute === "stop") {
-      if (routeToolCalled) removePhaseMessage(config.context.messages, previousPhaseMsgId);
-      return completeRun(config, state, createOutcome.default(output, config.context.messages));
-    }
-    const targetPhaseId = nextRoute;
-    if (!registry.phases.has(targetPhaseId)) {
-      removePhaseMessage(config.context.messages, previousPhaseMsgId);
-      return completeRun(config, state, createOutcome.phaseNotFound(output));
-    }
-    state.metrics.phaseTransitions.push({
-      from: currentPhaseId,
-      to: targetPhaseId,
-      ts: createTimestamp()
-    });
-    previousPayload = output.payload;
-    previousResults = output.payload !== void 0 ? [{ name: phase.id, output: output.payload }] : [];
-    currentPhaseId = targetPhaseId;
-  }
-  throw new Error("Phase machine exited without a stop or abort transition.");
-}
-var DEFAULT_MAX_RETRIES = 3;
-var DEFAULT_BASE_DELAY_MS = 1e3;
-var DEFAULT_MAX_DELAY_MS = 3e4;
-function isRetryableError(error) {
-  if (!(error instanceof Error)) return false;
-  const message = error.message.toLowerCase();
-  if (message.includes("rate limit") || message.includes("429")) return true;
-  if (message.includes("overloaded") || message.includes("529")) return true;
-  if (message.includes("server error") || message.includes("500")) return true;
-  if (message.includes("bad gateway") || message.includes("502")) return true;
-  if (message.includes("service unavailable") || message.includes("503")) return true;
-  if (message.includes("gateway timeout") || message.includes("504")) return true;
-  if (message.includes("econnreset") || message.includes("econnrefused")) return true;
-  if ("code" in error) {
-    const code = error.code;
-    if (code === "invalid_model_schema" || code === "empty_response") return true;
-  }
-  return false;
-}
-function getRetryDelay(attempt, baseMs, maxMs) {
-  const exponential = baseMs * Math.pow(2, attempt);
-  const jitter = exponential * (0.5 + Math.random() * 0.5);
-  return Math.min(jitter, maxMs);
-}
-async function withRetry(fn, options = {}) {
-  const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
-  const baseDelayMs = options.baseDelayMs ?? DEFAULT_BASE_DELAY_MS;
-  const maxDelayMs = options.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
-  let lastError;
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    try {
-      return await fn();
-    } catch (error) {
-      lastError = error;
-      if (attempt >= maxRetries || !isRetryableError(error)) {
-        throw error;
-      }
-      if (options.signal?.aborted) {
-        throw error;
-      }
-      const delayMs = getRetryDelay(attempt, baseDelayMs, maxDelayMs);
-      options.onRetry?.(attempt, error, delayMs);
-      await new Promise((resolve6) => setTimeout(resolve6, delayMs));
-      if (options.signal?.aborted) {
-        throw lastError;
-      }
-    }
-  }
-  throw lastError;
-}
-async function executePhase(ctx) {
-  const { phase, config, execution, registry, context } = ctx;
-  if (phase.factory) {
-    const api = createExtensionAPI(void 0, void 0, {
-      registerPhase: () => {
-      },
-      registerProvider: () => {
-      },
-      unregisterProvider: () => {
-      },
-      registerTool: () => {
-      },
-      context: {
-        cwd: process.cwd(),
-        signal: config.signal,
-        isIdle: () => false,
-        abort: () => config.signal?.dispatchEvent(new Event("abort")),
-        exec: async () => ({ exitCode: 1, stdout: "", stderr: "not available in phase context" }),
-        getSystemPrompt: () => config.context.systemPrompt,
-        setSystemPrompt: () => {
-        },
-        getMessages: () => context.messages,
-        addMessage: (role, content) => {
-          config.context.messages.push(createMessage(role, content));
-        },
-        getAvailableTools: () => config.context.tools.map((t) => ({ name: t.name, description: t.description })),
-        getAvailableSkills: () => config.context.skills.map((s) => ({ name: s.name, description: s.description })),
-        getPhaseContent: (id) => registry.phases.get(id)?.content ?? "",
-        getAvailablePhases: () => Array.from(registry.phases.keys())
-      },
-      phase: context,
-      session: config.context
-    });
-    await phase.factory(api);
-    return {
-      message: api.phase.getMessage() ?? `${phase.name} phase completed.`,
-      route: api.phase.getNextPhase() || "stop",
-      phase: phase.name,
-      payload: api.phase.getPayload()
-    };
-  }
-  if (phase.run) {
-    const output = resolvePhaseOutput(await phase.run(context, execution));
-    output.phase = phase.name;
-    if (output.message === "Phase completed.") {
-      output.message = `${phase.name} phase completed.`;
-    }
-    return output;
-  }
-  return executePhaseWithModel(ctx);
-}
-async function executeToolCall(input) {
-  if (input.config.runtime?.tools) {
-    return input.config.runtime.tools({
-      config: input.config,
-      toolCall: input.toolCall
-    });
-  }
-  const toolContext = {
-    skills: input.config.context.skills,
-    toolCallId: input.toolCall.id
-  };
-  return executeRuntimeToolCall({
-    tools: input.tools,
-    toolCall: input.toolCall,
-    toolContext,
-    beforeToolCall: input.config.beforeToolCall,
-    afterToolCall: input.config.afterToolCall,
-    signal: input.config.signal
-  });
-}
-function createPhaseExecution(config, state, allTools, phase, messageManager, toolExecutionManager, registry) {
-  return {
-    snapshot() {
-      return {
-        systemPrompt: config.context.systemPrompt,
-        messages: [...config.context.messages],
-        currentPhase: state.currentPhase ?? "",
-        availablePhases: Array.from(registry.phases.keys()),
-        turnNumber: state.metrics.iterations
-      };
-    },
-    restore(snapshot) {
-      config.context.systemPrompt = snapshot.systemPrompt;
-      config.context.messages.length = 0;
-      config.context.messages.push(...snapshot.messages);
-      state.currentPhase = snapshot.currentPhase;
-      state.metrics.iterations = snapshot.turnNumber;
-    },
-    async invokeModel(phaseContext) {
-      if (config.beforePrompt) {
-        phaseContext = await config.beforePrompt(phase.id, phaseContext);
-      }
-      const request = buildModelRequest({
-        systemPrompt: phaseContext.systemPrompt,
-        messages: phaseContext.messages,
-        tools: phaseContext.tools,
-        skills: phaseContext.skills,
-        promptGuidelines: phaseContext.promptGuidelines,
-        appendSystemPrompt: phaseContext.appendSystemPrompt
-      }, { model: phase.model ?? config.model });
-      if (!request.tools) {
-        if (phaseContext.tools.length > 0) {
-          request.tools = phaseContext.tools.map((t) => ({
-            name: t.name,
-            description: t.description,
-            parameters: t.parameters
-          }));
-        }
-      }
-      const result = await runTurn(
-        config.context,
-        config.emit,
-        () => withRetry(
-          () => invokeModel({
-            config,
-            message: messageManager,
-            request,
-            phaseId: phase.id
-          }),
-          {
-            signal: config.signal,
-            onRetry: (attempt, error, delayMs) => {
-              state.metrics.retryCount++;
-              const errMsg = error instanceof Error ? error.message : String(error);
-              config.emit?.({
-                type: "message_start",
-                message: {
-                  id: `retry_${attempt}`,
-                  role: "assistant",
-                  content: `[Retry ${attempt + 1}/${DEFAULT_MAX_RETRIES}] Transient error: ${errMsg}. Retrying in ${Math.round(delayMs)}ms...`,
-                  createdAt: createTimestamp(),
-                  metadata: { type: "retry_notice" }
-                },
-                ts: createTimestamp()
-              });
-            }
-          }
-        )
-      );
-      await config.onModelTranscript?.(result.transcript, { phase: phase.id, model: phase.model ?? config.model });
-      return result;
-    },
-    async executeTool(_context, toolCall) {
-      return runTurn(config.context, config.emit, async () => {
-        await toolExecutionManager.start(toolCall.id, toolCall.name, toolCall.args);
-        const result = await executeToolCall({ config, tools: allTools, toolCall });
-        await toolExecutionManager.end(result.toolCallId, result.toolName, result, !result.ok);
-        return result;
-      });
-    }
-  };
-}
-async function executeParallelPhase(config, state, registry, phase, payload, context, availablePhases, currentPhaseId) {
-  const messages = [...context];
-  const allTools = buildToolsWithRouting(config, availablePhases);
-  const phaseTools = phase.tools ? allTools.filter((t) => t.name === PhaseRouteTool || phase.tools.includes(t.name)) : allTools;
-  const phaseSkills = phase.skills ? config.context.skills.filter((s) => phase.skills.includes(s.name)) : config.context.skills;
-  const systemPrompt = phase.isolated ? readPhaseContent(phase) : config.context.systemPrompt;
-  const phaseContext = {
-    systemPrompt,
-    messages,
-    tools: phaseTools,
-    skills: phaseSkills,
-    state: {
-      current: phase.id,
-      available: Array.from(registry.phases.keys()),
-      iterations: 0,
-      payload
-    }
-  };
-  const messageManager = createMessageManager({ messages }, config.emit, config.onMessage);
-  const phaseMsgId = phase.isolated ? void 0 : injectPhaseContent(
-    phase,
-    { results: payload !== void 0 ? [{ name: currentPhaseId, output: payload }] : [] },
-    messageManager
-  );
-  const toolExecutionManager = createToolExecutionManager(config.emit);
-  const execution = createPhaseExecution(config, state, phaseTools, phase, messageManager, toolExecutionManager, registry);
-  const runtime = { phase, config, state, execution, messageManager, registry, context: phaseContext };
-  const output = await executePhase(runtime);
-  if (phaseMsgId) removePhaseMessage(messages, phaseMsgId);
-  const decision = output.toolCalls ? extractRouteCall(output.toolCalls) : void 0;
-  const resultPayload = decision?.decision[0]?.payload !== void 0 ? normalizePayload(decision.decision[0].payload) : output.payload;
-  return { instanceId: "", phaseId: phase.id, payload: resultPayload, content: output.message };
-}
-async function waitForBackgroundTasks(backgroundTasks) {
-  const entries = Array.from(backgroundTasks.entries());
-  const results = await Promise.allSettled(entries.map(([, t]) => t.promise));
-  const successful = [];
-  for (let i = 0; i < results.length; i++) {
-    const r = results[i];
-    if (r.status === "fulfilled") {
-      successful.push({ ...r.value, instanceId: entries[i][0] });
-    }
-  }
-  backgroundTasks.clear();
-  return successful;
-}
-
-// src/agent-loop.ts
-async function runAgentLoop(input) {
-  const sessionId = input.sessionId ?? createId("ses");
-  const config = {
-    ...input,
-    sessionId,
-    maxAttempts: input.maxAttempts ?? 2
-  };
-  const state = {
-    currentPhase: config.sessionState?.currentPhase ?? "",
-    attempt: config.sessionState?.attempt ?? 0,
-    status: config.sessionState?.status ?? "running",
-    metrics: config.sessionState?.metrics ?? {
-      iterations: 0,
-      phaseTransitions: [],
-      compactionCount: 0,
-      retryCount: 0,
-      startedAt: createTimestamp(),
-      startedAtMs: Date.now()
-    }
-  };
-  const emitEvent = (event) => {
-    config.emit?.(event);
-  };
-  emitEvent({ type: "agent_start", sessionId, ts: createTimestamp() });
-  try {
-    const abortResult = LoopGuard.checkAbort(config.signal);
-    if (abortResult.stopReason !== "none") {
-      return completeRun2(config, state, createOutcome.aborted());
-    }
-    return await startPhaseLoop(config, state);
-  } finally {
-    emitEvent({
-      type: "agent_end",
-      sessionId,
-      messages: snapshotMessages(config.context.messages),
-      ts: createTimestamp()
-    });
-  }
-}
-async function completeRun2(config, state, outcome) {
-  state.metrics.endedAt = createTimestamp();
-  state.metrics.durationMs = Date.now() - state.metrics.startedAtMs;
-  await config.onOutcome?.(outcome);
-  return {
-    sessionId: config.sessionId,
-    messages: snapshotMessages(config.context.messages),
-    outcome,
-    metrics: state.metrics
-  };
-}
-
-// src/agent.ts
-init_loader2();
-
-// src/harness/skills.ts
-var import_node_fs5 = require("fs");
-var import_promises5 = require("fs/promises");
-var import_node_path6 = require("path");
-init_path();
-init_loader();
-init_resource_formatter();
-var SKILL_MARKER = "SKILL.md";
-function resolveSkillPath(input, workspace = resolveWorkspacePaths()) {
-  return resolveResourcePath(input, "skills", SKILL_MARKER, workspace);
-}
-function readSkillContent(skill) {
-  return formatResourceOutput({
-    type: "skill",
-    name: skill.name,
-    location: skill.filePath,
-    content: skill.content,
-    baseDir: skill.baseDir
-  });
-}
-async function loadSkill(path, workspace) {
-  const resolved = resolveSkillPath(path, workspace);
-  const { frontmatter, body } = await loadMarkdown(resolved);
-  return {
-    name: frontmatter.name ?? inferResourceName(resolved, SKILL_MARKER),
-    description: frontmatter.description ?? "",
-    filePath: resolved,
-    baseDir: (0, import_node_path6.dirname)(resolved),
-    content: body,
-    disableModelInvocation: frontmatter["disable-model-invocation"] === true
-  };
-}
-async function loadSkills(workspace, paths) {
-  if (paths && paths.length > 0) {
-    return Promise.all(paths.map((path) => loadSkill(path, workspace)));
-  }
-  const ws = workspace ?? resolveWorkspacePaths();
-  const skillsDir = (0, import_node_path6.join)(ws.rowanDir, "skills");
-  if (!(0, import_node_fs5.existsSync)(skillsDir)) {
-    return [];
-  }
-  const entries = await (0, import_promises5.readdir)(skillsDir, { withFileTypes: true });
-  const skills = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    const skillFile = (0, import_node_path6.join)(skillsDir, entry.name, SKILL_MARKER);
-    if (!(0, import_node_fs5.existsSync)(skillFile)) continue;
-    try {
-      const skill = await loadSkill(entry.name, ws);
-      skills.push(skill);
-    } catch (error) {
-      console.warn(`Failed to load skill "${entry.name}":`, error);
-    }
-  }
-  return skills;
-}
-
-// src/agent.ts
-init_path();
-var Agent = class {
-  state;
-  options;
-  listeners = /* @__PURE__ */ new Set();
-  pendingListenerTasks = /* @__PURE__ */ new Set();
-  listenerErrors = [];
-  activeRun;
-  constructor(options) {
-    this.options = {
-      ...options,
-      context: cloneAgentContext(options.context)
-    };
-    this.state = {
-      ...this.options.sessionId ? { sessionId: this.options.sessionId } : {},
-      context: cloneAgentContext(this.options.context),
-      model: this.options.model,
-      tools: this.options.context.tools ?? [],
-      isRunning: false
-    };
-  }
-  subscribe(listener) {
-    this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
-  }
-  emitToListeners(event) {
-    for (const listener of this.listeners) {
-      try {
-        const result = listener(event);
-        if (result && typeof result === "object" && "then" in result) {
-          const task = Promise.resolve(result).catch((error) => {
-            this.listenerErrors.push(error);
-          }).finally(() => {
-            this.pendingListenerTasks.delete(task);
-          });
-          this.pendingListenerTasks.add(task);
-        }
-      } catch (error) {
-        this.listenerErrors.push(error);
-      }
-    }
-  }
-  async flushEvents() {
-    while (this.pendingListenerTasks.size > 0) {
-      await Promise.all([...this.pendingListenerTasks]);
-    }
-    for (const listener of this.listeners) {
-      try {
-        await listener.flush?.();
-      } catch (error) {
-        this.listenerErrors.push(error);
-      }
-    }
-    if (this.listenerErrors.length > 0) {
-      const [error] = this.listenerErrors;
-      throw error instanceof Error ? error : new Error(String(error));
-    }
-  }
-  processEvents(event) {
-    switch (event.type) {
-      case "message_start":
-        this.state.currentResult = void 0;
-        break;
-      case "message_end":
-        break;
-      case "agent_end":
-        break;
-    }
-    this.emitToListeners(event);
-    this.options.extensionRunnerRef?.current?.emitAgentEvent(event);
-  }
-  /**
-   * Hook for before_tool_call — called before a tool executes.
-   * Extensions can block execution by setting allow=false.
-   */
-  async handleBeforeToolCall(tool, args) {
-    const runner = this.options.extensionRunnerRef?.current;
-    if (!runner) return { allow: true };
-    return runner.emitBeforeToolCall(tool, args);
-  }
-  /**
-   * Hook for after_tool_call — called after a tool executes.
-   * Extensions can mutate the result.
-   */
-  async handleAfterToolCall(tool, result) {
-    const runner = this.options.extensionRunnerRef?.current;
-    if (!runner) return result;
-    return runner.emitAfterToolCall(tool, result);
-  }
-  /**
-   * Hook for before_phase — called before a phase executes.
-   * Extensions can abort, skip, or replace the phase input.
-   */
-  async handleBeforePhase(phaseId, input) {
-    const runner = this.options.extensionRunnerRef?.current;
-    if (!runner) return {};
-    return runner.emitBeforePhase(phaseId, input);
-  }
-  /**
-   * Hook for after_phase — called after a phase executes.
-   * Extensions can abort, retry, or replace the output.
-   */
-  async handleAfterPhase(phaseId, output) {
-    const runner = this.options.extensionRunnerRef?.current;
-    if (!runner) return {};
-    return runner.emitAfterPhase(phaseId, output);
-  }
-  /**
-   * Hook for before_prompt — called before model request, allowing extensions to transform PhaseContext.
-   * Extensions can transform the PhaseContext (messages, tools, systemPrompt, etc.).
-   */
-  async handleBeforePrompt(phaseId, input) {
-    const runner = this.options.extensionRunnerRef?.current;
-    if (!runner) return input;
-    return runner.emitBeforePrompt(phaseId, input);
-  }
-  handleRunFailure(error, aborted) {
-    const message = error instanceof Error ? error.message : "Agent run failed.";
-    this.state.error = message;
-  }
-  /**
-   * Discover and load phases and skills from the workspace.
-   *
-   * - Auto-discovers file-based phases from .rowan/phases/
-   * - Auto-discovers skills from .rowan/skills/
-   * - Merges with CLI-provided phases and skills
-   */
-  async discoverResources(context) {
-    const workspace = resolveWorkspacePaths({ cwd: this.options.cwd, rowanDir: this.options.rowanDir });
-    const filePhases = await loadPhases(workspace);
-    let phases;
-    const providedPhases = this.options.phases;
-    if (providedPhases && providedPhases.phases.size > 0) {
-      const merged = new Map(filePhases.phases);
-      for (const [id, phase] of providedPhases.phases) {
-        merged.set(id, phase);
-      }
-      phases = {
-        phases: merged,
-        entryPhaseId: providedPhases.entryPhaseId ?? filePhases.entryPhaseId
-      };
-    } else if (filePhases.phases.size > 0) {
-      phases = filePhases;
-    }
-    const fileSkills = await loadSkills(workspace);
-    const skillMap = /* @__PURE__ */ new Map();
-    for (const skill of fileSkills) {
-      skillMap.set(skill.name, skill);
-    }
-    for (const skill of context.skills) {
-      skillMap.set(skill.name, skill);
-    }
-    const skills = Array.from(skillMap.values());
-    return { phases, skills };
-  }
-  async runWithLifecycle(executor) {
-    if (this.activeRun) {
-      throw new Error("Agent is already running.");
-    }
-    let resolvePromise;
-    const abortController = new AbortController();
-    const promise = new Promise((resolve6) => {
-      resolvePromise = resolve6;
-    });
-    this.activeRun = { promise, resolve: resolvePromise, abortController };
-    this.state.isRunning = true;
-    try {
-      const result = await executor(abortController.signal);
-      resolvePromise(result);
-      return result;
-    } catch (error) {
-      this.handleRunFailure(error, abortController.signal.aborted);
-      resolvePromise(void 0);
-      throw error;
-    } finally {
-      this.finishRun();
-    }
-  }
-  finishRun() {
-    this.state.isRunning = false;
-    this.activeRun = void 0;
-  }
-  async run(config) {
-    const resolved = this.resolveRunConfig(config);
-    const previousSessionId = this.state.sessionId ?? this.options.sessionId;
-    const sessionId = resolved.sessionId ?? this.state.sessionId;
-    const hadExistingSession = Boolean(sessionId && previousSessionId === sessionId);
-    this.options = resolved;
-    if (sessionId) {
-      this.state.sessionId = sessionId;
-    }
-    this.state.context = cloneAgentContext(resolved.context);
-    this.state.model = resolved.model;
-    this.state.tools = resolved.context.tools ?? [];
-    this.state.currentResult = void 0;
-    this.state.error = void 0;
-    const { phases, skills } = await this.discoverResources(resolved.context);
-    const contextWithSkills = {
-      ...resolved.context,
-      skills
-    };
-    return this.runWithLifecycle(async (signal) => {
-      const emit = (event) => {
-        this.processEvents(event);
-      };
-      const beforeToolCall = async (input) => {
-        if (resolved.beforeToolCall) {
-          const userResult = await resolved.beforeToolCall(input);
-          if (!userResult.allow) return userResult;
-        }
-        const extResult = await this.handleBeforeToolCall(input.tool, input.args);
-        if (!extResult.allow) {
-          return { allow: false, reason: extResult.reason ?? "Blocked by extension" };
-        }
-        return { allow: true };
-      };
-      const afterToolCall = async (input) => {
-        let result2 = input.result;
-        if (resolved.afterToolCall) {
-          result2 = await resolved.afterToolCall({ tool: input.tool, result: result2 });
-        }
-        return this.handleAfterToolCall(input.tool, result2);
-      };
-      const result = await runAgentLoop({
-        context: contextWithSkills,
-        sessionId: sessionId ?? createId("ses"),
-        model: resolved.model,
-        stream: resolved.stream,
-        maxAttempts: resolved.maxAttempts,
-        signal,
-        beforeToolCall,
-        afterToolCall,
-        beforePhase: (phaseId, input) => this.handleBeforePhase(phaseId, input),
-        afterPhase: (phaseId, output) => this.handleAfterPhase(phaseId, output),
-        beforePrompt: (phaseId, input) => this.handleBeforePrompt(phaseId, input),
-        phases,
-        emit,
-        onMessage: resolved.onMessage,
-        onOutcome: resolved.onOutcome,
-        onModelTranscript: resolved.onModelTranscript
-      });
-      this.state.sessionId = result.sessionId;
-      this.state.context = {
-        ...cloneAgentContext(resolved.context),
-        messages: snapshotMessages(result.messages)
-      };
-      this.state.currentResult = result;
-      this.options = {
-        ...resolved,
-        sessionId: result.sessionId,
-        context: cloneAgentContext(this.state.context)
-      };
-      return result;
-    });
-  }
-  abort(reason = "Aborted by caller.") {
-    this.activeRun?.abortController.abort(reason);
-  }
-  /**
-   * Get formatted skill content for LLM consumption.
-   *
-   * Finds the skill by name and returns the formatted content using `formatSkillInvocation`.
-   * This is a programmatic API for developers to invoke skills directly.
-   *
-   * @param name - The skill name to look up
-   * @param additionalInstructions - Optional additional instructions to append
-   * @returns Formatted skill content string
-   */
-  skill(name, additionalInstructions) {
-    const skill = this.state.context.skills.find((s) => s.name === name);
-    if (!skill) {
-      throw new Error(`Unknown skill: ${name}`);
-    }
-    const content = readSkillContent(skill);
-    return additionalInstructions ? `${content}
-
-${additionalInstructions}` : content;
-  }
-  /**
-   * Get formatted phase content for LLM consumption.
-   *
-   * Finds the phase by name and returns the formatted content.
-   * This is a programmatic API for developers to invoke phases directly.
-   *
-   * @param name - The phase name to look up
-   * @returns Formatted phase content string, or empty string if not found
-   */
-  async phase(name) {
-    const workspace = resolveWorkspacePaths({ cwd: this.options.cwd, rowanDir: this.options.rowanDir });
-    const { loadPhase: loadPhase2, readPhaseContent: readPhaseContent2 } = await Promise.resolve().then(() => (init_loader2(), loader_exports));
-    try {
-      const phase = await loadPhase2(name, workspace);
-      return readPhaseContent2(phase);
-    } catch {
-      return "";
-    }
-  }
-  async waitForIdle() {
-    if (!this.activeRun) {
-      return;
-    }
-    await this.activeRun.promise.catch(() => void 0);
-    await this.flushEvents().catch(() => void 0);
-  }
-  resolveRunConfig(config) {
-    const context = cloneAgentContext(config?.context ?? this.createContextSnapshot());
-    return {
-      ...this.options,
-      ...config,
-      context,
-      sessionId: config?.sessionId ?? this.state.sessionId ?? this.options.sessionId
-    };
-  }
-  createContextSnapshot() {
-    return cloneAgentContext(this.state.context);
-  }
-};
-function cloneAgentContext(context) {
-  return {
-    systemPrompt: context.systemPrompt,
-    messages: snapshotMessages(context.messages),
-    tools: context.tools.slice(),
-    skills: context.skills.slice()
-  };
-}
-
-// src/harness/session/session.ts
-var import_typebox3 = __toESM(require("typebox"), 1);
-var SESSION_SCHEMA_VERSION = "0.4.4";
-var AgentMessageSchema = import_typebox3.default.Object({
-  id: import_typebox3.default.String(),
-  role: import_typebox3.default.Union([
-    import_typebox3.default.Literal("system"),
-    import_typebox3.default.Literal("user"),
-    import_typebox3.default.Literal("assistant"),
-    import_typebox3.default.Literal("tool")
-  ]),
-  content: import_typebox3.default.Union([import_typebox3.default.String(), import_typebox3.default.Array(import_typebox3.default.Unknown())]),
-  createdAt: import_typebox3.default.String(),
-  metadata: import_typebox3.default.Optional(import_typebox3.default.Record(import_typebox3.default.String(), import_typebox3.default.Unknown()))
-});
-var SkillSchema = import_typebox3.default.Object({
-  name: import_typebox3.default.String(),
-  description: import_typebox3.default.String(),
-  filePath: import_typebox3.default.String(),
-  baseDir: import_typebox3.default.String(),
-  content: import_typebox3.default.String(),
-  disableModelInvocation: import_typebox3.default.Boolean()
-});
-function createMessage2(role, content, metadata) {
-  return {
-    id: createId("msg"),
-    role,
-    content,
-    createdAt: createTimestamp(),
-    ...metadata ? { metadata } : {}
-  };
-}
-function createSession(input) {
-  const createdAt = createTimestamp();
-  const messages = [
-    createMessage2("user", input.input)
-  ];
-  return {
-    version: SESSION_SCHEMA_VERSION,
-    id: input.id ?? createId("ses"),
-    ...input.parentSessionId ? { parentSessionId: input.parentSessionId } : {},
-    systemPrompt: input.systemPrompt,
-    input: input.input,
-    messages,
-    log: [],
-    skills: input.skills ?? [],
-    createdAt,
-    updatedAt: createdAt,
-    ...input.title ? { title: input.title } : {}
-  };
-}
-function appendUserTurn(session, input) {
-  session.messages.push(createMessage2("user", input));
-  session.updatedAt = createTimestamp();
-  return session;
-}
-
-// src/harness/session/session-manager.ts
-var SESSION_MANAGER_SCHEMA_VERSION = "0.4.4";
-function clone(value) {
-  return JSON.parse(JSON.stringify(value));
-}
-function createSessionHeader(input) {
-  const createdAt = createTimestamp();
-  return {
-    type: "header",
-    id: input.id ?? createId("ses"),
-    version: SESSION_MANAGER_SCHEMA_VERSION,
-    createdAt,
-    updatedAt: createdAt,
-    systemPrompt: input.systemPrompt,
-    input: input.input,
-    ...input.parentSessionId ? { parentSessionId: input.parentSessionId } : {},
-    skills: input.skills?.map(clone) ?? [],
-    ...input.title ? { title: input.title } : {},
-    currentLeafId: null
-  };
-}
-function filterExecutionTurns(steps, filter = {}) {
-  return steps.filter((step) => {
-    if (filter.phase && step.phase !== filter.phase) return false;
-    if (filter.afterMs !== void 0 && step.requestedAtMs < filter.afterMs) return false;
-    return true;
-  }).map(clone);
-}
-var InMemorySessionManager = class _InMemorySessionManager {
-  constructor(header, entries = []) {
-    this.header = header;
-    this.entries = entries;
-  }
-  header;
-  entries;
-  static create(input) {
-    return new _InMemorySessionManager(createSessionHeader(input));
-  }
-  static fromRecords(records) {
-    const [header, ...entries] = records;
-    if (!header || header.type !== "header") {
-      throw new Error("Session records must start with a header.");
-    }
-    return new _InMemorySessionManager(clone(header), clone(entries));
-  }
-  getSessionId() {
-    return this.header.id;
-  }
-  getSessionFile() {
-    return void 0;
-  }
-  async getHeader() {
-    return clone(this.header);
-  }
-  async appendMessage(message) {
-    return this.appendEntry({ type: "message", message: clone(message) });
-  }
-  async appendOutcome(outcome) {
-    return this.appendEntry({ type: "outcome", outcome: clone(outcome) });
-  }
-  async appendExecutionTurn(turn) {
-    return this.appendEntry({
-      type: "execution_turn",
-      turn: clone({
-        ...turn,
-        sessionId: this.header.id
-      })
-    });
-  }
-  async appendCompaction(input) {
-    return this.appendEntry({ type: "compaction", ...input });
-  }
-  async appendBranchSummary(input) {
-    return this.appendEntry({ type: "branch_summary", ...input });
-  }
-  async appendSessionInfo(input) {
-    this.header = {
-      ...this.header,
-      title: input.title,
-      updatedAt: createTimestamp()
-    };
-    return this.appendEntry({ type: "session_info", title: input.title });
-  }
-  async appendCustom(input) {
-    return this.appendEntry({ type: "custom", customType: input.customType, data: clone(input.data) });
-  }
-  async appendSessionState(state) {
-    return this.appendEntry({ type: "session_state", state: clone(state) });
-  }
-  async appendModelTranscript(transcript, meta) {
-    return this.appendEntry({
-      type: "model_transcript",
-      transcript: clone(transcript),
-      ...meta?.phase ? { phase: meta.phase } : {},
-      ...meta?.model ? { model: clone(meta.model) } : {}
-    });
-  }
-  async getSessionState() {
-    for (let i = this.entries.length - 1; i >= 0; i--) {
-      const entry = this.entries[i];
-      if (entry.type === "session_state") {
-        return clone(entry.state);
-      }
-    }
-    return void 0;
-  }
-  async branch(entryId) {
-    if (entryId !== null && !this.entries.some((entry) => entry.id === entryId)) {
-      throw new Error(`Session entry not found: ${entryId}`);
-    }
-    this.header = {
-      ...this.header,
-      currentLeafId: entryId,
-      updatedAt: createTimestamp()
-    };
-  }
-  async buildAgentContext(input = {}) {
-    const entries = this.entriesForLeaf(input.leafId ?? this.header.currentLeafId ?? null);
-    return {
-      systemPrompt: this.header.systemPrompt,
-      messages: entries.filter((entry) => entry.type === "message").map((entry) => entry.message).map(clone),
-      tools: input.tools?.slice() ?? [],
-      skills: input.skills?.map(clone) ?? this.header.skills.map(clone)
-    };
-  }
-  async listEntries() {
-    return this.entries.map(clone);
-  }
-  async loadExecutionTurns(filter) {
-    return filterExecutionTurns(
-      this.entries.filter((entry) => entry.type === "execution_turn").map((entry) => entry.turn),
-      filter
-    );
-  }
-  appendImportedEntry(entry) {
-    this.entries.push(clone(entry));
-    this.header = {
-      ...this.header,
-      currentLeafId: entry.id,
-      updatedAt: entry.timestamp
-    };
-  }
-  appendEntry(input) {
-    const timestamp = createTimestamp();
-    const entry = {
-      id: createId("entry"),
-      parentId: this.header.currentLeafId ?? null,
-      timestamp,
-      ...input
-    };
-    this.entries.push(entry);
-    this.header = {
-      ...this.header,
-      currentLeafId: entry.id,
-      updatedAt: timestamp
-    };
-    return entry.id;
-  }
-  entriesForLeaf(leafId) {
-    if (!leafId) {
-      return [];
-    }
-    const byId = new Map(this.entries.map((entry) => [entry.id, entry]));
-    const ordered = [];
-    let currentId = leafId;
-    while (currentId) {
-      const entry = byId.get(currentId);
-      if (!entry) {
-        throw new Error(`Session entry not found: ${currentId}`);
-      }
-      ordered.unshift(entry);
-      currentId = entry.parentId;
-    }
-    return ordered;
-  }
-};
-function summarizeSessionManagerRecords(records) {
-  const [header, ...entries] = records;
-  if (!header || header.type !== "header") {
-    throw new Error("Session records must start with a header.");
-  }
-  const messages = entries.filter((entry) => entry.type === "message").map((entry) => entry.message);
-  const latestMessageContent = messages.at(-1)?.content;
-  const latestMessage = latestMessageContent ? messageContentText(latestMessageContent) : void 0;
-  return {
-    id: header.id,
-    ...header.title ? { title: header.title } : {},
-    createdAt: header.createdAt,
-    updatedAt: header.updatedAt,
-    messageCount: messages.length,
-    ...latestMessage ? { latestMessage } : {}
-  };
-}
-
-// src/harness/session/jsonl.ts
-var import_promises6 = require("fs/promises");
-var import_node_path7 = require("path");
-var SESSION_ID_PATTERN = /^ses_[A-Za-z0-9_-]+$/;
-function isPathInside(parent, child) {
-  const relativePath = (0, import_node_path7.relative)(parent, child);
-  return Boolean(relativePath) && !relativePath.startsWith("..") && !relativePath.includes(`..${import_node_path7.sep}`);
-}
-function safeSessionPath(sessionsDir, id) {
-  if (!SESSION_ID_PATTERN.test(id)) {
-    return void 0;
-  }
-  const root = (0, import_node_path7.resolve)(sessionsDir);
-  const path = (0, import_node_path7.resolve)(root, `${id}.jsonl`);
-  return isPathInside(root, path) ? path : void 0;
-}
-function parseRecord(line) {
-  const value = JSON.parse(line);
-  if (!value || typeof value !== "object" || !("type" in value)) {
-    throw new Error("Invalid session JSONL record.");
-  }
-  return value;
-}
-async function readRecords(path) {
-  const text = await (0, import_promises6.readFile)(path, "utf8").catch((error) => {
-    if (error.code === "ENOENT") {
-      return void 0;
-    }
-    throw error;
-  });
-  if (!text) {
-    return void 0;
-  }
-  const records = text.split("\n").map((line) => line.trim()).filter(Boolean).map(parseRecord);
-  const header = records[0];
-  if (!header || header.type !== "header") {
-    throw new Error("Session JSONL must start with a header record.");
-  }
-  const lastEntry = records.slice(1).reverse().find((record) => record.type !== "header");
-  return [
-    {
-      ...header,
-      updatedAt: lastEntry?.timestamp ?? header.updatedAt,
-      currentLeafId: lastEntry?.id ?? header.currentLeafId ?? null
-    },
-    ...records.slice(1)
-  ];
-}
-async function appendRecord(path, record) {
-  await (0, import_promises6.appendFile)(path, `${JSON.stringify(record)}
-`, "utf8");
-}
-var LocalJsonlSessionManager = class _LocalJsonlSessionManager {
-  constructor(sessionsDir, filePath, inner) {
-    this.sessionsDir = sessionsDir;
-    this.filePath = filePath;
-    this.inner = inner;
-  }
-  sessionsDir;
-  filePath;
-  inner;
-  static async create(sessionsDir, input) {
-    const header = createSessionHeader(input);
-    const path = safeSessionPath(sessionsDir, header.id);
-    if (!path) {
-      throw new Error(`Invalid session id: ${header.id}`);
-    }
-    const exists = await (0, import_promises6.stat)(path).then(() => true).catch((error) => {
-      if (error.code === "ENOENT") {
-        return false;
-      }
-      throw error;
-    });
-    if (exists) {
-      throw new Error(`Session already exists: ${header.id}`);
-    }
-    await (0, import_promises6.mkdir)(sessionsDir, { recursive: true });
-    await (0, import_promises6.writeFile)(path, `${JSON.stringify(header)}
-`, "utf8");
-    return new _LocalJsonlSessionManager(
-      sessionsDir,
-      path,
-      InMemorySessionManager.fromRecords([header])
-    );
-  }
-  static async open(sessionsDir, id) {
-    const path = safeSessionPath(sessionsDir, id);
-    if (!path) {
-      return void 0;
-    }
-    const records = await readRecords(path);
-    if (!records) {
-      return void 0;
-    }
-    const header = records[0];
-    if (header.id !== id) {
-      throw new Error(`Session id mismatch: expected ${id}, found ${header.id}`);
-    }
-    return new _LocalJsonlSessionManager(
-      sessionsDir,
-      path,
-      InMemorySessionManager.fromRecords(records)
-    );
-  }
-  static async list(sessionsDir) {
-    const entries = await (0, import_promises6.readdir)(sessionsDir, { withFileTypes: true }).catch((error) => {
-      if (error.code === "ENOENT") {
-        return [];
-      }
-      throw error;
-    });
-    const sessions = await Promise.all(
-      entries.filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map(async (entry) => {
-        const path = (0, import_node_path7.join)(sessionsDir, entry.name);
-        const records = await readRecords(path);
-        return records ? summarizeSessionManagerRecords(records) : void 0;
-      })
-    );
-    return sessions.filter((session) => Boolean(session)).sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
-  }
-  static async delete(sessionsDir, id) {
-    const path = safeSessionPath(sessionsDir, id);
-    if (!path) {
-      return false;
-    }
-    return (0, import_promises6.unlink)(path).then(() => true).catch((error) => {
-      if (error.code === "ENOENT") {
-        return false;
-      }
-      throw error;
-    });
-  }
-  getSessionId() {
-    return this.inner.getSessionId();
-  }
-  getSessionFile() {
-    return this.filePath;
-  }
-  async getHeader() {
-    return this.inner.getHeader();
-  }
-  async appendMessage(message) {
-    return this.appendThroughInner(() => this.inner.appendMessage(message));
-  }
-  async appendOutcome(outcome) {
-    return this.appendThroughInner(() => this.inner.appendOutcome(outcome));
-  }
-  async appendExecutionTurn(turn) {
-    return this.appendThroughInner(() => this.inner.appendExecutionTurn(turn));
-  }
-  async appendCompaction(input) {
-    return this.appendThroughInner(() => this.inner.appendCompaction(input));
-  }
-  async appendBranchSummary(input) {
-    return this.appendThroughInner(() => this.inner.appendBranchSummary(input));
-  }
-  async appendSessionInfo(input) {
-    return this.appendThroughInner(() => this.inner.appendSessionInfo(input));
-  }
-  async appendCustom(input) {
-    return this.appendThroughInner(() => this.inner.appendCustom(input));
-  }
-  async appendSessionState(state) {
-    return this.appendThroughInner(() => this.inner.appendSessionState(state));
-  }
-  async appendModelTranscript(transcript, meta) {
-    return this.appendThroughInner(() => this.inner.appendModelTranscript(transcript, meta));
-  }
-  async getSessionState() {
-    return this.inner.getSessionState();
-  }
-  async branch(entryId) {
-    await this.inner.branch(entryId);
-    if (entryId) {
-      await this.appendThroughInner(() => this.inner.appendBranchSummary({
-        fromId: entryId,
-        summary: `Selected branch at ${entryId}`
-      }));
-    }
-  }
-  async buildAgentContext(input) {
-    return this.inner.buildAgentContext(input);
-  }
-  async listEntries() {
-    return this.inner.listEntries();
-  }
-  async loadExecutionTurns(filter) {
-    return this.inner.loadExecutionTurns(filter);
-  }
-  async appendThroughInner(append) {
-    const before = await this.inner.listEntries();
-    const entryId = await append();
-    const after = await this.inner.listEntries();
-    const entry = after.find((candidate) => candidate.id === entryId);
-    if (!entry || before.some((candidate) => candidate.id === entry.id)) {
-      throw new Error(`Session entry was not appended: ${entryId}`);
-    }
-    await (0, import_promises6.mkdir)(this.sessionsDir, { recursive: true });
-    await appendRecord(this.filePath, entry);
-    return entryId;
-  }
-};
-
-// src/harness/env/index.ts
-init_path();
-
-// src/index.ts
-init_config();
-
-// src/event-stream.ts
-var EventStream = class {
-  queue = [];
-  waiting = [];
-  done = false;
-  finalResultPromise;
-  resolveFinalResult;
-  isComplete;
-  extractResult;
-  constructor(isComplete, extractResult) {
-    this.isComplete = isComplete;
-    this.extractResult = extractResult;
-    this.finalResultPromise = new Promise((resolve6) => {
-      this.resolveFinalResult = resolve6;
-    });
-  }
-  push(event) {
-    if (this.done) return;
-    if (this.isComplete(event)) {
-      this.done = true;
-      this.resolveFinalResult(this.extractResult(event));
-    }
-    const waiter = this.waiting.shift();
-    if (waiter) {
-      waiter({ value: event, done: false });
-    } else {
-      this.queue.push(event);
-    }
-  }
-  end(result) {
-    this.done = true;
-    if (result !== void 0) {
-      this.resolveFinalResult(result);
-    }
-    while (this.waiting.length > 0) {
-      const waiter = this.waiting.shift();
-      waiter({ value: void 0, done: true });
-    }
-  }
-  async *[Symbol.asyncIterator]() {
-    while (true) {
-      if (this.queue.length > 0) {
-        yield this.queue.shift();
-      } else if (this.done) {
-        return;
-      } else {
-        const result = await new Promise((resolve6) => this.waiting.push(resolve6));
-        if (result.done) return;
-        yield result.value;
-      }
-    }
-  }
-  result() {
-    return this.finalResultPromise;
-  }
-};
-var AgentEventStream = class extends EventStream {
-  constructor() {
-    super(
-      (event) => event.type === "agent_end",
-      (event) => event.type === "agent_end" ? event.messages : []
-    );
-  }
-};
-
-// src/extensions/hooks.ts
-var HookError = class extends Error {
-  constructor(eventType, message, cause) {
-    super(message, cause === void 0 ? void 0 : { cause });
-    this.eventType = eventType;
-    this.name = "HookError";
-  }
-  eventType;
-};
-var HooksManager = class {
-  handlers = /* @__PURE__ */ new Map();
-  /**
-   * Register a hook handler.
-   * Handlers execute in registration order.
-   *
-   * @param eventType - Event type
-   * @param handler - Handler function
-   */
-  on(eventType, handler) {
-    const handlers = this.handlers.get(eventType) ?? [];
-    handlers.push(handler);
-    this.handlers.set(eventType, handlers);
-  }
-  /**
-   * Unregister a hook handler.
-   */
-  off(eventType, handler) {
-    const handlers = this.handlers.get(eventType);
-    if (!handlers) return;
-    const index = handlers.indexOf(handler);
-    if (index >= 0) handlers.splice(index, 1);
-  }
-  /**
-   * Clear all handlers, or clear handlers for specified event type.
-   */
-  clear(eventType) {
-    if (eventType) {
-      this.handlers.delete(eventType);
-    } else {
-      this.handlers.clear();
-    }
-  }
-  /**
-   * Check if there are handlers registered for specified event type.
-   */
-  has(eventType) {
-    const handlers = this.handlers.get(eventType);
-    return handlers !== void 0 && handlers.length > 0;
-  }
-  /**
-   * Get handler count for specified event type.
-   */
-  count(eventType) {
-    return this.handlers.get(eventType)?.length ?? 0;
-  }
-  /**
-   * Emit event (listen-only, ignore return values).
-   * Errors are collected and thrown.
-   *
-   * @param eventType - Event type
-   * @param event - Event object
-   */
-  async emit(eventType, event) {
-    const handlers = this.handlers.get(eventType);
-    if (!handlers?.length) return;
-    const errors = [];
-    await Promise.allSettled(
-      handlers.map(async (handler) => {
-        try {
-          await handler(event);
-        } catch (error) {
-          errors.push(
-            error instanceof Error ? error : new Error(String(error))
-          );
-        }
-      })
-    );
-    if (errors.length > 0) {
-      throw new HookError(
-        eventType,
-        `${errors.length} handler(s) failed for "${eventType}"`,
-        errors[0]
-      );
-    }
-  }
-  /**
-   * Emit event and return first non-undefined result (short-circuit).
-   *
-   * @param eventType - Event type
-   * @param event - Event object
-   * @returns First non-undefined result, or undefined
-   */
-  async emitFirst(eventType, event) {
-    const handlers = this.handlers.get(eventType);
-    if (!handlers?.length) return void 0;
-    for (const handler of handlers) {
-      try {
-        const result = await handler(event);
-        if (result !== void 0) return result;
-      } catch (error) {
-        throw new HookError(
-          eventType,
-          `Handler failed for "${eventType}"`,
-          error instanceof Error ? error : new Error(String(error))
-        );
-      }
-    }
-    return void 0;
-  }
-};
-var _globalHooks;
-function getGlobalHooks() {
-  _globalHooks ??= new HooksManager();
-  return _globalHooks;
-}
-function resetGlobalHooks() {
-  _globalHooks = void 0;
-}
-
-// src/extensions/runner.ts
-var import_node_child_process = require("child_process");
-var import_models2 = require("@rowan-agent/models");
-
-// src/extensions/types.ts
-function createSourceInfo(extensionPath, options = {}) {
-  const source = options.source ?? (extensionPath.startsWith("<") ? "synthetic" : "local");
-  const displayName = extensionPath.startsWith("<") ? extensionPath.slice(1, -1) : extensionPath.split("/").pop() ?? extensionPath;
-  return {
-    source,
-    baseDir: options.baseDir,
-    displayName
-  };
-}
-function createExtension(extensionPath, resolvedPath, sourceInfo) {
-  return {
-    path: extensionPath,
-    resolvedPath,
-    sourceInfo,
-    handlers: /* @__PURE__ */ new Map(),
-    tools: /* @__PURE__ */ new Map(),
-    phases: /* @__PURE__ */ new Map()
-  };
-}
-function createExtensionRuntime() {
-  const state = {};
-  const assertActive = () => {
-    if (state.staleMessage) {
-      throw new Error(state.staleMessage);
-    }
-  };
-  const runtime = {
-    assertActive,
-    invalidate: (message) => {
-      state.staleMessage ??= message ?? "This extension context is stale after session replacement or reload. Do not use a captured extension API after the runner has been replaced.";
-    },
-    pendingProviderRegistrations: [],
-    // Pre-bind: queue registrations so bind() can flush them once the
-    // model registry is available. bind() replaces both with direct calls.
-    registerProvider: (name, config, extensionPath = "<unknown>") => {
-      runtime.pendingProviderRegistrations.push({ name, config, extensionPath });
-    },
-    unregisterProvider: (name) => {
-      runtime.pendingProviderRegistrations = runtime.pendingProviderRegistrations.filter(
-        (r) => r.name !== name
-      );
-    }
-  };
-  return runtime;
-}
-
-// src/extensions/runner.ts
-init_config();
-
-// src/extensions/event-bus.ts
-function createEventBus() {
-  const listeners = /* @__PURE__ */ new Map();
-  return {
-    on(event, listener) {
-      const set = listeners.get(event) ?? /* @__PURE__ */ new Set();
-      set.add(listener);
-      listeners.set(event, set);
-      return () => {
-        set.delete(listener);
-        if (set.size === 0) listeners.delete(event);
-      };
-    },
-    emit(event, ...args) {
-      const set = listeners.get(event);
-      if (!set) return;
-      for (const listener of set) {
-        try {
-          listener(...args);
-        } catch (err) {
-          console.error(`[event-bus] Listener error for "${event}":`, err);
-        }
-      }
-    },
-    off(event) {
-      if (event) {
-        listeners.delete(event);
-      } else {
-        listeners.clear();
-      }
-    },
-    has(event) {
-      const set = listeners.get(event);
-      return set !== void 0 && set.size > 0;
-    },
-    count(event) {
-      return listeners.get(event)?.size ?? 0;
-    }
-  };
-}
-
-// src/extensions/runner.ts
-async function execCommand(command, args, cwd, options) {
-  return new Promise((resolve6, reject) => {
-    const child = (0, import_node_child_process.execFile)(
-      command,
-      args,
-      {
-        cwd: options?.cwd ?? cwd,
-        env: options?.env ? { ...process.env, ...options.env } : void 0,
-        timeout: options?.timeout,
-        maxBuffer: 10 * 1024 * 1024
-      },
-      (error, stdout, stderr) => {
-        if (error && error.killed && options?.signal?.aborted) {
-          reject(new Error("Command was aborted"));
-          return;
-        }
-        resolve6({
-          exitCode: typeof error?.code === "number" ? error.code : error ? 1 : 0,
-          stdout: stdout ?? "",
-          stderr: stderr ?? ""
-        });
-      }
-    );
-    if (options?.signal) {
-      options.signal.addEventListener(
-        "abort",
-        () => {
-          child.kill("SIGTERM");
-        },
-        { once: true }
-      );
-    }
-  });
-}
-function applyProviderRegistration(config) {
-  if (config.streamSimple) {
-    (0, import_models2.registerApiProvider)({ protocol: config.protocol, stream: config.streamSimple });
-  }
-  for (const modelConfig of config.models) {
-    (0, import_models2.registerModel)({
-      id: modelConfig.id,
-      name: modelConfig.name,
-      protocol: config.protocol,
-      provider: config.id,
-      baseUrl: config.baseUrl,
-      reasoning: modelConfig.reasoning,
-      input: modelConfig.input,
-      cost: modelConfig.cost,
-      contextWindow: modelConfig.contextWindow,
-      maxTokens: modelConfig.maxTokens,
-      ...config.headers ? { headers: config.headers } : {}
-    });
-  }
-}
-function applyProviderUnregistration(name) {
-  (0, import_models2.unregisterProviderModels)(name);
-}
-var ExtensionRunner = class {
-  hooks;
-  runtime;
-  events;
-  cwd;
-  abortController = new AbortController();
-  _idle = true;
-  // Per-extension tracking
-  extensions = [];
-  // Phase management
-  phases = /* @__PURE__ */ new Map();
-  _phaseCache = null;
-  // Provider management
-  pendingProviders = [];
-  bound = false;
-  // Error listeners
-  errorListeners = /* @__PURE__ */ new Set();
-  // Loaded extension metadata (pre-initialization form)
-  loadedExtensions = [];
-  /** Current agent context — set by the agent before each phase */
-  currentContext;
-  constructor(options) {
-    this.hooks = new HooksManager();
-    this.runtime = createExtensionRuntime();
-    this.events = createEventBus();
-    this.cwd = options?.cwd ?? process.cwd();
-  }
-  /** Whether the agent is currently idle (not streaming). */
-  get isIdle() {
-    return this._idle;
-  }
-  /** Set idle state — called by the agent loop. */
-  setIdle(idle) {
-    this._idle = idle;
-  }
-  /** Abort signal for the current runner instance. */
-  get signal() {
-    return this.abortController.signal;
-  }
-  /** Abort the current runner operation. */
-  abort() {
-    this.abortController.abort();
-  }
-  // ---------------------------------------------------------------------------
-  // Error handling
-  // ---------------------------------------------------------------------------
-  /**
-   * Register an error listener.
-   * Returns an unsubscribe function.
-   */
-  onError(listener) {
-    this.errorListeners.add(listener);
-    return () => this.errorListeners.delete(listener);
-  }
-  /**
-   * Emit a structured extension error to all listeners.
-   */
-  emitError(error) {
-    for (const listener of this.errorListeners) {
-      try {
-        listener(error);
-      } catch (err) {
-        console.error("[extension-runner] Error listener failed:", err);
-      }
-    }
-  }
-  // ---------------------------------------------------------------------------
-  // Lifecycle: invalidate / assertActive
-  // ---------------------------------------------------------------------------
-  /**
-   * Mark all extension contexts as stale.
-   * After calling this, any captured ExtensionAPI or ExtensionContext will throw
-   * on use. Used during session replacement or reload.
-   */
-  invalidate(message) {
-    this.runtime.invalidate(message);
-  }
-  // ---------------------------------------------------------------------------
-  // Direct hook API
-  // ---------------------------------------------------------------------------
-  /**
-   * Subscribe to a specific hook event type.
-   * Returns an unsubscribe function.
-   *
-   * @example
-   * ```ts
-   * const unsub = runner.on("before_tool_call", (event) => {
-   *   return { allow: false, reason: "Blocked" };
-   * });
-   * unsub(); // Cancel subscription
-   * ```
-   */
-  on(type, handler) {
-    this.hooks.on(type, handler);
-    return () => this.hooks.off(type, handler);
-  }
-  /**
-   * Subscribe to all events (read-only).
-   * Returns an unsubscribe function.
-   *
-   * @example
-   * ```ts
-   * const unsub = runner.subscribe((event) => {
-   *   console.log(event.type);
-   * });
-   * ```
-   */
-  subscribe(listener) {
-    const handlers = /* @__PURE__ */ new Map();
-    for (const eventType of this.getAllEventTypes()) {
-      const handler = (event) => listener(event);
-      handlers.set(eventType, handler);
-      this.hooks.on(eventType, handler);
-    }
-    return () => {
-      for (const [eventType, handler] of handlers) {
-        this.hooks.off(eventType, handler);
-      }
-    };
-  }
-  getAllEventTypes() {
-    return [
-      "before_phase",
-      "after_phase",
-      "before_prompt",
-      "before_tool_call",
-      "after_tool_call",
-      "agent_start",
-      "agent_end",
-      "turn_start",
-      "turn_end",
-      "message_start",
-      "message_update",
-      "message_end",
-      "tool_execution_start",
-      "tool_execution_update",
-      "tool_execution_end",
-      "queue_update",
-      "save_point",
-      "abort",
-      "settled"
-    ];
-  }
-  // ---------------------------------------------------------------------------
-  // Extension loading
-  // ---------------------------------------------------------------------------
-  /**
-   * Load and initialize extensions.
-   * Creates Extension tracking objects and calls each factory with an ExtensionAPI.
-   */
-  async loadExtensions(extensions) {
-    for (const ext of extensions) {
-      try {
-        const sourceInfo = createSourceInfo(ext.path, {
-          source: ext.path.startsWith("<builtin:") ? "builtin" : "local",
-          baseDir: ext.resolvedPath.startsWith("<") ? void 0 : ext.resolvedPath
-        });
-        const extension = createExtension(ext.path, ext.resolvedPath, sourceInfo);
-        const api = this.createExtensionAPI(extension, ext.manifest);
-        await ext.factory(api);
-        this.extensions.push(extension);
-        this.loadedExtensions.push(ext);
-        this._phaseCache = null;
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        this.emitError({
-          extensionPath: ext.path,
-          event: "load",
-          error: message,
-          stack: error instanceof Error ? error.stack : void 0
-        });
-        throw error;
-      }
-    }
-  }
-  // ---------------------------------------------------------------------------
-  // Tool management
-  // ---------------------------------------------------------------------------
-  /**
-   * Get all registered tools from all extensions (first registration per name wins).
-   */
-  getAllRegisteredTools() {
-    const toolsByName = /* @__PURE__ */ new Map();
-    for (const ext of this.extensions) {
-      for (const tool of ext.tools.values()) {
-        if (!toolsByName.has(tool.definition.name)) {
-          toolsByName.set(tool.definition.name, tool);
-        }
-      }
-    }
-    return Array.from(toolsByName.values());
-  }
-  /**
-   * Get a tool definition by name. Returns undefined if not found.
-   */
-  getToolDefinition(toolName) {
-    for (const ext of this.extensions) {
-      const tool = ext.tools.get(toolName);
-      if (tool) return tool.definition;
-    }
-    return void 0;
-  }
-  // ---------------------------------------------------------------------------
-  // Handler queries
-  // ---------------------------------------------------------------------------
-  /**
-   * Check if there are handlers registered for specified event type.
-   */
-  hasHandlers(eventType) {
-    return this.hooks.has(eventType);
-  }
-  /**
-   * Get the number of handlers for specified event type.
-   */
-  handlerCount(eventType) {
-    return this.hooks.count(eventType);
-  }
-  // ---------------------------------------------------------------------------
-  // Phase management
-  // ---------------------------------------------------------------------------
-  getPhase(id) {
-    const reg = this.getRegisteredPhase(id);
-    if (!reg) return void 0;
-    return this.adaptToPhase(reg);
-  }
-  getPhases() {
-    return [...this.collectRegisteredPhases().values()].map(
-      (p) => this.adaptToPhase(p)
-    );
-  }
-  createPhaseRegistry(input = {}) {
-    const registered = this.collectRegisteredPhases();
-    const phases = /* @__PURE__ */ new Map();
-    for (const [id, reg] of registered) {
-      phases.set(id, this.adaptToPhase(reg));
-    }
-    const entryPhaseId = input.entryPhaseId ?? null;
-    return { phases, entryPhaseId };
-  }
-  /** Adapt an extension RegisteredPhase to the core Phase type. */
-  adaptToPhase(reg) {
-    const def = reg.definition;
-    return {
-      id: def.id,
-      name: def.name ?? def.id,
-      description: def.description ?? "",
-      tools: def.tools,
-      skills: def.skills,
-      target: def.target,
-      input: def.input,
-      run: def.run,
-      filePath: "",
-      baseDir: "",
-      content: "",
-      ...def.model ? { model: parseModelRef(def.model) } : {}
-    };
-  }
-  // ---------------------------------------------------------------------------
-  // Lifecycle
-  // ---------------------------------------------------------------------------
-  /**
-   * Bind the runner — flushes pending provider registrations and
-   * replaces runtime stubs with real implementations.
-   */
-  bind() {
-    if (this.bound) return;
-    this.bound = true;
-    this.flushPendingProviders();
-    this.runtime.registerProvider = (_name, config) => {
-      applyProviderRegistration(config);
-    };
-    this.runtime.unregisterProvider = (_name) => {
-      applyProviderUnregistration(_name);
-    };
-  }
-  // ---------------------------------------------------------------------------
-  // Unified hook emission
-  // ---------------------------------------------------------------------------
-  /**
-   * Generic emit — fire-and-forget for any event type.
-   */
-  async emit(eventType, event) {
-    await this.hooks.emit(eventType, event);
-  }
-  /**
-   * Unified hook emission — returns the first non-undefined result.
-   */
-  async emitHook(type, event) {
-    return this.hooks.emitFirst(type, event);
-  }
-  // ---------------------------------------------------------------------------
-  // Phase hooks (with inline processing)
-  // ---------------------------------------------------------------------------
-  async emitBeforePhase(phaseId, input) {
-    const result = await this.emitHook("before_phase", {
-      type: "before_phase",
-      phaseId,
-      input
-    });
-    return result ?? {};
-  }
-  async emitAfterPhase(phaseId, output) {
-    const result = await this.emitHook("after_phase", {
-      type: "after_phase",
-      phaseId,
-      output
-    });
-    return result ?? {};
-  }
-  async emitBeforePrompt(phaseId, input) {
-    const result = await this.emitHook("before_prompt", {
-      type: "before_prompt",
-      phaseId,
-      input
-    });
-    return result?.input ?? input;
-  }
-  async emitBeforeToolCall(tool, args) {
-    const result = await this.emitHook("before_tool_call", {
-      type: "before_tool_call",
-      tool,
-      args
-    });
-    return result ?? { allow: true };
-  }
-  async emitAfterToolCall(tool, result) {
-    const hookResult = await this.emitHook("after_tool_call", {
-      type: "after_tool_call",
-      tool,
-      result
-    });
-    return hookResult?.result ?? result;
-  }
-  // ---------------------------------------------------------------------------
-  // Agent event hooks (fire-and-forget)
-  // ---------------------------------------------------------------------------
-  async emitAgentStart(sessionId) {
-    await this.hooks.emit("agent_start", { type: "agent_start", sessionId });
-  }
-  async emitAgentEnd(sessionId, outcome, messages) {
-    await this.hooks.emit("agent_end", { type: "agent_end", sessionId, outcome, messages });
-  }
-  async emitTurnStart(messages) {
-    await this.hooks.emit("turn_start", { type: "turn_start", messages });
-  }
-  async emitTurnEnd(messages, outcome) {
-    await this.hooks.emit("turn_end", { type: "turn_end", messages, outcome });
-  }
-  async emitMessageStart(message) {
-    await this.hooks.emit("message_start", { type: "message_start", message });
-  }
-  async emitMessageUpdate(message, delta) {
-    await this.hooks.emit("message_update", { type: "message_update", message, delta });
-  }
-  async emitMessageEnd(message) {
-    await this.hooks.emit("message_end", { type: "message_end", message });
-  }
-  async emitToolExecutionStart(toolCallId, toolName, args) {
-    await this.hooks.emit("tool_execution_start", {
-      type: "tool_execution_start",
-      toolCallId,
-      toolName,
-      args
-    });
-  }
-  async emitToolExecutionUpdate(toolCallId, toolName, _progress) {
-    await this.hooks.emit("tool_execution_update", {
-      type: "tool_execution_update",
-      toolCallId,
-      toolName
-    });
-  }
-  async emitToolExecutionEnd(toolCallId, toolName, result) {
-    await this.hooks.emit("tool_execution_end", {
-      type: "tool_execution_end",
-      toolCallId,
-      toolName,
-      result
-    });
-  }
-  async emitSavePoint(hadPendingMutations) {
-    await this.hooks.emit("save_point", { type: "save_point", hadPendingMutations });
-  }
-  async emitAbort(reason) {
-    await this.hooks.emit("abort", { type: "abort", reason });
-  }
-  async emitSettled() {
-    await this.hooks.emit("settled", { type: "settled" });
-  }
-  // ---------------------------------------------------------------------------
-  // AgentEvent bridge (backward compatibility)
-  // ---------------------------------------------------------------------------
-  /**
-   * Emit an AgentEvent by routing to the appropriate typed hook.
-   */
-  async emitAgentEvent(event) {
-    switch (event.type) {
-      case "agent_start":
-        await this.emitAgentStart(event.sessionId);
-        break;
-      case "agent_end":
-        await this.emitAgentEnd(event.sessionId, event.outcome, event.messages);
-        break;
-      case "turn_start":
-        await this.emitTurnStart(event.messages);
-        break;
-      case "turn_end":
-        await this.emitTurnEnd(event.messages, event.outcome);
-        break;
-      case "message_start":
-        await this.emitMessageStart(event.message);
-        break;
-      case "message_update":
-        await this.emitMessageUpdate(event.message, event.delta);
-        break;
-      case "message_end":
-        await this.emitMessageEnd(event.message);
-        break;
-      case "tool_execution_start":
-        await this.emitToolExecutionStart(event.toolCallId, event.toolName, event.args);
-        break;
-      case "tool_execution_update":
-        await this.emitToolExecutionUpdate(event.toolCallId, event.toolName);
-        break;
-      case "tool_execution_end":
-        await this.emitToolExecutionEnd(event.toolCallId, event.toolName, event.result);
-        break;
-    }
-  }
-  // ---------------------------------------------------------------------------
-  // Internal helpers
-  // ---------------------------------------------------------------------------
-  /**
-   * Create an ExtensionAPI for a specific extension.
-   * Registration methods write to the extension tracking object.
-   * Action methods delegate to the shared runtime.
-   */
-  createExtensionAPI(extension, manifest) {
-    const runner = this;
-    const extContext = {
-      get cwd() {
-        return runner.cwd;
-      },
-      get signal() {
-        return runner.abortController.signal;
-      },
-      isIdle() {
-        return runner._idle;
-      },
-      abort() {
-        runner.abortController.abort();
-      },
-      exec(command, args, options) {
-        return execCommand(command, args, runner.cwd, options);
-      },
-      manifest,
-      getSystemPrompt() {
-        return runner.currentContext?.systemPrompt ?? "";
-      },
-      setSystemPrompt(prompt) {
-        if (runner.currentContext) runner.currentContext.systemPrompt = prompt;
-      },
-      getMessages() {
-        return runner.currentContext?.messages ?? [];
-      },
-      addMessage(role, content) {
-        runner.currentContext?.messages.push({ role, content });
-      },
-      getAvailableTools() {
-        return (runner.currentContext?.tools ?? []).map((t) => ({ name: t.name, description: t.description }));
-      },
-      getAvailableSkills() {
-        return (runner.currentContext?.skills ?? []).map((s) => ({ name: s.name, description: s.description }));
-      },
-      getSkillContent(skillName) {
-        const skill = runner.currentContext?.skills.find((s) => s.name === skillName);
-        return skill?.content ?? "";
-      },
-      getAvailablePhases() {
-        return [...runner.phases.keys()];
-      },
-      getPhaseContent(phaseId) {
-        return runner.phases.get(phaseId)?.definition.description ?? "";
-      }
-    };
-    return createExtensionAPI(this.hooks, extension.path, {
-      registerPhase: (registration) => this.registerPhase(extension, registration),
-      registerProvider: (config) => this.registerProvider(config),
-      unregisterProvider: (name) => this.unregisterProvider(name),
-      registerTool: (tool) => this.registerTool(extension, tool),
-      context: extContext,
-      manifest
-    }, this.runtime, this.events);
-  }
-  registerTool(extension, tool) {
-    for (const ext of this.extensions) {
-      if (ext.tools.has(tool.name)) {
-        this.emitError({
-          extensionPath: extension.path,
-          event: "register_tool",
-          error: `Tool "${tool.name}" is already registered by extension ${ext.path}`
-        });
-        return;
-      }
-    }
-    const sourceInfo = createSourceInfo(extension.path);
-    extension.tools.set(tool.name, {
-      definition: tool,
-      sourceInfo
-    });
-  }
-  registerPhase(extension, registration) {
-    if (!registration.id) {
-      throw new Error(`Phase registration requires an "id" field.`);
-    }
-    if (!registration.name) {
-      throw new Error(`Phase registration "${registration.id}" requires a "name" field.`);
-    }
-    if (!registration.description) {
-      throw new Error(`Phase registration "${registration.id}" requires a "description" field.`);
-    }
-    if (this.phases.has(registration.id)) {
-      throw new Error(`Duplicate phase id: ${registration.id}`);
-    }
-    const definition = {
-      id: registration.id,
-      name: registration.name,
-      description: registration.description,
-      run: registration.run,
-      ...registration.model ? { model: registration.model } : {}
-    };
-    const registered = {
-      definition,
-      source: { extensionPath: extension.path }
-    };
-    this.phases.set(registration.id, registered);
-    extension.phases.set(registration.id, registered);
-    this._phaseCache = null;
-  }
-  registerProvider(config) {
-    if (this.bound) {
-      applyProviderRegistration(config);
-    } else {
-      this.pendingProviders.push({ kind: "register", config });
-    }
-  }
-  unregisterProvider(name) {
-    if (this.bound) {
-      applyProviderUnregistration(name);
-    } else {
-      this.pendingProviders.push({ kind: "unregister", name });
-    }
-  }
-  flushPendingProviders() {
-    for (const action of this.pendingProviders) {
-      if (action.kind === "register") {
-        applyProviderRegistration(action.config);
-      } else {
-        applyProviderUnregistration(action.name);
-      }
-    }
-    this.pendingProviders.length = 0;
-  }
-  getRegisteredPhase(id) {
-    return this.collectRegisteredPhases().get(id);
-  }
-  collectRegisteredPhases() {
-    if (this._phaseCache) return this._phaseCache;
-    this._phaseCache = new Map(this.phases);
-    return this._phaseCache;
-  }
-};
-function createExtensionRunner(options) {
-  return new ExtensionRunner(options);
-}
-
-// src/extensions/loader.ts
-var import_node_fs6 = require("fs");
-var import_promises7 = require("fs/promises");
-var import_node_url = require("url");
-var import_node_path8 = require("path");
-var import_jiti = require("jiti");
-var import_meta2 = {};
-var ROWAN_DIR = ".rowan";
-var EXTENSIONS_DIR = "extensions";
-function isExtensionFile(path) {
-  const extension = (0, import_node_path8.extname)(path).toLowerCase();
-  return extension === ".ts" || extension === ".js";
-}
-function isSyntheticPath(path) {
-  return path.startsWith("<") && path.endsWith(">");
-}
-function readManifestSync(dir) {
-  const manifestPath = (0, import_node_path8.join)(dir, "package.json");
-  if (!(0, import_node_fs6.existsSync)(manifestPath)) {
-    return void 0;
-  }
-  try {
-    const content = (0, import_node_fs6.readFileSync)(manifestPath, "utf8");
-    const pkg = JSON.parse(content);
-    const rowan = pkg.rowan;
-    if (!rowan) return void 0;
-    return {
-      entry: rowan.extensions?.[0],
-      phase: rowan.phase
-    };
-  } catch {
-    return void 0;
-  }
-}
-function jitiAliases() {
-  const moduleUrl = import_meta2.url;
-  if (!moduleUrl) {
-    return {};
-  }
-  const agentSourcePath = (0, import_node_url.fileURLToPath)(new URL("../index.ts", moduleUrl));
-  if (!(0, import_node_fs6.existsSync)(agentSourcePath)) {
-    return {};
-  }
-  return { "@rowan-agent/agent": agentSourcePath };
-}
-var sharedJiti;
-function getJiti() {
-  sharedJiti ??= (0, import_jiti.createJiti)(import_meta2.url || process.cwd(), {
-    moduleCache: false,
-    alias: jitiAliases()
-  });
-  return sharedJiti;
-}
-async function loadExtensionModule(extensionPath) {
-  const jiti = getJiti();
-  const module2 = await jiti.import(extensionPath, { default: true });
-  return typeof module2 === "function" ? module2 : void 0;
-}
-async function readPackageManifest(path) {
-  if (!(0, import_node_fs6.existsSync)(path)) {
-    return void 0;
-  }
-  const content = await (0, import_promises7.readFile)(path, "utf8");
-  return JSON.parse(content);
-}
-async function resolveExtensionEntries(dir) {
-  const manifest = await readPackageManifest((0, import_node_path8.join)(dir, "package.json"));
-  const declared = manifest?.rowan?.extensions;
-  if (declared && declared.length > 0) {
-    return declared.map((entry) => (0, import_node_path8.resolve)(dir, entry));
-  }
-  for (const name of ["index.ts", "index.js"]) {
-    const entry = (0, import_node_path8.join)(dir, name);
-    if ((0, import_node_fs6.existsSync)(entry)) {
-      return [entry];
-    }
-  }
-  return void 0;
-}
-async function discoverExtensionsInDir(dir) {
-  const entries = await (0, import_promises7.readdir)(dir, { withFileTypes: true }).catch((error) => {
-    if (error.code === "ENOENT") {
-      return [];
-    }
-    throw error;
-  });
-  const paths = [];
-  for (const entry of [...entries].sort((a, b) => a.name.localeCompare(b.name))) {
-    const entryPath = (0, import_node_path8.join)(dir, entry.name);
-    if ((entry.isFile() || entry.isSymbolicLink()) && isExtensionFile(entry.name)) {
-      paths.push(entryPath);
-      continue;
-    }
-    if (entry.isDirectory() || entry.isSymbolicLink()) {
-      const info = entry.isSymbolicLink() ? await (0, import_promises7.stat)(entryPath).catch(() => void 0) : void 0;
-      if (entry.isDirectory() || info?.isDirectory()) {
-        const resolvedEntries = await resolveExtensionEntries(entryPath);
-        if (resolvedEntries) {
-          paths.push(...resolvedEntries);
-        }
-      }
-    }
-  }
-  return paths;
-}
-function loadExtensionFromFactory(factory, cwd, extensionPath = "<inline>") {
-  const resolvedCwd = (0, import_node_path8.resolve)(cwd);
-  const resolvedPath = isSyntheticPath(extensionPath) ? extensionPath : (0, import_node_path8.resolve)(resolvedCwd, extensionPath);
-  const name = isSyntheticPath(extensionPath) ? extensionPath : (0, import_node_path8.dirname)(resolvedPath).split("/").pop() ?? "unknown";
-  const manifestDir = isSyntheticPath(extensionPath) ? resolvedCwd : (0, import_node_path8.dirname)(resolvedPath);
-  const manifest = readManifestSync(manifestDir);
-  return {
-    path: extensionPath,
-    resolvedPath,
-    name,
-    factory,
-    manifest
-  };
-}
-async function loadExtensions(paths, cwd) {
-  const extensions = [];
-  const errors = [];
-  const resolvedCwd = (0, import_node_path8.resolve)(cwd);
-  for (const path of paths) {
-    const resolvedPath = (0, import_node_path8.resolve)(resolvedCwd, path);
-    try {
-      const factory = await loadExtensionModule(resolvedPath);
-      if (!factory) {
-        errors.push({
-          path: resolvedPath,
-          error: `Extension does not export a valid factory function: ${path}`
-        });
-        continue;
-      }
-      extensions.push(loadExtensionFromFactory(factory, resolvedCwd, resolvedPath));
-    } catch (error) {
-      errors.push({
-        path: resolvedPath,
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  return { extensions, errors };
-}
-async function discoverAndLoadExtensions(cwd) {
-  const extensionsDir = (0, import_node_path8.join)((0, import_node_path8.resolve)(cwd), ROWAN_DIR, EXTENSIONS_DIR);
-  const paths = await discoverExtensionsInDir(extensionsDir);
-  return loadExtensions(paths, cwd);
-}
-
-// src/index.ts
-init_loader2();
-
-// src/harness/context/index.ts
-init_resource_formatter();
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Agent,
-  AgentEventStream,
-  EventStream,
-  ExtensionRunner,
-  HooksManager,
-  LocalJsonlSessionManager,
-  appendUserTurn,
-  buildModelRequest,
-  buildSystemPrompt,
-  conversationMessages,
-  createCoreTools,
-  createEventBus,
-  createExtension,
-  createExtensionAPI,
-  createExtensionRunner,
-  createExtensionRuntime,
-  createId,
-  createMessage,
-  createSession,
-  createSourceInfo,
-  createTimestamp,
-  discoverAndLoadExtensions,
-  getGlobalHooks,
-  interpolateEnvVars,
-  latestUserInput,
-  loadConfigFile,
-  loadExtensionFromFactory,
-  loadExtensions,
-  loadPhases,
-  loadSkill,
-  loadSkills,
-  messageContentText,
-  parseModelRef,
-  registerConfigModels,
-  resetGlobalHooks,
-  resolveDefaultModel,
-  resolveInWorkspace,
-  resolveSkillPath,
-  resolveWorkspacePaths,
-  serializeSkills
-});