@rowan-agent/agent 0.4.11 → 0.5.1

package/dist/index.js

@@ -1,28 +1,3 @@
-import {
-  buildPhaseDirectiveMessage,
-  buildSkillsDescription,
-  buildStructuredSection,
-  detectResourceType,
-  formatResourceOutput,
-  inferResourceName,
-  interpolateEnvVars,
-  loadConfigFile,
-  loadMarkdown,
-  loadPhases,
-  parseFrontmatter,
-  parseModelRef,
-  readPhaseContent,
-  registerConfigModels,
-  reloadPhases,
-  resolveDefaultModel,
-  resolveResourcePath
-} from "./chunk-FTIS43EE.js";
-import {
-  normalizeRelativePath,
-  resolveInWorkspace,
-  resolveWorkspacePaths
-} from "./chunk-2FIII4GP.js";
-
 // src/utils.ts
 function createId(prefix) {
   return `${prefix}_${crypto.randomUUID().slice(0, 8)}`;
@@ -46,6 +21,19 @@ var EmptyResponseError = class extends Error {
     this.name = "EmptyResponseError";
   }
 };
+var MissingRouteToolCallError = class extends Error {
+  code = "missing_route_tool_call";
+  phase;
+  toolCallNames;
+  constructor(phase, toolCallNames) {
+    super(
+      `Phase "${phase}" requires a route tool call, but the model did not emit one.`
+    );
+    this.name = "MissingRouteToolCallError";
+    this.phase = phase;
+    this.toolCallNames = toolCallNames;
+  }
+};
 var LoopGuard = {
   /** Returns abort result if signal is aborted */
   checkAbort(signal) {
@@ -379,12 +367,596 @@ function createExtensionAPI(hooks, _extensionPath, options, runtime, eventBus) {
   };
 }
 
+// src/harness/phases/loader.ts
+import { existsSync as existsSync2, statSync } from "fs";
+import { readdir } from "fs/promises";
+import { dirname as dirname2, join as join2, resolve } from "path";
+
+// src/harness/loader.ts
+import { readFile } from "fs/promises";
+import { basename, dirname, extname } from "path";
+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 readFile(filePath, "utf8");
+  const { frontmatter, body } = parseFrontmatter(raw);
+  return { frontmatter, body, raw };
+}
+function inferResourceName(path, markerFile) {
+  const file = basename(path);
+  if (file.toLowerCase() === markerFile.toLowerCase()) {
+    return basename(dirname(path));
+  }
+  const extension = extname(file);
+  return extension ? file.slice(0, -extension.length) : file;
+}
+
+// src/harness/config.ts
+import { existsSync } from "fs";
+import { readFile as readFile2 } from "fs/promises";
+import { join } from "path";
+import { parse as parseYaml } from "yaml";
+import { registerModel } from "@rowan-agent/models";
+var DEFAULT_REASONING = false;
+var DEFAULT_INPUT = ["text"];
+var DEFAULT_CONTEXT_WINDOW = 128e3;
+var DEFAULT_MAX_TOKENS = 16384;
+var DEFAULT_COST = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+var DEFAULT_TIMEOUT_MS = 6e4;
+var ENV_VAR_PATTERN = /\$\{([^}]+)\}/g;
+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;
+  });
+}
+var CONFIG_CANDIDATES = ["config.yaml", "config.yml"];
+async function loadConfigFile(workspace) {
+  let configPath;
+  let configFilename;
+  for (const candidate of CONFIG_CANDIDATES) {
+    const p = join(workspace.rowanDir, candidate);
+    if (existsSync(p)) {
+      configPath = p;
+      configFilename = candidate;
+      break;
+    }
+  }
+  if (!configPath || !configFilename) {
+    return void 0;
+  }
+  const raw = await readFile2(configPath, "utf8");
+  let parsed;
+  try {
+    parsed = parseYaml(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 } : {}
+      };
+      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)
+  };
+}
+
+// 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
+  }];
+}
+
+// src/harness/phases/loader.ts
+var PHASE_MARKER = "PHASE.md";
+function resolvePhasePath(input) {
+  const resolved = resolve(input);
+  return existsSync2(resolved) && statSync(resolved).isDirectory() ? join2(resolved, PHASE_MARKER) : resolved;
+}
+async function loadPhase(targetPath) {
+  const resolved = resolvePhasePath(targetPath);
+  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 = dirname2(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
+  });
+}
+function resolvePhaseLoadTarget(targetPath) {
+  return typeof targetPath === "string" ? targetPath : join2(targetPath.rowanDir, "phases");
+}
+async function loadPhases(targetPath) {
+  const phases = /* @__PURE__ */ new Map();
+  const phasesDir = resolve(resolvePhaseLoadTarget(targetPath));
+  if (existsSync2(phasesDir) && statSync(phasesDir).isFile()) {
+    const phase = await loadPhase(phasesDir);
+    phases.set(phase.id, phase);
+    return { phases, entryPhaseId: null };
+  }
+  if (existsSync2(join2(phasesDir, PHASE_MARKER))) {
+    const phase = await loadPhase(phasesDir);
+    phases.set(phase.id, phase);
+    return { phases, entryPhaseId: null };
+  }
+  const entries = await readdir(phasesDir, { withFileTypes: true });
+  for (const entry of [...entries].sort((a, b) => a.name.localeCompare(b.name))) {
+    if (!entry.isDirectory()) continue;
+    const phaseFile = join2(phasesDir, entry.name, PHASE_MARKER);
+    if (!existsSync2(phaseFile)) continue;
+    try {
+      const phase = await loadPhase(phaseFile);
+      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 = join2(baseDir, candidate);
+    if (existsSync2(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) {
+  for (const [id, phase] of registry.phases) {
+    if (!phase.filePath) {
+      continue;
+    }
+    try {
+      const fresh = await loadPhase(phase.filePath);
+      registry.phases.set(id, fresh);
+    } catch (error) {
+      console.warn(`Failed to reload phase "${id}":`, error);
+    }
+  }
+}
+
+// src/harness/phases/default.ts
+var DEFAULT_PHASE_ID = "default";
+function createDefaultPhase() {
+  return {
+    id: DEFAULT_PHASE_ID,
+    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."
+  };
+}
+
 // src/harness/tools/index.ts
-import { mkdir, readFile, stat, writeFile } from "fs/promises";
-import { basename, dirname, isAbsolute, relative, resolve, sep } from "path";
+import { mkdir, readFile as readFile3, stat, writeFile } from "fs/promises";
+import { basename as basename2, dirname as dirname4, isAbsolute as isAbsolute2, relative as relative2, resolve as resolve3, sep as sep2 } from "path";
 import Type2 from "typebox";
 import Schema from "typebox/schema";
 
+// src/harness/env/path.ts
+import { existsSync as existsSync3, readFileSync } from "fs";
+import { homedir } from "os";
+import { dirname as dirname3, isAbsolute, join as join3, parse, relative, resolve as resolve2, sep } from "path";
+var WORKSPACE_ENV = "ROWAN_WORKSPACE";
+var BINARY_WORKSPACE_DIR = ".rowan";
+function nonEmptyEnv(env, key) {
+  const value = env[key]?.trim();
+  return value ? value : void 0;
+}
+function resolveUserPath(path, homeDir) {
+  if (path === "~") {
+    return homeDir;
+  }
+  if (path.startsWith("~/") || path.startsWith("~\\")) {
+    return join3(homeDir, path.slice(2));
+  }
+  return resolve2(path);
+}
+function isSourceWorkspaceRoot(path) {
+  const packagePath = join3(path, "package.json");
+  if (!existsSync3(packagePath)) {
+    return false;
+  }
+  try {
+    const manifest = JSON.parse(readFileSync(packagePath, "utf8"));
+    return manifest.name === "rowan-agent" || Array.isArray(manifest.workspaces);
+  } catch {
+    return false;
+  }
+}
+function findSourceWorkspaceRoot(startDir = process.cwd()) {
+  let current = resolve2(startDir);
+  const { root } = parse(current);
+  while (true) {
+    if (isSourceWorkspaceRoot(current)) {
+      return current;
+    }
+    if (current === root) {
+      return resolve2(startDir);
+    }
+    current = dirname3(current);
+  }
+}
+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 ?? homedir();
+  const override = nonEmptyEnv(env, WORKSPACE_ENV);
+  if (override) {
+    return resolveUserPath(override, homeDir);
+  }
+  return findSourceWorkspaceRoot(defaultWorkspaceStartDir(options));
+}
+function resolveWorkspacePaths(options = {}) {
+  const cwd = resolveWorkspaceRoot(options);
+  return {
+    cwd,
+    rowanDir: resolveProjectRowanDir(cwd, options.rowanDir)
+  };
+}
+function resolveProjectRowanDir(cwd, rowanDir = BINARY_WORKSPACE_DIR) {
+  const inputPath = rowanDir.trim() || BINARY_WORKSPACE_DIR;
+  if (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, homedir());
+  }
+  if (isAbsolute(path)) {
+    return path;
+  }
+  const root = typeof rootOrPaths === "string" ? rootOrPaths : rootOrPaths.cwd;
+  return resolve2(root, path);
+}
+function normalizeRelativePath(path) {
+  return path.split(sep).join("/");
+}
+function normalizeWorkspaceInputPath(path = ".") {
+  const trimmed = path.trim();
+  if (!trimmed || trimmed === "/" || trimmed === "\\") {
+    return ".";
+  }
+  return path;
+}
+function resolveWorkspacePath(context, path = ".") {
+  const root = resolve2(context.root);
+  const inputPath = normalizeWorkspaceInputPath(path);
+  const absolutePath = resolve2(root, inputPath);
+  const relativePath = relative(root, absolutePath);
+  if (relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)) {
+    throw new Error(`Path escapes workspace root: ${path}`);
+  }
+  return {
+    root,
+    inputPath,
+    absolutePath,
+    relativePath: normalizeRelativePath(relativePath || ".")
+  };
+}
+
 // src/harness/tools/route-tool.ts
 import Type from "typebox";
 var PhaseRouteTool = "route";
@@ -536,18 +1108,18 @@ function normalizeCoreToolInputPath(path = ".") {
 }
 function createCoreToolContext(input = {}) {
   return {
-    root: resolve(input.root ?? process.cwd()),
+    root: resolve3(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 = resolve(context.root);
+  const root = resolve3(context.root);
   const inputPath = normalizeCoreToolInputPath(path);
-  const absolutePath = resolve(root, inputPath);
-  const relativePath = relative(root, absolutePath);
-  if (relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)) {
+  const absolutePath = resolve3(root, inputPath);
+  const relativePath = relative2(root, absolutePath);
+  if (relativePath === ".." || relativePath.startsWith(`..${sep2}`) || isAbsolute2(relativePath)) {
     throw new Error(`Path escapes workspace root: ${path}`);
   }
   return {
@@ -726,7 +1298,7 @@ function createReadTool(context) {
           error: `Not a file: ${resolved.relativePath}`
         });
       }
-      const bytes = await readFile(resolved.absolutePath);
+      const bytes = await readFile3(resolved.absolutePath);
       const sliced = bytes.subarray(0, maxBytes);
       const text = new TextDecoder().decode(sliced);
       const resourceType = parsed.type ?? detectResourceType(resolved.absolutePath);
@@ -736,9 +1308,9 @@ function createReadTool(context) {
         const { frontmatter } = parseFrontmatter(text);
         const marker = resourceType === "skill" ? "SKILL.md" : "PHASE.md";
         name = frontmatter.name ?? inferResourceName(resolved.absolutePath, marker);
-        baseDir = dirname(resolved.absolutePath);
+        baseDir = dirname4(resolved.absolutePath);
       } else {
-        name = inferResourceName(resolved.absolutePath, basename(resolved.absolutePath));
+        name = inferResourceName(resolved.absolutePath, basename2(resolved.absolutePath));
       }
       return toolResult({
         context: toolContext,
@@ -767,7 +1339,7 @@ function createWriteTool(context) {
     async execute(args, toolContext) {
       const parsed = WriteArgsValidator.Parse(args);
       const resolved = resolveCoreToolPath(context, parsed.path);
-      await mkdir(dirname(resolved.absolutePath), { recursive: true });
+      await mkdir(dirname4(resolved.absolutePath), { recursive: true });
       await writeFile(resolved.absolutePath, parsed.content, "utf8");
       return toolResult({
         context: toolContext,
@@ -804,7 +1376,7 @@ function createEditTool(context) {
         });
       }
       const resolved = resolveCoreToolPath(context, parsed.path);
-      const current = await readFile(resolved.absolutePath, "utf8");
+      const current = await readFile3(resolved.absolutePath, "utf8");
       if (!current.includes(parsed.oldText)) {
         return toolResult({
           context: toolContext,
@@ -1287,25 +1859,13 @@ async function runTurn(context, emitFn, fn) {
   }
 }
 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 = config.context.phases;
+  if (!registry) {
+    throw new Error("AgentContext.phases is required. Construct Agent to apply the default phase.");
+  }
+  if (!registry.entryPhaseId) {
+    throw new Error("AgentContext.phases.entryPhaseId is required. Construct Agent to apply the default phase.");
   }
-  const registry = {
-    phases,
-    entryPhaseId
-  };
   return runPhaseLoop(config, state, registry);
 }
 async function runPhaseLoop(config, state, registry) {
@@ -1316,10 +1876,6 @@ async function runPhaseLoop(config, state, registry) {
   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 });
@@ -1429,6 +1985,14 @@ async function runPhaseLoop(config, state, registry) {
         output = extAfter.output;
       }
     }
+    const routeToolAvailable = phaseContext.tools.some((tool) => tool.name === PhaseRouteTool);
+    const routeRequired = !phase.target && !phase.run && !phase.factory && routeToolAvailable && registry.phases.size > 1;
+    if (routeRequired && !routeDecision) {
+      throw new MissingRouteToolCallError(
+        currentPhaseId,
+        output.toolCalls?.map((toolCall) => toolCall.name) ?? []
+      );
+    }
     if (output.route === "continue") {
       isContinuing = true;
       continue;
@@ -1451,7 +2015,7 @@ async function runPhaseLoop(config, state, registry) {
       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";
+      const entryPhaseId = phase.target ?? registry.entryPhaseId;
       if (entryPhaseId === "stop") {
         return completeRun(config, state, createOutcome.default(output, config.context.messages));
       }
@@ -1529,7 +2093,7 @@ async function withRetry(fn, options = {}) {
       }
       const delayMs = getRetryDelay(attempt, baseDelayMs, maxDelayMs);
       options.onRetry?.(attempt, error, delayMs);
-      await new Promise((resolve4) => setTimeout(resolve4, delayMs));
+      await new Promise((resolve7) => setTimeout(resolve7, delayMs));
       if (options.signal?.aborted) {
         throw lastError;
       }
@@ -1790,12 +2354,13 @@ async function completeRun2(config, state, outcome) {
 }
 
 // src/harness/skills.ts
-import { existsSync } from "fs";
-import { readdir } from "fs/promises";
-import { dirname as dirname2, join } from "path";
+import { existsSync as existsSync4, statSync as statSync2 } from "fs";
+import { readdir as readdir2 } from "fs/promises";
+import { dirname as dirname5, join as join4, resolve as resolve4 } from "path";
 var SKILL_MARKER = "SKILL.md";
-function resolveSkillPath(input, workspace = resolveWorkspacePaths()) {
-  return resolveResourcePath(input, "skills", SKILL_MARKER, workspace);
+function resolveSkillPath(input) {
+  const resolved = resolve4(input);
+  return existsSync4(resolved) && statSync2(resolved).isDirectory() ? join4(resolved, SKILL_MARKER) : resolved;
 }
 function readSkillContent(skill) {
   return formatResourceOutput({
@@ -1806,35 +2371,34 @@ function readSkillContent(skill) {
     baseDir: skill.baseDir
   });
 }
-async function loadSkill(path, workspace) {
-  const resolved = resolveSkillPath(path, workspace);
+async function loadSkill(path) {
+  const resolved = resolveSkillPath(path);
   const { frontmatter, body } = await loadMarkdown(resolved);
   return {
     name: frontmatter.name ?? inferResourceName(resolved, SKILL_MARKER),
     description: frontmatter.description ?? "",
     filePath: resolved,
-    baseDir: dirname2(resolved),
+    baseDir: dirname5(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)));
+async function loadSkills(targetPath) {
+  const skillsDir = resolve4(targetPath);
+  if (existsSync4(skillsDir) && statSync2(skillsDir).isFile()) {
+    return [await loadSkill(skillsDir)];
   }
-  const ws = workspace ?? resolveWorkspacePaths();
-  const skillsDir = join(ws.rowanDir, "skills");
-  if (!existsSync(skillsDir)) {
-    return [];
+  if (existsSync4(join4(skillsDir, SKILL_MARKER))) {
+    return [await loadSkill(skillsDir)];
   }
-  const entries = await readdir(skillsDir, { withFileTypes: true });
+  const entries = await readdir2(skillsDir, { withFileTypes: true });
   const skills = [];
-  for (const entry of entries) {
+  for (const entry of [...entries].sort((a, b) => a.name.localeCompare(b.name))) {
     if (!entry.isDirectory()) continue;
-    const skillFile = join(skillsDir, entry.name, SKILL_MARKER);
-    if (!existsSync(skillFile)) continue;
+    const skillFile = join4(skillsDir, entry.name, SKILL_MARKER);
+    if (!existsSync4(skillFile)) continue;
     try {
-      const skill = await loadSkill(entry.name, ws);
+      const skill = await loadSkill(skillFile);
       skills.push(skill);
     } catch (error) {
       console.warn(`Failed to load skill "${entry.name}":`, error);
@@ -1843,1850 +2407,1855 @@ async function loadSkills(workspace, paths) {
   return skills;
 }
 
-// src/agent.ts
-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
-    };
+// 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";
   }
-  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);
+  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);
   }
   /**
-   * Hook for before_tool_call — called before a tool executes.
-   * Extensions can block execution by setting allow=false.
+   * Unregister a hook handler.
    */
-  async handleBeforeToolCall(tool, args) {
-    const runner = this.options.extensionRunnerRef?.current;
-    if (!runner) return { allow: true };
-    return runner.emitBeforeToolCall(tool, args);
+  off(eventType, handler) {
+    const handlers = this.handlers.get(eventType);
+    if (!handlers) return;
+    const index = handlers.indexOf(handler);
+    if (index >= 0) handlers.splice(index, 1);
   }
   /**
-   * Hook for after_tool_call — called after a tool executes.
-   * Extensions can mutate the result.
+   * Clear all handlers, or clear handlers for specified event type.
    */
-  async handleAfterToolCall(tool, result) {
-    const runner = this.options.extensionRunnerRef?.current;
-    if (!runner) return result;
-    return runner.emitAfterToolCall(tool, result);
+  clear(eventType) {
+    if (eventType) {
+      this.handlers.delete(eventType);
+    } else {
+      this.handlers.clear();
+    }
   }
   /**
-   * Hook for before_phase — called before a phase executes.
-   * Extensions can abort, skip, or replace the phase input.
+   * Check if there are handlers registered for specified event type.
    */
-  async handleBeforePhase(phaseId, input) {
-    const runner = this.options.extensionRunnerRef?.current;
-    if (!runner) return {};
-    return runner.emitBeforePhase(phaseId, input);
+  has(eventType) {
+    const handlers = this.handlers.get(eventType);
+    return handlers !== void 0 && handlers.length > 0;
   }
   /**
-   * Hook for after_phase — called after a phase executes.
-   * Extensions can abort, retry, or replace the output.
+   * Get handler count for specified event type.
    */
-  async handleAfterPhase(phaseId, output) {
-    const runner = this.options.extensionRunnerRef?.current;
-    if (!runner) return {};
-    return runner.emitAfterPhase(phaseId, output);
+  count(eventType) {
+    return this.handlers.get(eventType)?.length ?? 0;
   }
   /**
-   * Hook for before_prompt — called before model request, allowing extensions to transform PhaseContext.
-   * Extensions can transform the PhaseContext (messages, tools, systemPrompt, etc.).
+   * Emit event (listen-only, ignore return values).
+   * Errors are collected and thrown.
+   *
+   * @param eventType - Event type
+   * @param event - Event object
    */
-  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;
+  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]
+      );
+    }
   }
   /**
-   * Discover and load phases and skills from the workspace.
+   * Emit event and return first non-undefined result (short-circuit).
    *
-   * - Auto-discovers file-based phases from .rowan/phases/
-   * - Auto-discovers skills from .rowan/skills/
-   * - Merges with CLI-provided phases and skills
+   * @param eventType - Event type
+   * @param event - Event object
+   * @returns First non-undefined result, or undefined
    */
-  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);
+  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))
+        );
       }
-      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 };
+    return void 0;
   }
-  async runWithLifecycle(executor) {
-    if (this.activeRun) {
-      throw new Error("Agent is already running.");
-    }
-    let resolvePromise;
-    const abortController = new AbortController();
-    const promise = new Promise((resolve4) => {
-      resolvePromise = resolve4;
-    });
-    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();
+};
+var _globalHooks;
+function getGlobalHooks() {
+  _globalHooks ??= new HooksManager();
+  return _globalHooks;
+}
+function resetGlobalHooks() {
+  _globalHooks = void 0;
+}
+
+// src/extensions/runner.ts
+import { execFile } from "child_process";
+import {
+  registerModel as registerModel2,
+  unregisterProviderModels,
+  registerApiProvider
+} from "@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, sourceInfo) {
+  return {
+    path: extensionPath,
+    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);
     }
-  }
-  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;
+  };
+  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
+      );
     }
-    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);
+  };
+  return runtime;
+}
+
+// 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);
       };
-      const beforeToolCall = async (input) => {
-        if (resolved.beforeToolCall) {
-          const userResult = await resolved.beforeToolCall(input);
-          if (!userResult.allow) return userResult;
+    },
+    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);
         }
-        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 });
+      }
+    },
+    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((resolve7, reject) => {
+    const child = 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;
         }
-        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;
+        resolve7({
+          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) {
+    registerApiProvider({ protocol: config.protocol, stream: config.streamSimple });
+  }
+  for (const modelConfig of config.models) {
+    registerModel2({
+      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 } : {}
     });
   }
-  abort(reason = "Aborted by caller.") {
-    this.activeRun?.abortController.abort(reason);
+}
+function applyProviderUnregistration(name) {
+  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
+  // ---------------------------------------------------------------------------
   /**
-   * 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
+   * Register an error listener.
+   * Returns an unsubscribe function.
    */
-  skill(name, additionalInstructions) {
-    const skill = this.state.context.skills.find((s) => s.name === name);
-    if (!skill) {
-      throw new Error(`Unknown skill: ${name}`);
+  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);
+      }
     }
-    const content = readSkillContent(skill);
-    return additionalInstructions ? `${content}
-
-${additionalInstructions}` : content;
   }
+  // ---------------------------------------------------------------------------
+  // Lifecycle: invalidate / assertActive
+  // ---------------------------------------------------------------------------
   /**
-   * 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.
+   * 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.
    *
-   * @param name - The phase name to look up
-   * @returns Formatted phase content string, or empty string if not found
+   * @example
+   * ```ts
+   * const unsub = runner.on("before_tool_call", (event) => {
+   *   return { allow: false, reason: "Blocked" };
+   * });
+   * unsub(); // Cancel subscription
+   * ```
    */
-  async phase(name) {
-    const workspace = resolveWorkspacePaths({ cwd: this.options.cwd, rowanDir: this.options.rowanDir });
-    const { loadPhase: loadPhase2, readPhaseContent: readPhaseContent2 } = await import("./loader-HCYCHPGT.js");
-    try {
-      const phase = await loadPhase2(name, workspace);
-      return readPhaseContent2(phase);
-    } catch {
-      return "";
-    }
+  on(type, handler) {
+    this.hooks.on(type, handler);
+    return () => this.hooks.off(type, handler);
   }
-  async waitForIdle() {
-    if (!this.activeRun) {
-      return;
+  /**
+   * 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);
     }
-    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
+    return () => {
+      for (const [eventType, handler] of handlers) {
+        this.hooks.off(eventType, handler);
+      }
     };
   }
-  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
-import Type3 from "typebox";
-var SESSION_SCHEMA_VERSION = "0.4.4";
-var AgentMessageSchema = Type3.Object({
-  id: Type3.String(),
-  role: Type3.Union([
-    Type3.Literal("system"),
-    Type3.Literal("user"),
-    Type3.Literal("assistant"),
-    Type3.Literal("tool")
-  ]),
-  content: Type3.Union([Type3.String(), Type3.Array(Type3.Unknown())]),
-  createdAt: Type3.String(),
-  metadata: Type3.Optional(Type3.Record(Type3.String(), Type3.Unknown()))
-});
-var SkillSchema = Type3.Object({
-  name: Type3.String(),
-  description: Type3.String(),
-  filePath: Type3.String(),
-  baseDir: Type3.String(),
-  content: Type3.String(),
-  disableModelInvocation: Type3.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));
+  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"
+    ];
   }
-  static fromRecords(records) {
-    const [header, ...entries] = records;
-    if (!header || header.type !== "header") {
-      throw new Error("Session records must start with a header.");
+  // ---------------------------------------------------------------------------
+  // 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: "local",
+          baseDir: ext.path.startsWith("<") ? void 0 : ext.path
+        });
+        const extension = createExtension(ext.path, 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;
+      }
     }
-    return new _InMemorySessionManager(clone(header), clone(entries));
   }
-  getSessionId() {
-    return this.header.id;
+  // ---------------------------------------------------------------------------
+  // 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());
   }
-  getSessionFile() {
+  /**
+   * 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;
   }
-  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) });
+  // ---------------------------------------------------------------------------
+  // Handler queries
+  // ---------------------------------------------------------------------------
+  /**
+   * Check if there are handlers registered for specified event type.
+   */
+  hasHandlers(eventType) {
+    return this.hooks.has(eventType);
   }
-  async appendSessionState(state) {
-    return this.appendEntry({ type: "session_state", state: clone(state) });
+  /**
+   * Get the number of handlers for specified event type.
+   */
+  handlerCount(eventType) {
+    return this.hooks.count(eventType);
   }
-  async appendModelTranscript(transcript, meta) {
-    return this.appendEntry({
-      type: "model_transcript",
-      transcript: clone(transcript),
-      ...meta?.phase ? { phase: meta.phase } : {},
-      ...meta?.model ? { model: clone(meta.model) } : {}
-    });
+  // ---------------------------------------------------------------------------
+  // Phase management
+  // ---------------------------------------------------------------------------
+  getPhase(id) {
+    const reg = this.getRegisteredPhase(id);
+    if (!reg) return void 0;
+    return this.adaptToPhase(reg);
   }
-  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;
+  getPhases() {
+    return [...this.collectRegisteredPhases().values()].map(
+      (p) => this.adaptToPhase(p)
+    );
   }
-  async branch(entryId) {
-    if (entryId !== null && !this.entries.some((entry) => entry.id === entryId)) {
-      throw new Error(`Session entry not found: ${entryId}`);
+  createPhaseRegistry(input = {}) {
+    const registered = this.collectRegisteredPhases();
+    const phases = /* @__PURE__ */ new Map();
+    for (const [id, reg] of registered) {
+      phases.set(id, this.adaptToPhase(reg));
     }
-    this.header = {
-      ...this.header,
-      currentLeafId: entryId,
-      updatedAt: createTimestamp()
-    };
+    const entryPhaseId = input.entryPhaseId ?? null;
+    return { phases, entryPhaseId };
   }
-  async buildAgentContext(input = {}) {
-    const entries = this.entriesForLeaf(input.leafId ?? this.header.currentLeafId ?? null);
+  /** Adapt an extension RegisteredPhase to the core Phase type. */
+  adaptToPhase(reg) {
+    const def = reg.definition;
     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
+      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) } : {}
     };
   }
-  appendEntry(input) {
-    const timestamp = createTimestamp();
-    const entry = {
-      id: createId("entry"),
-      parentId: this.header.currentLeafId ?? null,
-      timestamp,
-      ...input
+  // ---------------------------------------------------------------------------
+  // 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.entries.push(entry);
-    this.header = {
-      ...this.header,
-      currentLeafId: entry.id,
-      updatedAt: timestamp
+    this.runtime.unregisterProvider = (_name) => {
+      applyProviderUnregistration(_name);
     };
-    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
-import { appendFile, mkdir as mkdir2, readFile as readFile2, readdir as readdir2, stat as stat2, unlink, writeFile as writeFile2 } from "fs/promises";
-import { join as join2, relative as relative2, resolve as resolve2, sep as sep2 } from "path";
-var SESSION_ID_PATTERN = /^ses_[A-Za-z0-9_-]+$/;
-function isPathInside(parent, child) {
-  const relativePath = relative2(parent, child);
-  return Boolean(relativePath) && !relativePath.startsWith("..") && !relativePath.includes(`..${sep2}`);
-}
-function safeSessionPath(sessionsDir, id) {
-  if (!SESSION_ID_PATTERN.test(id)) {
-    return void 0;
-  }
-  const root = resolve2(sessionsDir);
-  const path = resolve2(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 readFile2(path, "utf8").catch((error) => {
-    if (error.code === "ENOENT") {
-      return void 0;
-    }
-    throw error;
-  });
-  if (!text) {
-    return void 0;
+  // ---------------------------------------------------------------------------
+  // Unified hook emission
+  // ---------------------------------------------------------------------------
+  /**
+   * Generic emit — fire-and-forget for any event type.
+   */
+  async emit(eventType, event) {
+    await this.hooks.emit(eventType, event);
   }
-  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.");
+  /**
+   * Unified hook emission — returns the first non-undefined result.
+   */
+  async emitHook(type, event) {
+    return this.hooks.emitFirst(type, event);
   }
-  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 appendFile(path, `${JSON.stringify(record)}
-`, "utf8");
-}
-var LocalJsonlSessionManager = class _LocalJsonlSessionManager {
-  constructor(sessionsDir, filePath, inner) {
-    this.sessionsDir = sessionsDir;
-    this.filePath = filePath;
-    this.inner = inner;
+  // ---------------------------------------------------------------------------
+  // Phase hooks (with inline processing)
+  // ---------------------------------------------------------------------------
+  async emitBeforePhase(phaseId, input) {
+    const result = await this.emitHook("before_phase", {
+      type: "before_phase",
+      phaseId,
+      input
+    });
+    return result ?? {};
   }
-  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 stat2(path).then(() => true).catch((error) => {
-      if (error.code === "ENOENT") {
-        return false;
-      }
-      throw error;
+  async emitAfterPhase(phaseId, output) {
+    const result = await this.emitHook("after_phase", {
+      type: "after_phase",
+      phaseId,
+      output
     });
-    if (exists) {
-      throw new Error(`Session already exists: ${header.id}`);
-    }
-    await mkdir2(sessionsDir, { recursive: true });
-    await writeFile2(path, `${JSON.stringify(header)}
-`, "utf8");
-    return new _LocalJsonlSessionManager(
-      sessionsDir,
-      path,
-      InMemorySessionManager.fromRecords([header])
-    );
+    return result ?? {};
   }
-  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)
-    );
+  async emitBeforePrompt(phaseId, input) {
+    const result = await this.emitHook("before_prompt", {
+      type: "before_prompt",
+      phaseId,
+      input
+    });
+    return result?.input ?? input;
   }
-  static async list(sessionsDir) {
-    const entries = await readdir2(sessionsDir, { withFileTypes: true }).catch((error) => {
-      if (error.code === "ENOENT") {
-        return [];
-      }
-      throw error;
+  async emitBeforeToolCall(tool, args) {
+    const result = await this.emitHook("before_tool_call", {
+      type: "before_tool_call",
+      tool,
+      args
     });
-    const sessions = await Promise.all(
-      entries.filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map(async (entry) => {
-        const path = join2(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));
+    return result ?? { allow: true };
   }
-  static async delete(sessionsDir, id) {
-    const path = safeSessionPath(sessionsDir, id);
-    if (!path) {
-      return false;
-    }
-    return unlink(path).then(() => true).catch((error) => {
-      if (error.code === "ENOENT") {
-        return false;
-      }
-      throw error;
+  async emitAfterToolCall(tool, result) {
+    const hookResult = await this.emitHook("after_tool_call", {
+      type: "after_tool_call",
+      tool,
+      result
     });
+    return hookResult?.result ?? result;
   }
-  getSessionId() {
-    return this.inner.getSessionId();
+  // ---------------------------------------------------------------------------
+  // Agent event hooks (fire-and-forget)
+  // ---------------------------------------------------------------------------
+  async emitAgentStart(sessionId) {
+    await this.hooks.emit("agent_start", { type: "agent_start", sessionId });
   }
-  getSessionFile() {
-    return this.filePath;
+  async emitAgentEnd(sessionId, outcome, messages) {
+    await this.hooks.emit("agent_end", { type: "agent_end", sessionId, outcome, messages });
   }
-  async getHeader() {
-    return this.inner.getHeader();
+  async emitTurnStart(messages) {
+    await this.hooks.emit("turn_start", { type: "turn_start", messages });
   }
-  async appendMessage(message) {
-    return this.appendThroughInner(() => this.inner.appendMessage(message));
+  async emitTurnEnd(messages, outcome) {
+    await this.hooks.emit("turn_end", { type: "turn_end", messages, outcome });
   }
-  async appendOutcome(outcome) {
-    return this.appendThroughInner(() => this.inner.appendOutcome(outcome));
+  async emitMessageStart(message) {
+    await this.hooks.emit("message_start", { type: "message_start", message });
   }
-  async appendExecutionTurn(turn) {
-    return this.appendThroughInner(() => this.inner.appendExecutionTurn(turn));
+  async emitMessageUpdate(message, delta) {
+    await this.hooks.emit("message_update", { type: "message_update", message, delta });
   }
-  async appendCompaction(input) {
-    return this.appendThroughInner(() => this.inner.appendCompaction(input));
+  async emitMessageEnd(message) {
+    await this.hooks.emit("message_end", { type: "message_end", message });
   }
-  async appendBranchSummary(input) {
-    return this.appendThroughInner(() => this.inner.appendBranchSummary(input));
+  async emitToolExecutionStart(toolCallId, toolName, args) {
+    await this.hooks.emit("tool_execution_start", {
+      type: "tool_execution_start",
+      toolCallId,
+      toolName,
+      args
+    });
   }
-  async appendSessionInfo(input) {
-    return this.appendThroughInner(() => this.inner.appendSessionInfo(input));
+  async emitToolExecutionUpdate(toolCallId, toolName, _progress) {
+    await this.hooks.emit("tool_execution_update", {
+      type: "tool_execution_update",
+      toolCallId,
+      toolName
+    });
   }
-  async appendCustom(input) {
-    return this.appendThroughInner(() => this.inner.appendCustom(input));
+  async emitToolExecutionEnd(toolCallId, toolName, result) {
+    await this.hooks.emit("tool_execution_end", {
+      type: "tool_execution_end",
+      toolCallId,
+      toolName,
+      result
+    });
   }
-  async appendSessionState(state) {
-    return this.appendThroughInner(() => this.inner.appendSessionState(state));
+  async emitSavePoint(hadPendingMutations) {
+    await this.hooks.emit("save_point", { type: "save_point", hadPendingMutations });
   }
-  async appendModelTranscript(transcript, meta) {
-    return this.appendThroughInner(() => this.inner.appendModelTranscript(transcript, meta));
+  async emitAbort(reason) {
+    await this.hooks.emit("abort", { type: "abort", reason });
   }
-  async getSessionState() {
-    return this.inner.getSessionState();
+  async emitSettled() {
+    await this.hooks.emit("settled", { type: "settled" });
   }
-  async branch(entryId) {
-    await this.inner.branch(entryId);
-    if (entryId) {
-      await this.appendThroughInner(() => this.inner.appendBranchSummary({
-        fromId: entryId,
-        summary: `Selected branch at ${entryId}`
-      }));
+  // ---------------------------------------------------------------------------
+  // 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;
     }
   }
-  async buildAgentContext(input) {
-    return this.inner.buildAgentContext(input);
-  }
-  async listEntries() {
-    return this.inner.listEntries();
-  }
-  async loadExecutionTurns(filter) {
-    return this.inner.loadExecutionTurns(filter);
+  // ---------------------------------------------------------------------------
+  // 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);
   }
-  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}`);
+  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;
+      }
     }
-    await mkdir2(this.sessionsDir, { recursive: true });
-    await appendRecord(this.filePath, entry);
-    return entryId;
-  }
-};
-
-// 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((resolve4) => {
-      this.resolveFinalResult = resolve4;
+    const sourceInfo = createSourceInfo(extension.path);
+    extension.tools.set(tool.name, {
+      definition: tool,
+      sourceInfo
     });
   }
-  push(event) {
-    if (this.done) return;
-    if (this.isComplete(event)) {
-      this.done = true;
-      this.resolveFinalResult(this.extractResult(event));
+  registerPhase(extension, registration) {
+    if (!registration.id) {
+      throw new Error(`Phase registration requires an "id" field.`);
     }
-    const waiter = this.waiting.shift();
-    if (waiter) {
-      waiter({ value: event, done: false });
-    } else {
-      this.queue.push(event);
+    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;
   }
-  end(result) {
-    this.done = true;
-    if (result !== void 0) {
-      this.resolveFinalResult(result);
+  registerProvider(config) {
+    if (this.bound) {
+      applyProviderRegistration(config);
+    } else {
+      this.pendingProviders.push({ kind: "register", config });
     }
-    while (this.waiting.length > 0) {
-      const waiter = this.waiting.shift();
-      waiter({ value: void 0, done: true });
+  }
+  unregisterProvider(name) {
+    if (this.bound) {
+      applyProviderUnregistration(name);
+    } else {
+      this.pendingProviders.push({ kind: "unregister", name });
     }
   }
-  async *[Symbol.asyncIterator]() {
-    while (true) {
-      if (this.queue.length > 0) {
-        yield this.queue.shift();
-      } else if (this.done) {
-        return;
+  flushPendingProviders() {
+    for (const action of this.pendingProviders) {
+      if (action.kind === "register") {
+        applyProviderRegistration(action.config);
       } else {
-        const result = await new Promise((resolve4) => this.waiting.push(resolve4));
-        if (result.done) return;
-        yield result.value;
+        applyProviderUnregistration(action.name);
       }
     }
+    this.pendingProviders.length = 0;
   }
-  result() {
-    return this.finalResultPromise;
+  getRegisteredPhase(id) {
+    return this.collectRegisteredPhases().get(id);
   }
-};
-var AgentEventStream = class extends EventStream {
-  constructor() {
-    super(
-      (event) => event.type === "agent_end",
-      (event) => event.type === "agent_end" ? event.messages : []
-    );
+  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/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))
-        );
-      }
-    }
+// src/extensions/loader.ts
+import { existsSync as existsSync5, readFileSync as readFileSync2 } from "fs";
+import { readdir as readdir3, readFile as readFile4, stat as stat2 } from "fs/promises";
+import { fileURLToPath } from "url";
+import { dirname as dirname6, extname as extname2, join as join5, resolve as resolve5 } from "path";
+import { createJiti } from "jiti";
+function isExtensionFile(path) {
+  const extension = extname2(path).toLowerCase();
+  return extension === ".ts" || extension === ".js";
+}
+function isSyntheticPath(path) {
+  return path.startsWith("<") && path.endsWith(">");
+}
+function readManifestSync(dir) {
+  const manifestPath = join5(dir, "package.json");
+  if (!existsSync5(manifestPath)) {
+    return void 0;
+  }
+  try {
+    const content = readFileSync2(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;
   }
-};
-var _globalHooks;
-function getGlobalHooks() {
-  _globalHooks ??= new HooksManager();
-  return _globalHooks;
 }
-function resetGlobalHooks() {
-  _globalHooks = void 0;
+function jitiAliases() {
+  const moduleUrl = import.meta.url;
+  if (!moduleUrl) {
+    return {};
+  }
+  const agentSourcePath = fileURLToPath(new URL("../index.ts", moduleUrl));
+  if (!existsSync5(agentSourcePath)) {
+    return {};
+  }
+  return { "@rowan-agent/agent": agentSourcePath };
 }
-
-// src/extensions/runner.ts
-import { execFile } from "child_process";
-import {
-  registerModel,
-  unregisterProviderModels,
-  registerApiProvider
-} from "@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
-  };
+var sharedJiti;
+function getJiti() {
+  sharedJiti ??= createJiti(import.meta.url || process.cwd(), {
+    moduleCache: false,
+    alias: jitiAliases()
+  });
+  return sharedJiti;
 }
-function createExtension(extensionPath, resolvedPath, sourceInfo) {
-  return {
-    path: extensionPath,
-    resolvedPath,
-    sourceInfo,
-    handlers: /* @__PURE__ */ new Map(),
-    tools: /* @__PURE__ */ new Map(),
-    phases: /* @__PURE__ */ new Map()
-  };
+async function loadExtensionModule(extensionPath) {
+  const jiti = getJiti();
+  const module = await jiti.import(extensionPath, { default: true });
+  return typeof module === "function" ? module : void 0;
 }
-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;
+async function readPackageManifest(path) {
+  if (!existsSync5(path)) {
+    return void 0;
+  }
+  const content = await readFile4(path, "utf8");
+  return JSON.parse(content);
 }
-
-// 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;
+async function resolveExtensionEntries(dir) {
+  const manifest = await readPackageManifest(join5(dir, "package.json"));
+  const declared = manifest?.rowan?.extensions;
+  if (declared && declared.length > 0) {
+    return declared.map((entry) => resolve5(dir, entry));
+  }
+  for (const name of ["index.ts", "index.js"]) {
+    const entry = join5(dir, name);
+    if (existsSync5(entry)) {
+      return [entry];
     }
-  };
+  }
+  return void 0;
 }
-
-// src/extensions/runner.ts
-async function execCommand(command, args, cwd, options) {
-  return new Promise((resolve4, reject) => {
-    const child = 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;
+async function discoverExtensionsInDir(dir) {
+  const entries = await readdir3(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 = join5(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 stat2(entryPath).catch(() => void 0) : void 0;
+      if (entry.isDirectory() || info?.isDirectory()) {
+        const resolvedEntries = await resolveExtensionEntries(entryPath);
+        if (resolvedEntries) {
+          paths.push(...resolvedEntries);
         }
-        resolve4({
-          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) {
-    registerApiProvider({ protocol: config.protocol, stream: config.streamSimple });
-  }
-  for (const modelConfig of config.models) {
-    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 } : {}
-    });
   }
+  return paths;
 }
-function applyProviderUnregistration(name) {
-  unregisterProviderModels(name);
+function loadExtensionFromFactory(factory, cwd, extensionPath = "<inline>") {
+  const resolvedCwd = resolve5(cwd);
+  const resolvedPath = isSyntheticPath(extensionPath) ? extensionPath : resolve5(resolvedCwd, extensionPath);
+  const name = isSyntheticPath(extensionPath) ? extensionPath : dirname6(resolvedPath).split("/").pop() ?? "unknown";
+  const manifestDir = isSyntheticPath(extensionPath) ? resolvedCwd : dirname6(resolvedPath);
+  const manifest = readManifestSync(manifestDir);
+  return {
+    path: resolvedPath,
+    name,
+    factory,
+    manifest
+  };
 }
-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;
+async function loadExtensions(paths, cwd) {
+  const extensions = [];
+  const errors = [];
+  const resolvedCwd = resolve5(cwd);
+  for (const path of paths) {
+    const resolvedPath = resolve5(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 loadExtensionsFromPath(path) {
+  const resolvedPath = resolve5(path);
+  const info = await stat2(resolvedPath);
+  if (!info.isDirectory()) {
+    return loadExtensions([resolvedPath], dirname6(resolvedPath));
+  }
+  const entries = await resolveExtensionEntries(resolvedPath) ?? await discoverExtensionsInDir(resolvedPath);
+  return loadExtensions(entries, resolvedPath);
+}
+
+// src/agent.ts
+var Agent = class {
+  state;
+  options;
+  listeners = /* @__PURE__ */ new Set();
+  pendingListenerTasks = /* @__PURE__ */ new Set();
+  listenerErrors = [];
+  activeRun;
+  extensionRunner;
+  loadedExtensions;
+  loadedExtensionsCwd;
+  static loadSkills(targetPath) {
+    return loadSkills(targetPath);
+  }
+  static loadPhases(targetPath) {
+    return loadPhases(targetPath);
+  }
+  static loadExtensions(targetPath) {
+    return loadExtensionsFromPath(targetPath);
+  }
   constructor(options) {
-    this.hooks = new HooksManager();
-    this.runtime = createExtensionRuntime();
-    this.events = createEventBus();
-    this.cwd = options?.cwd ?? process.cwd();
+    const context = cloneAgentContext(options.context);
+    this.options = {
+      ...options,
+      context
+    };
+    this.state = {
+      ...this.options.sessionId ? { sessionId: this.options.sessionId } : {},
+      context: cloneAgentContext(context),
+      model: this.options.model,
+      tools: this.options.context.tools ?? [],
+      isRunning: false
+    };
   }
-  /** Whether the agent is currently idle (not streaming). */
-  get isIdle() {
-    return this._idle;
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
   }
-  /** Set idle state — called by the agent loop. */
-  setIdle(idle) {
-    this._idle = idle;
+  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);
+      }
+    }
   }
-  /** Abort signal for the current runner instance. */
-  get signal() {
-    return this.abortController.signal;
+  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));
+    }
   }
-  /** Abort the current runner operation. */
-  abort() {
-    this.abortController.abort();
+  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.extensionRunner?.emitAgentEvent(event);
   }
-  // ---------------------------------------------------------------------------
-  // Error handling
-  // ---------------------------------------------------------------------------
   /**
-   * Register an error listener.
-   * Returns an unsubscribe function.
+   * Hook for before_tool_call — called before a tool executes.
+   * Extensions can block execution by setting allow=false.
    */
-  onError(listener) {
-    this.errorListeners.add(listener);
-    return () => this.errorListeners.delete(listener);
+  async handleBeforeToolCall(tool, args) {
+    const runner = this.extensionRunner;
+    if (!runner) return { allow: true };
+    return runner.emitBeforeToolCall(tool, args);
   }
   /**
-   * Emit a structured extension error to all listeners.
+   * Hook for after_tool_call — called after a tool executes.
+   * Extensions can mutate the result.
    */
-  emitError(error) {
-    for (const listener of this.errorListeners) {
-      try {
-        listener(error);
-      } catch (err) {
-        console.error("[extension-runner] Error listener failed:", err);
-      }
-    }
+  async handleAfterToolCall(tool, result) {
+    const runner = this.extensionRunner;
+    if (!runner) return result;
+    return runner.emitAfterToolCall(tool, result);
   }
-  // ---------------------------------------------------------------------------
-  // 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.
+   * Hook for before_phase — called before a phase executes.
+   * Extensions can abort, skip, or replace the phase input.
    */
-  invalidate(message) {
-    this.runtime.invalidate(message);
+  async handleBeforePhase(phaseId, input) {
+    const runner = this.extensionRunner;
+    if (!runner) return {};
+    return runner.emitBeforePhase(phaseId, input);
   }
-  // ---------------------------------------------------------------------------
-  // 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
-   * ```
+   * Hook for after_phase — called after a phase executes.
+   * Extensions can abort, retry, or replace the output.
    */
-  on(type, handler) {
-    this.hooks.on(type, handler);
-    return () => this.hooks.off(type, handler);
+  async handleAfterPhase(phaseId, output) {
+    const runner = this.extensionRunner;
+    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.extensionRunner;
+    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;
+  }
+  async runWithLifecycle(executor) {
+    if (this.activeRun) {
+      throw new Error("Agent is already running.");
+    }
+    let resolvePromise;
+    const abortController = new AbortController();
+    const promise = new Promise((resolve7) => {
+      resolvePromise = resolve7;
+    });
+    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 loadExtensions(extensions, cwd) {
+    if (extensions.length === 0) {
+      this.extensionRunner?.invalidate();
+      this.extensionRunner = void 0;
+      this.loadedExtensions = extensions;
+      this.loadedExtensionsCwd = cwd;
+      return;
+    }
+    if (this.extensionRunner && this.loadedExtensions === extensions && this.loadedExtensionsCwd === cwd) {
+      return;
+    }
+    const runner = createExtensionRunner({ cwd });
+    await runner.loadExtensions(extensions);
+    runner.bind();
+    this.extensionRunner?.invalidate();
+    this.extensionRunner = runner;
+    this.loadedExtensions = extensions;
+    this.loadedExtensionsCwd = cwd;
+  }
+  async run(config) {
+    const resolved = this.resolveRunConfig(config);
+    const extensions = resolved.extensions ?? [];
+    await this.loadExtensions(extensions, resolved.cwd);
+    const runContext = cloneAgentContext(resolved.context, this.extensionRunner);
+    const sessionId = resolved.sessionId ?? this.state.sessionId;
+    this.options = resolved;
+    if (sessionId) {
+      this.state.sessionId = sessionId;
+    }
+    this.state.context = runContext;
+    this.state.model = resolved.model;
+    this.state.tools = runContext.tools ?? [];
+    this.state.currentResult = void 0;
+    this.state.error = void 0;
+    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: runContext,
+        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),
+        emit,
+        onMessage: resolved.onMessage,
+        onOutcome: resolved.onOutcome,
+        onModelTranscript: resolved.onModelTranscript
+      });
+      const nextContext = {
+        ...cloneAgentContext(resolved.context),
+        messages: snapshotMessages(result.messages)
+      };
+      this.state.sessionId = result.sessionId;
+      this.state.context = cloneAgentContext(nextContext, this.extensionRunner);
+      this.state.currentResult = result;
+      this.options = {
+        ...resolved,
+        sessionId: result.sessionId,
+        context: nextContext
+      };
+      return result;
+    });
+  }
+  abort(reason = "Aborted by caller.") {
+    this.activeRun?.abortController.abort(reason);
   }
   /**
-   * Subscribe to all events (read-only).
-   * Returns an unsubscribe function.
+   * Get formatted skill content for LLM consumption.
    *
-   * @example
-   * ```ts
-   * const unsub = runner.subscribe((event) => {
-   *   console.log(event.type);
-   * });
-   * ```
+   * 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
    */
-  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);
+  skill(name, additionalInstructions) {
+    const skill = this.state.context.skills.find((s) => s.name === name);
+    if (!skill) {
+      throw new Error(`Unknown skill: ${name}`);
     }
-    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"
-    ];
+    const content = readSkillContent(skill);
+    return additionalInstructions ? `${content}
+
+${additionalInstructions}` : content;
   }
-  // ---------------------------------------------------------------------------
-  // Extension loading
-  // ---------------------------------------------------------------------------
   /**
-   * Load and initialize extensions.
-   * Creates Extension tracking objects and calls each factory with an ExtensionAPI.
+   * 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 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;
-      }
-    }
+  async phase(name) {
+    await this.loadExtensions(this.options.extensions ?? [], this.options.cwd);
+    const registry = cloneAgentContext(this.options.context, this.extensionRunner).phases?.phases;
+    const phase = registry?.get(name) ?? [...registry?.values() ?? []].find((candidate) => candidate.name === name);
+    return phase ? readPhaseContent(phase) : "";
   }
-  // ---------------------------------------------------------------------------
-  // 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);
-        }
-      }
+  async waitForIdle() {
+    if (!this.activeRun) {
+      return;
     }
-    return Array.from(toolsByName.values());
+    await this.activeRun.promise.catch(() => void 0);
+    await this.flushEvents().catch(() => void 0);
   }
-  /**
-   * 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;
+  resolveRunConfig(config) {
+    const merged = {
+      ...this.options,
+      ...config
+    };
+    const context = cloneAgentContext(config?.context ?? this.createContextSnapshot());
+    return {
+      ...merged,
+      context,
+      sessionId: config?.sessionId ?? this.state.sessionId ?? this.options.sessionId
+    };
   }
-  // ---------------------------------------------------------------------------
-  // Handler queries
-  // ---------------------------------------------------------------------------
-  /**
-   * Check if there are handlers registered for specified event type.
-   */
-  hasHandlers(eventType) {
-    return this.hooks.has(eventType);
+  createContextSnapshot() {
+    return cloneAgentContext(this.options.context);
   }
-  /**
-   * Get the number of handlers for specified event type.
-   */
-  handlerCount(eventType) {
-    return this.hooks.count(eventType);
+};
+function cloneAgentContext(context, extensionRunner) {
+  const phases = /* @__PURE__ */ new Map();
+  phases.set(DEFAULT_PHASE_ID, createDefaultPhase());
+  for (const [id, phase] of context.phases?.phases ?? []) {
+    phases.set(id, phase);
   }
-  // ---------------------------------------------------------------------------
-  // Phase management
-  // ---------------------------------------------------------------------------
-  getPhase(id) {
-    const reg = this.getRegisteredPhase(id);
-    if (!reg) return void 0;
-    return this.adaptToPhase(reg);
+  const extensionRegistry = extensionRunner?.createPhaseRegistry();
+  for (const [id, phase] of extensionRegistry?.phases ?? []) {
+    phases.set(id, phase);
   }
-  getPhases() {
-    return [...this.collectRegisteredPhases().values()].map(
-      (p) => this.adaptToPhase(p)
-    );
+  return {
+    systemPrompt: context.systemPrompt,
+    messages: snapshotMessages(context.messages),
+    tools: context.tools.slice(),
+    skills: context.skills.slice(),
+    phases: {
+      phases,
+      entryPhaseId: extensionRegistry?.entryPhaseId ?? context.phases?.entryPhaseId ?? DEFAULT_PHASE_ID
+    }
+  };
+}
+
+// src/harness/session/session.ts
+import Type3 from "typebox";
+var SESSION_SCHEMA_VERSION = "0.4.4";
+var AgentMessageSchema = Type3.Object({
+  id: Type3.String(),
+  role: Type3.Union([
+    Type3.Literal("system"),
+    Type3.Literal("user"),
+    Type3.Literal("assistant"),
+    Type3.Literal("tool")
+  ]),
+  content: Type3.Union([Type3.String(), Type3.Array(Type3.Unknown())]),
+  createdAt: Type3.String(),
+  metadata: Type3.Optional(Type3.Record(Type3.String(), Type3.Unknown()))
+});
+var SkillSchema = Type3.Object({
+  name: Type3.String(),
+  description: Type3.String(),
+  filePath: Type3.String(),
+  baseDir: Type3.String(),
+  content: Type3.String(),
+  disableModelInvocation: Type3.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));
   }
-  createPhaseRegistry(input = {}) {
-    const registered = this.collectRegisteredPhases();
-    const phases = /* @__PURE__ */ new Map();
-    for (const [id, reg] of registered) {
-      phases.set(id, this.adaptToPhase(reg));
+  static fromRecords(records) {
+    const [header, ...entries] = records;
+    if (!header || header.type !== "header") {
+      throw new Error("Session records must start with a header.");
     }
-    const entryPhaseId = input.entryPhaseId ?? null;
-    return { phases, entryPhaseId };
+    return new _InMemorySessionManager(clone(header), clone(entries));
   }
-  /** 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) } : {}
-    };
+  getSessionId() {
+    return this.header.id;
   }
-  // ---------------------------------------------------------------------------
-  // 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);
-    };
+  getSessionFile() {
+    return void 0;
   }
-  // ---------------------------------------------------------------------------
-  // Unified hook emission
-  // ---------------------------------------------------------------------------
-  /**
-   * Generic emit — fire-and-forget for any event type.
-   */
-  async emit(eventType, event) {
-    await this.hooks.emit(eventType, event);
+  async getHeader() {
+    return clone(this.header);
   }
-  /**
-   * Unified hook emission — returns the first non-undefined result.
-   */
-  async emitHook(type, event) {
-    return this.hooks.emitFirst(type, event);
+  async appendMessage(message) {
+    return this.appendEntry({ type: "message", message: clone(message) });
   }
-  // ---------------------------------------------------------------------------
-  // Phase hooks (with inline processing)
-  // ---------------------------------------------------------------------------
-  async emitBeforePhase(phaseId, input) {
-    const result = await this.emitHook("before_phase", {
-      type: "before_phase",
-      phaseId,
-      input
-    });
-    return result ?? {};
+  async appendOutcome(outcome) {
+    return this.appendEntry({ type: "outcome", outcome: clone(outcome) });
   }
-  async emitAfterPhase(phaseId, output) {
-    const result = await this.emitHook("after_phase", {
-      type: "after_phase",
-      phaseId,
-      output
+  async appendExecutionTurn(turn) {
+    return this.appendEntry({
+      type: "execution_turn",
+      turn: clone({
+        ...turn,
+        sessionId: this.header.id
+      })
     });
-    return result ?? {};
   }
-  async emitBeforePrompt(phaseId, input) {
-    const result = await this.emitHook("before_prompt", {
-      type: "before_prompt",
-      phaseId,
-      input
-    });
-    return result?.input ?? input;
+  async appendCompaction(input) {
+    return this.appendEntry({ type: "compaction", ...input });
   }
-  async emitBeforeToolCall(tool, args) {
-    const result = await this.emitHook("before_tool_call", {
-      type: "before_tool_call",
-      tool,
-      args
-    });
-    return result ?? { allow: true };
+  async appendBranchSummary(input) {
+    return this.appendEntry({ type: "branch_summary", ...input });
   }
-  async emitAfterToolCall(tool, result) {
-    const hookResult = await this.emitHook("after_tool_call", {
-      type: "after_tool_call",
-      tool,
-      result
+  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) } : {}
     });
-    return hookResult?.result ?? result;
   }
-  // ---------------------------------------------------------------------------
-  // Agent event hooks (fire-and-forget)
-  // ---------------------------------------------------------------------------
-  async emitAgentStart(sessionId) {
-    await this.hooks.emit("agent_start", { type: "agent_start", sessionId });
+  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 emitAgentEnd(sessionId, outcome, messages) {
-    await this.hooks.emit("agent_end", { type: "agent_end", sessionId, outcome, messages });
+  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 emitTurnStart(messages) {
-    await this.hooks.emit("turn_start", { type: "turn_start", messages });
+  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 emitTurnEnd(messages, outcome) {
-    await this.hooks.emit("turn_end", { type: "turn_end", messages, outcome });
+  async listEntries() {
+    return this.entries.map(clone);
   }
-  async emitMessageStart(message) {
-    await this.hooks.emit("message_start", { type: "message_start", message });
+  async loadExecutionTurns(filter) {
+    return filterExecutionTurns(
+      this.entries.filter((entry) => entry.type === "execution_turn").map((entry) => entry.turn),
+      filter
+    );
   }
-  async emitMessageUpdate(message, delta) {
-    await this.hooks.emit("message_update", { type: "message_update", message, delta });
+  appendImportedEntry(entry) {
+    this.entries.push(clone(entry));
+    this.header = {
+      ...this.header,
+      currentLeafId: entry.id,
+      updatedAt: entry.timestamp
+    };
   }
-  async emitMessageEnd(message) {
-    await this.hooks.emit("message_end", { type: "message_end", message });
+  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;
   }
-  async emitToolExecutionStart(toolCallId, toolName, args) {
-    await this.hooks.emit("tool_execution_start", {
-      type: "tool_execution_start",
-      toolCallId,
-      toolName,
-      args
-    });
+  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;
   }
-  async emitToolExecutionUpdate(toolCallId, toolName, _progress) {
-    await this.hooks.emit("tool_execution_update", {
-      type: "tool_execution_update",
-      toolCallId,
-      toolName
-    });
+};
+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
+import { appendFile, mkdir as mkdir2, readFile as readFile5, readdir as readdir4, stat as stat3, unlink, writeFile as writeFile2 } from "fs/promises";
+import { join as join6, relative as relative3, resolve as resolve6, sep as sep3 } from "path";
+var SESSION_ID_PATTERN = /^ses_[A-Za-z0-9_-]+$/;
+function isPathInside(parent, child) {
+  const relativePath = relative3(parent, child);
+  return Boolean(relativePath) && !relativePath.startsWith("..") && !relativePath.includes(`..${sep3}`);
+}
+function safeSessionPath(sessionsDir, id) {
+  if (!SESSION_ID_PATTERN.test(id)) {
+    return void 0;
   }
-  async emitToolExecutionEnd(toolCallId, toolName, result) {
-    await this.hooks.emit("tool_execution_end", {
-      type: "tool_execution_end",
-      toolCallId,
-      toolName,
-      result
-    });
+  const root = resolve6(sessionsDir);
+  const path = resolve6(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.");
   }
-  async emitSavePoint(hadPendingMutations) {
-    await this.hooks.emit("save_point", { type: "save_point", hadPendingMutations });
+  return value;
+}
+async function readRecords(path) {
+  const text = await readFile5(path, "utf8").catch((error) => {
+    if (error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  });
+  if (!text) {
+    return void 0;
   }
-  async emitAbort(reason) {
-    await this.hooks.emit("abort", { type: "abort", reason });
+  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.");
   }
-  async emitSettled() {
-    await this.hooks.emit("settled", { type: "settled" });
+  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 appendFile(path, `${JSON.stringify(record)}
+`, "utf8");
+}
+var LocalJsonlSessionManager = class _LocalJsonlSessionManager {
+  constructor(sessionsDir, filePath, inner) {
+    this.sessionsDir = sessionsDir;
+    this.filePath = filePath;
+    this.inner = inner;
   }
-  // ---------------------------------------------------------------------------
-  // 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;
+  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}`);
     }
-  }
-  // ---------------------------------------------------------------------------
-  // 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 exists = await stat3(path).then(() => true).catch((error) => {
+      if (error.code === "ENOENT") {
+        return false;
       }
-    }
-    const sourceInfo = createSourceInfo(extension.path);
-    extension.tools.set(tool.name, {
-      definition: tool,
-      sourceInfo
+      throw error;
     });
-  }
-  registerPhase(extension, registration) {
-    if (!registration.id) {
-      throw new Error(`Phase registration requires an "id" field.`);
+    if (exists) {
+      throw new Error(`Session already exists: ${header.id}`);
     }
-    if (!registration.name) {
-      throw new Error(`Phase registration "${registration.id}" requires a "name" field.`);
+    await mkdir2(sessionsDir, { recursive: true });
+    await writeFile2(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;
     }
-    if (!registration.description) {
-      throw new Error(`Phase registration "${registration.id}" requires a "description" field.`);
+    const records = await readRecords(path);
+    if (!records) {
+      return void 0;
     }
-    if (this.phases.has(registration.id)) {
-      throw new Error(`Duplicate phase id: ${registration.id}`);
+    const header = records[0];
+    if (header.id !== id) {
+      throw new Error(`Session id mismatch: expected ${id}, found ${header.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;
+    return new _LocalJsonlSessionManager(
+      sessionsDir,
+      path,
+      InMemorySessionManager.fromRecords(records)
+    );
   }
-  registerProvider(config) {
-    if (this.bound) {
-      applyProviderRegistration(config);
-    } else {
-      this.pendingProviders.push({ kind: "register", config });
-    }
+  static async list(sessionsDir) {
+    const entries = await readdir4(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 = join6(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));
   }
-  unregisterProvider(name) {
-    if (this.bound) {
-      applyProviderUnregistration(name);
-    } else {
-      this.pendingProviders.push({ kind: "unregister", name });
+  static async delete(sessionsDir, id) {
+    const path = safeSessionPath(sessionsDir, id);
+    if (!path) {
+      return false;
     }
-  }
-  flushPendingProviders() {
-    for (const action of this.pendingProviders) {
-      if (action.kind === "register") {
-        applyProviderRegistration(action.config);
-      } else {
-        applyProviderUnregistration(action.name);
+    return unlink(path).then(() => true).catch((error) => {
+      if (error.code === "ENOENT") {
+        return false;
       }
-    }
-    this.pendingProviders.length = 0;
+      throw error;
+    });
   }
-  getRegisteredPhase(id) {
-    return this.collectRegisteredPhases().get(id);
+  getSessionId() {
+    return this.inner.getSessionId();
   }
-  collectRegisteredPhases() {
-    if (this._phaseCache) return this._phaseCache;
-    this._phaseCache = new Map(this.phases);
-    return this._phaseCache;
+  getSessionFile() {
+    return this.filePath;
   }
-};
-function createExtensionRunner(options) {
-  return new ExtensionRunner(options);
-}
-
-// src/extensions/loader.ts
-import { existsSync as existsSync2, readFileSync } from "fs";
-import { readdir as readdir3, readFile as readFile3, stat as stat3 } from "fs/promises";
-import { fileURLToPath } from "url";
-import { dirname as dirname3, extname, join as join3, resolve as resolve3 } from "path";
-import { createJiti } from "jiti";
-var ROWAN_DIR = ".rowan";
-var EXTENSIONS_DIR = "extensions";
-function isExtensionFile(path) {
-  const extension = extname(path).toLowerCase();
-  return extension === ".ts" || extension === ".js";
-}
-function isSyntheticPath(path) {
-  return path.startsWith("<") && path.endsWith(">");
-}
-function readManifestSync(dir) {
-  const manifestPath = join3(dir, "package.json");
-  if (!existsSync2(manifestPath)) {
-    return void 0;
+  async getHeader() {
+    return this.inner.getHeader();
   }
-  try {
-    const content = 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;
+  async appendMessage(message) {
+    return this.appendThroughInner(() => this.inner.appendMessage(message));
   }
-}
-function jitiAliases() {
-  const moduleUrl = import.meta.url;
-  if (!moduleUrl) {
-    return {};
+  async appendOutcome(outcome) {
+    return this.appendThroughInner(() => this.inner.appendOutcome(outcome));
   }
-  const agentSourcePath = fileURLToPath(new URL("../index.ts", moduleUrl));
-  if (!existsSync2(agentSourcePath)) {
-    return {};
+  async appendExecutionTurn(turn) {
+    return this.appendThroughInner(() => this.inner.appendExecutionTurn(turn));
   }
-  return { "@rowan-agent/agent": agentSourcePath };
-}
-var sharedJiti;
-function getJiti() {
-  sharedJiti ??= createJiti(import.meta.url || process.cwd(), {
-    moduleCache: false,
-    alias: jitiAliases()
-  });
-  return sharedJiti;
-}
-async function loadExtensionModule(extensionPath) {
-  const jiti = getJiti();
-  const module = await jiti.import(extensionPath, { default: true });
-  return typeof module === "function" ? module : void 0;
-}
-async function readPackageManifest(path) {
-  if (!existsSync2(path)) {
-    return void 0;
+  async appendCompaction(input) {
+    return this.appendThroughInner(() => this.inner.appendCompaction(input));
   }
-  const content = await readFile3(path, "utf8");
-  return JSON.parse(content);
-}
-async function resolveExtensionEntries(dir) {
-  const manifest = await readPackageManifest(join3(dir, "package.json"));
-  const declared = manifest?.rowan?.extensions;
-  if (declared && declared.length > 0) {
-    return declared.map((entry) => resolve3(dir, entry));
+  async appendBranchSummary(input) {
+    return this.appendThroughInner(() => this.inner.appendBranchSummary(input));
   }
-  for (const name of ["index.ts", "index.js"]) {
-    const entry = join3(dir, name);
-    if (existsSync2(entry)) {
-      return [entry];
+  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}`
+      }));
     }
   }
-  return void 0;
-}
-async function discoverExtensionsInDir(dir) {
-  const entries = await readdir3(dir, { withFileTypes: true }).catch((error) => {
-    if (error.code === "ENOENT") {
-      return [];
+  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}`);
     }
-    throw error;
-  });
-  const paths = [];
-  for (const entry of [...entries].sort((a, b) => a.name.localeCompare(b.name))) {
-    const entryPath = join3(dir, entry.name);
-    if ((entry.isFile() || entry.isSymbolicLink()) && isExtensionFile(entry.name)) {
-      paths.push(entryPath);
-      continue;
+    await mkdir2(this.sessionsDir, { recursive: true });
+    await appendRecord(this.filePath, entry);
+    return entryId;
+  }
+};
+
+// 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((resolve7) => {
+      this.resolveFinalResult = resolve7;
+    });
+  }
+  push(event) {
+    if (this.done) return;
+    if (this.isComplete(event)) {
+      this.done = true;
+      this.resolveFinalResult(this.extractResult(event));
     }
-    if (entry.isDirectory() || entry.isSymbolicLink()) {
-      const info = entry.isSymbolicLink() ? await stat3(entryPath).catch(() => void 0) : void 0;
-      if (entry.isDirectory() || info?.isDirectory()) {
-        const resolvedEntries = await resolveExtensionEntries(entryPath);
-        if (resolvedEntries) {
-          paths.push(...resolvedEntries);
-        }
-      }
+    const waiter = this.waiting.shift();
+    if (waiter) {
+      waiter({ value: event, done: false });
+    } else {
+      this.queue.push(event);
     }
   }
-  return paths;
-}
-function loadExtensionFromFactory(factory, cwd, extensionPath = "<inline>") {
-  const resolvedCwd = resolve3(cwd);
-  const resolvedPath = isSyntheticPath(extensionPath) ? extensionPath : resolve3(resolvedCwd, extensionPath);
-  const name = isSyntheticPath(extensionPath) ? extensionPath : dirname3(resolvedPath).split("/").pop() ?? "unknown";
-  const manifestDir = isSyntheticPath(extensionPath) ? resolvedCwd : dirname3(resolvedPath);
-  const manifest = readManifestSync(manifestDir);
-  return {
-    path: extensionPath,
-    resolvedPath,
-    name,
-    factory,
-    manifest
-  };
-}
-async function loadExtensions(paths, cwd) {
-  const extensions = [];
-  const errors = [];
-  const resolvedCwd = resolve3(cwd);
-  for (const path of paths) {
-    const resolvedPath = resolve3(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;
+  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((resolve7) => this.waiting.push(resolve7));
+        if (result.done) return;
+        yield result.value;
       }
-      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 = join3(resolve3(cwd), ROWAN_DIR, EXTENSIONS_DIR);
-  const paths = await discoverExtensionsInDir(extensionsDir);
-  return loadExtensions(paths, cwd);
-}
+  result() {
+    return this.finalResultPromise;
+  }
+};
+var AgentEventStream = class extends EventStream {
+  constructor() {
+    super(
+      (event) => event.type === "agent_end",
+      (event) => event.type === "agent_end" ? event.messages : []
+    );
+  }
+};
 
 // src/index.ts
 import {
@@ -3696,10 +4265,12 @@ import {
 export {
   Agent,
   AgentEventStream,
+  EmptyResponseError,
   EventStream,
   ExtensionRunner,
   HooksManager,
   LocalJsonlSessionManager,
+  MissingRouteToolCallError,
   appendUserTurn,
   buildModelRequest,
   buildSystemPrompt,
@@ -3716,24 +4287,20 @@ export {
   createSession,
   createSourceInfo,
   createTimestamp,
-  discoverAndLoadExtensions,
   getGlobalHooks,
   interpolateEnvVars,
   latestUserInput,
   loadConfigFile,
-  loadExtensionFromFactory,
-  loadExtensions,
+  loadPhase,
   loadPhases,
-  loadSkill,
-  loadSkills,
   messageContentText,
   parseModelRef,
   registerBuiltInApiProviders,
   registerConfigModels,
+  reloadPhases,
   resetGlobalHooks,
   resolveDefaultModel,
   resolveInWorkspace,
-  resolveSkillPath,
   resolveWorkspacePaths,
   serializeSkills
 };