@rowan-agent/agent 0.4.4

package/dist/index.js

@@ -0,0 +1,4039 @@
+// src/utils.ts
+function createId(prefix) {
+  return `${prefix}_${crypto.randomUUID().slice(0, 8)}`;
+}
+function padDatePart(value, length = 2) {
+  return String(value).padStart(length, "0");
+}
+function formatLocalTimestamp(date) {
+  const offsetMinutes = -date.getTimezoneOffset();
+  const offsetSign = offsetMinutes >= 0 ? "+" : "-";
+  const offsetAbsolute = Math.abs(offsetMinutes);
+  const offsetHours = Math.floor(offsetAbsolute / 60);
+  const offsetRemainingMinutes = offsetAbsolute % 60;
+  return [
+    `${date.getFullYear()}-${padDatePart(date.getMonth() + 1)}-${padDatePart(date.getDate())}`,
+    "T",
+    `${padDatePart(date.getHours())}${padDatePart(date.getMinutes())}${padDatePart(date.getSeconds())}`,
+    "-",
+    padDatePart(Math.floor(date.getMilliseconds() / 10)),
+    offsetSign,
+    padDatePart(offsetHours),
+    ":",
+    padDatePart(offsetRemainingMinutes)
+  ].join("");
+}
+function createTimestamp(date = /* @__PURE__ */ new Date()) {
+  return formatLocalTimestamp(date);
+}
+var createJson = {
+  new(value) {
+    return JSON.parse(JSON.stringify(value));
+  },
+  stringify(value) {
+    return JSON.stringify(value, null, 2);
+  }
+};
+
+// src/types.ts
+var AGENT_STATE_SCHEMA_VERSION = "0.4.4";
+function createMessage(role, content, metadata) {
+  return {
+    id: createId("msg"),
+    role,
+    content,
+    createdAt: createTimestamp(),
+    ...metadata ? { metadata } : {}
+  };
+}
+function createAgentState(input) {
+  const createdAt = createTimestamp();
+  const messages = input.messages?.map(createJson.new) ?? [
+    createMessage("user", input.input)
+  ];
+  return {
+    version: AGENT_STATE_SCHEMA_VERSION,
+    id: input.id ?? createId("ses"),
+    ...input.parentSessionId ? { parentSessionId: input.parentSessionId } : {},
+    systemPrompt: input.systemPrompt,
+    input: input.input,
+    messages,
+    skills: input.skills?.map(createJson.new) ?? [],
+    createdAt,
+    updatedAt: createdAt,
+    ...input.title ? { title: input.title } : {}
+  };
+}
+
+// src/loop/phases/built-in/chat/index.ts
+function chat_default(api) {
+  api.registerPhase({
+    ...api.manifest?.phase,
+    id: "chat",
+    async run(context, input) {
+      const collected = await context.turn(() => context.model.invoke({ input }));
+      if (collected.stopReason === "aborted") {
+        return { message: collected.text, route: "stop", toolCalls: collected.toolCalls };
+      }
+      const nonRouteToolCalls = collected.toolCalls.filter((t) => t.name !== "route");
+      if (nonRouteToolCalls.length > 0) {
+        return { message: collected.text.trim() || "Executing tools.", route: "execute", toolCalls: collected.toolCalls };
+      }
+      return { message: collected.text.trim() || "Done.", route: "stop", toolCalls: collected.toolCalls };
+    }
+  });
+}
+
+// src/loop/phases/built-in/execute/index.ts
+function execute_default(api) {
+  api.registerPhase({
+    ...api.manifest?.phase,
+    id: "execute",
+    prompt: {
+      instructions: [
+        "Phase: execute",
+        "",
+        "Execute the task by calling the appropriate tools.",
+        "If more tool calls are needed, continue calling tools.",
+        "If execution is complete, respond with a brief summary and call the 'route' tool."
+      ]
+    },
+    async run(context, input) {
+      context.incrementAttempt();
+      const maxAttempts = context.maxAttempts ?? 2;
+      let collected;
+      try {
+        collected = await context.turn(() => context.model.invoke({
+          input,
+          autoExecuteTools: true,
+          excludeTools: ["route"]
+        }));
+      } catch (error) {
+        if (context.state.attempt < maxAttempts) {
+          return {
+            message: "Execution error, retrying.",
+            route: "execute"
+          };
+        }
+        return {
+          message: "Execution error, no retries remaining.",
+          route: "stop"
+        };
+      }
+      if (collected.stopReason === "aborted") {
+        return { message: collected.text, route: "stop", toolCalls: collected.toolCalls };
+      }
+      if (collected.toolCalls.length > 0) {
+        return { message: collected.text ?? "", route: "stop", toolCalls: collected.toolCalls };
+      }
+      return { message: collected.text ?? "", route: "chat" };
+    }
+  });
+}
+
+// src/loop/phases/built-in/plan/index.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeTask(value) {
+  if (!isRecord(value)) throw new Error("Expected task to be an object.");
+  const status = value.status;
+  if (status !== "pending" && status !== "running" && status !== "passed" && status !== "failed") {
+    throw new Error("Expected task status to be pending, running, passed, or failed.");
+  }
+  return {
+    id: typeof value.id === "string" ? value.id : "",
+    title: typeof value.title === "string" ? value.title : "",
+    instruction: typeof value.instruction === "string" ? value.instruction : "",
+    acceptanceCriteria: Array.isArray(value.acceptanceCriteria) ? value.acceptanceCriteria.map(
+      (c) => typeof c === "string" ? c : isRecord(c) && typeof c.description === "string" ? c.description : String(c)
+    ) : [],
+    toolNames: Array.isArray(value.toolNames) ? value.toolNames.filter((t) => typeof t === "string") : [],
+    skillIds: Array.isArray(value.skillIds) ? value.skillIds.filter((s) => typeof s === "string") : [],
+    status,
+    attempts: typeof value.attempts === "number" ? value.attempts : 0
+  };
+}
+function plan_default(api) {
+  api.registerPhase({
+    ...api.manifest?.phase,
+    id: "plan",
+    prompt: {
+      instructions: [
+        "Phase: plan",
+        "",
+        "Analyze the user's request and create a task plan.",
+        'Output a JSON object: { "task": { ... }, "message": "explanation" }',
+        "Task fields: title, instruction, acceptanceCriteria, toolNames, skillIds, status, attempts.",
+        'Prefer setting task.status to "pending" and task.attempts to 0.',
+        "Use toolNames only from the available tools. Use skillIds only from the loaded skills.",
+        "After outputting the task JSON, call the 'route' tool to indicate the next phase."
+      ]
+    },
+    async run(context, input) {
+      const collected = await context.turn(() => context.model.invoke({ input }));
+      let raw;
+      try {
+        raw = JSON.parse(collected.text);
+      } catch {
+        return {
+          message: "",
+          route: "stop",
+          toolCalls: collected.toolCalls
+        };
+      }
+      const rawTask = raw?.task ?? raw;
+      if (!rawTask) {
+        throw new Error("Planner did not produce a structured task.");
+      }
+      normalizeTask(rawTask);
+      const message = raw?.message ?? "";
+      return {
+        message,
+        route: "stop",
+        toolCalls: collected.toolCalls
+      };
+    }
+  });
+}
+
+// src/loop/phases/built-in/verify/index.ts
+function verify_default(api) {
+  api.registerPhase({
+    ...api.manifest?.phase,
+    id: "verify",
+    prompt: {
+      instructions: [
+        "Phase: verify",
+        "",
+        "Review the task output against the acceptance criteria.",
+        "If the criteria are met, confirm and call the 'route' tool to stop or proceed.",
+        "If more work is needed, call tools to fix issues, then call the 'route' tool."
+      ]
+    },
+    async run(context, input) {
+      const maxAttempts = context.maxAttempts ?? 2;
+      let collected;
+      try {
+        collected = await context.turn(() => context.model.invoke({ input }));
+      } catch (error) {
+        if (context.state.attempt < maxAttempts) {
+          return {
+            message: "Verification error, retrying.",
+            route: "execute"
+          };
+        }
+        return {
+          message: "Verification error, no retries remaining.",
+          route: "stop"
+        };
+      }
+      const nonRouteToolCalls = collected.toolCalls.filter((t) => t.name !== "route");
+      if (nonRouteToolCalls.length > 0) {
+        return {
+          message: collected.text || "Fixing issues.",
+          route: "execute",
+          toolCalls: collected.toolCalls
+        };
+      }
+      return {
+        message: collected.text.trim() || "Verification complete.",
+        route: "stop",
+        toolCalls: collected.toolCalls
+      };
+    }
+  });
+}
+
+// src/loop/phases/built-in/index.ts
+var builtinPhases = [
+  chat_default,
+  plan_default,
+  execute_default,
+  verify_default
+];
+
+// src/loop/phases/registry.ts
+function definePhase(definition) {
+  return definition;
+}
+function validatePhaseRegistry(registry) {
+  if (!registry.entryPhaseId || registry.entryPhaseId.trim().length === 0) {
+    throw new Error("Phase registry must have a non-empty entryPhaseId.");
+  }
+  if (!Array.isArray(registry.phases) || registry.phases.length === 0) {
+    throw new Error("Phase registry must include at least one phase definition.");
+  }
+  const ids = /* @__PURE__ */ new Set();
+  for (const phase of registry.phases) {
+    if (!phase.id || phase.id.trim().length === 0) {
+      throw new Error("Each phase definition must have a non-empty id.");
+    }
+    if (ids.has(phase.id)) {
+      throw new Error(`Duplicate phase id: ${phase.id}`);
+    }
+    ids.add(phase.id);
+  }
+  if (!ids.has(registry.entryPhaseId)) {
+    throw new Error(`Entry phase id "${registry.entryPhaseId}" is not defined in phases.`);
+  }
+}
+function createPhaseRegistry(input) {
+  const phases = [...input.phases ?? []];
+  const registry = {
+    entryPhaseId: input.entryPhaseId ?? phases[0]?.id ?? "",
+    phases
+  };
+  validatePhaseRegistry(registry);
+  return registry;
+}
+function resolvePhaseEntry(registry, phaseId) {
+  const phase = registry.phases.find((p) => p.id === phaseId);
+  if (!phase) {
+    throw new Error(`Phase "${phaseId}" is not defined in the phase registry.`);
+  }
+  return phase;
+}
+function ensurePhaseRegistry(registry) {
+  validatePhaseRegistry(registry);
+  return registry;
+}
+var DEFAULT_PHASE_ID = process.env.ROWAN_DEFAULT_PHASE ?? "chat";
+
+// 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 collect all non-undefined results.
+   *
+   * @param eventType - Event type
+   * @param event - Event object
+   * @returns Array of non-undefined results
+   */
+  async emitCollect(eventType, event) {
+    const handlers = this.handlers.get(eventType);
+    if (!handlers?.length) return [];
+    const results = [];
+    const errors = [];
+    for (const handler of handlers) {
+      try {
+        const result = await handler(event);
+        if (result !== void 0) {
+          results.push(result);
+        }
+      } 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]
+      );
+    }
+    return results;
+  }
+  /**
+   * Emit event and return first non-undefined result (short-circuit).
+   *
+   * @param eventType - Event type
+   * @param event - Event object
+   * @returns First non-undefined result, or undefined
+   */
+  async emitFirst(eventType, event) {
+    const handlers = this.handlers.get(eventType);
+    if (!handlers?.length) return void 0;
+    for (const handler of handlers) {
+      try {
+        const result = await handler(event);
+        if (result !== void 0) return result;
+      } catch (error) {
+        throw new HookError(
+          eventType,
+          `Handler failed for "${eventType}"`,
+          error instanceof Error ? error : new Error(String(error))
+        );
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Emit event and aggregate results with reducer.
+   *
+   * @param eventType - Event type
+   * @param event - Event object
+   * @param reducer - Aggregation function
+   * @param initial - Initial value
+   * @returns Aggregated result
+   */
+  async emitReduce(eventType, event, reducer, initial) {
+    const results = await this.emitCollect(eventType, event);
+    return results.reduce(reducer, initial);
+  }
+};
+var _globalHooks;
+function getGlobalHooks() {
+  _globalHooks ??= new HooksManager();
+  return _globalHooks;
+}
+function resetGlobalHooks() {
+  _globalHooks = void 0;
+}
+
+// src/extensions/runner.ts
+import { execFile } from "child_process";
+
+// src/harness/context/section-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 lines = ["<available_skills>"];
+  for (const skill of skills) {
+    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");
+}
+
+// src/harness/context/system-prompt.ts
+function buildSystemPrompt(options) {
+  const { systemPrompt, promptGuidelines, appendSystemPrompt, tools, skills, cwd } = options;
+  const date = createTimestamp();
+  const guidelinesList = [];
+  const guidelinesSet = /* @__PURE__ */ new Set();
+  const addGuideline = (guideline) => {
+    const normalized = guideline.trim();
+    if (normalized.length === 0 || guidelinesSet.has(normalized)) return;
+    guidelinesSet.add(normalized);
+    guidelinesList.push(normalized);
+  };
+  const visibleTools = (tools ?? []).filter((t) => !!t.promptSnippet);
+  const toolsList = visibleTools.length > 0 ? visibleTools.map((t) => `- ${t.name}: ${t.promptSnippet}`).join("\n") : "(none)";
+  for (const tool of tools ?? []) {
+    for (const g of tool.promptGuidelines ?? []) {
+      addGuideline(g);
+    }
+  }
+  const skillsBlock = skills && skills.length > 0 ? buildSkillsDescription(skills) : "";
+  for (const g of promptGuidelines ?? []) {
+    addGuideline(g);
+  }
+  const guidelines = guidelinesList.map((g) => `- ${g}`).join("\n");
+  let prompt = `${systemPrompt}
+
+**Important:** Tool and skill availability varies by phase. Only use tools that are available in your current phase context.
+
+Available tools:
+${toolsList}
+
+Guidelines:
+${guidelines}`;
+  if (skillsBlock) {
+    prompt += `
+
+${skillsBlock}`;
+  }
+  if (date || cwd) {
+    const contextParts = [];
+    if (date) contextParts.push(`Current date: ${date}`);
+    if (cwd) contextParts.push(`Working directory: ${cwd}`);
+    prompt += `
+
+${contextParts.join("\n")}`;
+  }
+  if (appendSystemPrompt) {
+    prompt += `
+
+${appendSystemPrompt}`;
+  }
+  return prompt;
+}
+
+// src/harness/context/prompt-builder.ts
+function serializeSkills(skills) {
+  return skills.map((skill) => ({
+    name: skill.name,
+    description: skill.description,
+    filePath: skill.filePath
+  }));
+}
+function latestUserInput(input) {
+  for (let index = input.messages.length - 1; index >= 0; index -= 1) {
+    const message = input.messages[index];
+    if (message.role === "user") {
+      return message.content;
+    }
+  }
+  return "";
+}
+function conversationMessages(messages) {
+  return messages.flatMap((message) => {
+    if (message.role === "user") {
+      return [{ role: "user", content: message.content }];
+    }
+    if (message.role === "assistant") {
+      const toolCalls = message.metadata?.toolCalls;
+      if (!toolCalls?.length) {
+        return [{ role: "assistant", content: message.content }];
+      }
+    }
+    if (message.role === "assistant" && Array.isArray(message.metadata?.toolCalls)) {
+      const toolCalls = message.metadata.toolCalls;
+      const content = [];
+      if (message.content) {
+        content.push({ type: "text", text: message.content });
+      }
+      for (const tc of toolCalls) {
+        content.push({ type: "tool_use", id: tc.id, name: tc.name, input: tc.args });
+      }
+      return [{ role: "assistant", content }];
+    }
+    if (message.role === "tool") {
+      const toolCallId = message.metadata?.toolCallId ?? "";
+      const isError = message.metadata?.isError;
+      const content = [
+        { type: "tool_result", toolUseId: toolCallId, content: message.content, isError }
+      ];
+      return [{ role: "tool", content }];
+    }
+    return [];
+  });
+}
+function buildModelRequest(input, options) {
+  const toolMeta = input.tools.map((t) => ({
+    name: t.name,
+    description: t.description,
+    promptSnippet: t.promptSnippet,
+    promptGuidelines: t.promptGuidelines
+  }));
+  let systemText = buildSystemPrompt({
+    systemPrompt: input.systemPrompt,
+    tools: toolMeta,
+    skills: input.skills.length > 0 ? serializeSkills(input.skills) : void 0,
+    promptGuidelines: input.promptGuidelines,
+    appendSystemPrompt: input.appendSystemPrompt
+  });
+  const messages = [...conversationMessages(input.messages)];
+  const modelTools = (input.phaseTools ?? input.tools).map((t) => ({
+    name: t.name,
+    description: t.description,
+    parameters: t.parameters
+  }));
+  return {
+    model: options?.model ?? { provider: "", name: "" },
+    system: systemText,
+    messages,
+    tools: modelTools.length > 0 ? modelTools : void 0
+  };
+}
+
+// src/extensions/runner.ts
+import {
+  registerModel,
+  unregisterProviderModels,
+  registerApiProvider
+} from "@rowan-agent/models";
+
+// src/extensions/source-info.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
+  };
+}
+
+// src/extensions/types.ts
+function createExtension(extensionPath, resolvedPath, sourceInfo) {
+  return {
+    path: extensionPath,
+    resolvedPath,
+    sourceInfo,
+    handlers: /* @__PURE__ */ new Map(),
+    tools: /* @__PURE__ */ new Map(),
+    phases: /* @__PURE__ */ new Map()
+  };
+}
+function createExtensionRuntime() {
+  const state = {};
+  const assertActive = () => {
+    if (state.staleMessage) {
+      throw new Error(state.staleMessage);
+    }
+  };
+  const runtime = {
+    assertActive,
+    invalidate: (message) => {
+      state.staleMessage ??= message ?? "This extension context is stale after session replacement or reload. Do not use a captured extension API after the runner has been replaced.";
+    },
+    pendingProviderRegistrations: [],
+    // Pre-bind: queue registrations so bind() can flush them once the
+    // model registry is available. bind() replaces both with direct calls.
+    registerProvider: (name, config, extensionPath = "<unknown>") => {
+      runtime.pendingProviderRegistrations.push({ name, config, extensionPath });
+    },
+    unregisterProvider: (name) => {
+      runtime.pendingProviderRegistrations = runtime.pendingProviderRegistrations.filter(
+        (r) => r.name !== name
+      );
+    }
+  };
+  return runtime;
+}
+
+// src/extensions/event-bus.ts
+function createEventBus() {
+  const listeners = /* @__PURE__ */ new Map();
+  return {
+    on(event, listener) {
+      const set = listeners.get(event) ?? /* @__PURE__ */ new Set();
+      set.add(listener);
+      listeners.set(event, set);
+      return () => {
+        set.delete(listener);
+        if (set.size === 0) listeners.delete(event);
+      };
+    },
+    emit(event, ...args) {
+      const set = listeners.get(event);
+      if (!set) return;
+      for (const listener of set) {
+        try {
+          listener(...args);
+        } catch (err) {
+          console.error(`[event-bus] Listener error for "${event}":`, err);
+        }
+      }
+    },
+    off(event) {
+      if (event) {
+        listeners.delete(event);
+      } else {
+        listeners.clear();
+      }
+    },
+    has(event) {
+      const set = listeners.get(event);
+      return set !== void 0 && set.size > 0;
+    },
+    count(event) {
+      return listeners.get(event)?.size ?? 0;
+    }
+  };
+}
+
+// src/extensions/context.ts
+function createExtensionAPI(hooks, _extensionPath, options, runtime, eventBus) {
+  let idCounter = 0;
+  const createId3 = (prefix) => {
+    idCounter++;
+    return `${prefix}_${Date.now().toString(36)}_${idCounter}`;
+  };
+  const formatJson = (value) => {
+    try {
+      return JSON.stringify(value, null, 2) ?? "undefined";
+    } catch {
+      return "[unserializable]";
+    }
+  };
+  const createPromptBuilder = (instructions) => {
+    return (input) => {
+      const req = buildModelRequest(input);
+      if (instructions.length > 0) {
+        req.messages.push({
+          role: "user",
+          content: instructions.join("\n")
+        });
+      }
+      return req;
+    };
+  };
+  return {
+    on: (eventType, handler) => {
+      runtime.assertActive();
+      hooks.on(eventType, handler);
+    },
+    off: (eventType, handler) => {
+      runtime.assertActive();
+      hooks.off(eventType, handler);
+    },
+    registerTool: (tool) => {
+      runtime.assertActive();
+      options.registerTool(tool);
+    },
+    registerPhase: (registration) => {
+      runtime.assertActive();
+      options.registerPhase(registration);
+    },
+    registerProvider: (config) => {
+      runtime.assertActive();
+      options.registerProvider(config);
+    },
+    unregisterProvider: (name) => {
+      runtime.assertActive();
+      options.unregisterProvider(name);
+    },
+    manifest: options.manifest,
+    utils: {
+      createId: createId3,
+      formatJson,
+      buildModelRequest,
+      createPromptBuilder
+    },
+    context: options.context,
+    events: eventBus
+  };
+}
+
+// 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;
+        }
+        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({ api: config.api, stream: config.streamSimple });
+  }
+  for (const modelConfig of config.models) {
+    registerModel({
+      id: modelConfig.id,
+      name: modelConfig.name,
+      api: config.api,
+      provider: config.name,
+      baseUrl: config.baseUrl,
+      reasoning: modelConfig.reasoning,
+      input: modelConfig.input,
+      cost: modelConfig.cost,
+      contextWindow: modelConfig.contextWindow,
+      maxTokens: modelConfig.maxTokens,
+      ...config.headers ? { headers: config.headers } : {}
+    });
+  }
+}
+function applyProviderUnregistration(name) {
+  unregisterProviderModels(name);
+}
+var ExtensionRunner = class {
+  hooks;
+  runtime;
+  events;
+  validatePhaseOverride;
+  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 = [];
+  constructor(options) {
+    this.hooks = new HooksManager();
+    this.runtime = createExtensionRuntime();
+    this.events = createEventBus();
+    this.validatePhaseOverride = options?.validatePhaseOverride;
+    this.cwd = options?.cwd ?? process.cwd();
+  }
+  /** Whether the agent is currently idle (not streaming). */
+  get isIdle() {
+    return this._idle;
+  }
+  /** Set idle state — called by the agent loop. */
+  setIdle(idle) {
+    this._idle = idle;
+  }
+  /** Abort signal for the current runner instance. */
+  get signal() {
+    return this.abortController.signal;
+  }
+  /** Abort the current runner operation. */
+  abort() {
+    this.abortController.abort();
+  }
+  // ---------------------------------------------------------------------------
+  // Error handling
+  // ---------------------------------------------------------------------------
+  /**
+   * Register an error listener.
+   * Returns an unsubscribe function.
+   */
+  onError(listener) {
+    this.errorListeners.add(listener);
+    return () => this.errorListeners.delete(listener);
+  }
+  /**
+   * Emit a structured extension error to all listeners.
+   */
+  emitError(error) {
+    for (const listener of this.errorListeners) {
+      try {
+        listener(error);
+      } catch (err) {
+        console.error("[extension-runner] Error listener failed:", err);
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Lifecycle: invalidate / assertActive
+  // ---------------------------------------------------------------------------
+  /**
+   * Mark all extension contexts as stale.
+   * After calling this, any captured ExtensionAPI or ExtensionContext will throw
+   * on use. Used during session replacement or reload.
+   */
+  invalidate(message) {
+    this.runtime.invalidate(message);
+  }
+  // ---------------------------------------------------------------------------
+  // Direct hook API
+  // ---------------------------------------------------------------------------
+  /**
+   * Subscribe to a specific hook event type.
+   * Returns an unsubscribe function.
+   *
+   * @example
+   * ```ts
+   * const unsub = runner.on("before_tool_call", (event) => {
+   *   return { allow: false, reason: "Blocked" };
+   * });
+   * unsub(); // Cancel subscription
+   * ```
+   */
+  on(type, handler) {
+    this.hooks.on(type, handler);
+    return () => this.hooks.off(type, handler);
+  }
+  /**
+   * Subscribe to all events (read-only).
+   * Returns an unsubscribe function.
+   *
+   * @example
+   * ```ts
+   * const unsub = runner.subscribe((event) => {
+   *   console.log(event.type);
+   * });
+   * ```
+   */
+  subscribe(listener) {
+    const handlers = /* @__PURE__ */ new Map();
+    for (const eventType of this.getAllEventTypes()) {
+      const handler = (event) => listener(event);
+      handlers.set(eventType, handler);
+      this.hooks.on(eventType, handler);
+    }
+    return () => {
+      for (const [eventType, handler] of handlers) {
+        this.hooks.off(eventType, handler);
+      }
+    };
+  }
+  getAllEventTypes() {
+    return [
+      "before_phase",
+      "after_phase",
+      "before_prompt",
+      "before_tool_call",
+      "after_tool_call",
+      "agent_start",
+      "agent_end",
+      "turn_start",
+      "turn_end",
+      "message_start",
+      "message_update",
+      "message_end",
+      "tool_execution_start",
+      "tool_execution_update",
+      "tool_execution_end",
+      "queue_update",
+      "save_point",
+      "abort",
+      "settled"
+    ];
+  }
+  // ---------------------------------------------------------------------------
+  // Extension loading
+  // ---------------------------------------------------------------------------
+  /**
+   * Load and initialize extensions.
+   * Creates Extension tracking objects and calls each factory with an ExtensionAPI.
+   */
+  async loadExtensions(extensions) {
+    for (const ext of extensions) {
+      try {
+        const sourceInfo = createSourceInfo(ext.path, {
+          source: ext.path.startsWith("<builtin:") ? "builtin" : "local",
+          baseDir: ext.resolvedPath.startsWith("<") ? void 0 : ext.resolvedPath
+        });
+        const extension = createExtension(ext.path, ext.resolvedPath, sourceInfo);
+        const api = this.createExtensionAPI(extension, ext.manifest);
+        await ext.factory(api);
+        this.extensions.push(extension);
+        this.loadedExtensions.push(ext);
+        this._phaseCache = null;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.emitError({
+          extensionPath: ext.path,
+          event: "load",
+          error: message,
+          stack: error instanceof Error ? error.stack : void 0
+        });
+        throw error;
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Tool management
+  // ---------------------------------------------------------------------------
+  /**
+   * Get all registered tools from all extensions (first registration per name wins).
+   */
+  getAllRegisteredTools() {
+    const toolsByName = /* @__PURE__ */ new Map();
+    for (const ext of this.extensions) {
+      for (const tool of ext.tools.values()) {
+        if (!toolsByName.has(tool.definition.name)) {
+          toolsByName.set(tool.definition.name, tool);
+        }
+      }
+    }
+    return Array.from(toolsByName.values());
+  }
+  /**
+   * Get a tool definition by name. Returns undefined if not found.
+   */
+  getToolDefinition(toolName) {
+    for (const ext of this.extensions) {
+      const tool = ext.tools.get(toolName);
+      if (tool) return tool.definition;
+    }
+    return void 0;
+  }
+  // ---------------------------------------------------------------------------
+  // Handler queries
+  // ---------------------------------------------------------------------------
+  /**
+   * Check if there are handlers registered for specified event type.
+   */
+  hasHandlers(eventType) {
+    return this.hooks.has(eventType);
+  }
+  /**
+   * Get the number of handlers for specified event type.
+   */
+  handlerCount(eventType) {
+    return this.hooks.count(eventType);
+  }
+  // ---------------------------------------------------------------------------
+  // Phase management
+  // ---------------------------------------------------------------------------
+  getPhase(id) {
+    return this.getRegisteredPhase(id)?.definition;
+  }
+  getPhases() {
+    return [...this.collectRegisteredPhases().values()].map(
+      (p) => p.definition
+    );
+  }
+  getPhaseHandler(id) {
+    return this.getRegisteredPhase(id)?.handler;
+  }
+  createPhaseRegistry(input = {}) {
+    const registered = this.collectRegisteredPhases();
+    return createPhaseRegistry({
+      entryPhaseId: input.entryPhaseId,
+      phases: [...registered.values()].map((p) => p.definition)
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // Lifecycle
+  // ---------------------------------------------------------------------------
+  /**
+   * Bind the runner — flushes pending provider registrations and
+   * replaces runtime stubs with real implementations.
+   */
+  bind() {
+    if (this.bound) return;
+    this.bound = true;
+    this.flushPendingProviders();
+    this.runtime.registerProvider = (_name, config) => {
+      applyProviderRegistration(config);
+    };
+    this.runtime.unregisterProvider = (_name) => {
+      applyProviderUnregistration(_name);
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Unified hook emission
+  // ---------------------------------------------------------------------------
+  /**
+   * Generic emit — fire-and-forget for any event type.
+   */
+  async emit(eventType, event) {
+    await this.hooks.emit(eventType, event);
+  }
+  /**
+   * Unified hook emission — returns the first non-undefined result.
+   */
+  async emitHook(type, event) {
+    return this.hooks.emitFirst(type, event);
+  }
+  // ---------------------------------------------------------------------------
+  // Phase hooks (with inline processing)
+  // ---------------------------------------------------------------------------
+  async emitBeforePhase(phaseId, input) {
+    const result = await this.emitHook("before_phase", {
+      type: "before_phase",
+      phaseId,
+      input
+    });
+    return result ?? {};
+  }
+  async emitAfterPhase(phaseId, output) {
+    const result = await this.emitHook("after_phase", {
+      type: "after_phase",
+      phaseId,
+      output
+    });
+    return result ?? {};
+  }
+  async emitBeforePrompt(phaseId, input) {
+    const result = await this.emitHook("before_prompt", {
+      type: "before_prompt",
+      phaseId,
+      input
+    });
+    return result?.input ?? input;
+  }
+  async emitBeforeToolCall(tool, args) {
+    const result = await this.emitHook("before_tool_call", {
+      type: "before_tool_call",
+      tool,
+      args
+    });
+    return result ?? { allow: true };
+  }
+  async emitAfterToolCall(tool, result) {
+    const hookResult = await this.emitHook("after_tool_call", {
+      type: "after_tool_call",
+      tool,
+      result
+    });
+    return hookResult?.result ?? result;
+  }
+  // ---------------------------------------------------------------------------
+  // Agent event hooks (fire-and-forget)
+  // ---------------------------------------------------------------------------
+  async emitAgentStart(sessionId) {
+    await this.hooks.emit("agent_start", { type: "agent_start", sessionId });
+  }
+  async emitAgentEnd(sessionId, outcome, messages) {
+    await this.hooks.emit("agent_end", { type: "agent_end", sessionId, outcome, messages });
+  }
+  async emitTurnStart(messages) {
+    await this.hooks.emit("turn_start", { type: "turn_start", messages });
+  }
+  async emitTurnEnd(messages, outcome) {
+    await this.hooks.emit("turn_end", { type: "turn_end", messages, outcome });
+  }
+  async emitMessageStart(message) {
+    await this.hooks.emit("message_start", { type: "message_start", message });
+  }
+  async emitMessageUpdate(message, delta) {
+    await this.hooks.emit("message_update", { type: "message_update", message, delta });
+  }
+  async emitMessageEnd(message) {
+    await this.hooks.emit("message_end", { type: "message_end", message });
+  }
+  async emitToolExecutionStart(toolCallId, toolName, args) {
+    await this.hooks.emit("tool_execution_start", {
+      type: "tool_execution_start",
+      toolCallId,
+      toolName,
+      args
+    });
+  }
+  async emitToolExecutionUpdate(toolCallId, toolName, _progress) {
+    await this.hooks.emit("tool_execution_update", {
+      type: "tool_execution_update",
+      toolCallId,
+      toolName
+    });
+  }
+  async emitToolExecutionEnd(toolCallId, toolName, result) {
+    await this.hooks.emit("tool_execution_end", {
+      type: "tool_execution_end",
+      toolCallId,
+      toolName,
+      result
+    });
+  }
+  async emitSavePoint(hadPendingMutations) {
+    await this.hooks.emit("save_point", { type: "save_point", hadPendingMutations });
+  }
+  async emitAbort(reason) {
+    await this.hooks.emit("abort", { type: "abort", reason });
+  }
+  async emitSettled() {
+    await this.hooks.emit("settled", { type: "settled" });
+  }
+  // ---------------------------------------------------------------------------
+  // AgentEvent bridge (backward compatibility)
+  // ---------------------------------------------------------------------------
+  /**
+   * Emit an AgentEvent by routing to the appropriate typed hook.
+   */
+  async emitAgentEvent(event) {
+    switch (event.type) {
+      case "agent_start":
+        await this.emitAgentStart(event.sessionId);
+        break;
+      case "agent_end":
+        await this.emitAgentEnd(event.sessionId, event.outcome, event.messages);
+        break;
+      case "turn_start":
+        await this.emitTurnStart(event.messages);
+        break;
+      case "turn_end":
+        await this.emitTurnEnd(event.messages, event.outcome);
+        break;
+      case "message_start":
+        await this.emitMessageStart(event.message);
+        break;
+      case "message_update":
+        await this.emitMessageUpdate(event.message, event.delta);
+        break;
+      case "message_end":
+        await this.emitMessageEnd(event.message);
+        break;
+      case "tool_execution_start":
+        await this.emitToolExecutionStart(event.toolCallId, event.toolName, event.args);
+        break;
+      case "tool_execution_update":
+        await this.emitToolExecutionUpdate(event.toolCallId, event.toolName);
+        break;
+      case "tool_execution_end":
+        await this.emitToolExecutionEnd(event.toolCallId, event.toolName, event.result);
+        break;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Internal helpers
+  // ---------------------------------------------------------------------------
+  /**
+   * Create an ExtensionAPI for a specific extension.
+   * Registration methods write to the extension tracking object.
+   * Action methods delegate to the shared runtime.
+   */
+  createExtensionAPI(extension, manifest) {
+    const runner = this;
+    const extContext = {
+      get cwd() {
+        return runner.cwd;
+      },
+      get signal() {
+        return runner.abortController.signal;
+      },
+      isIdle() {
+        return runner._idle;
+      },
+      abort() {
+        runner.abortController.abort();
+      },
+      exec(command, args, options) {
+        return execCommand(command, args, runner.cwd, options);
+      },
+      manifest
+    };
+    return createExtensionAPI(this.hooks, extension.path, {
+      registerPhase: (registration) => this.registerPhase(extension, registration),
+      registerProvider: (config) => this.registerProvider(config),
+      unregisterProvider: (name) => this.unregisterProvider(name),
+      registerTool: (tool) => this.registerTool(extension, tool),
+      context: extContext,
+      manifest
+    }, this.runtime, this.events);
+  }
+  registerTool(extension, tool) {
+    for (const ext of this.extensions) {
+      if (ext.tools.has(tool.name)) {
+        this.emitError({
+          extensionPath: extension.path,
+          event: "register_tool",
+          error: `Tool "${tool.name}" is already registered by extension ${ext.path}`
+        });
+        return;
+      }
+    }
+    const sourceInfo = createSourceInfo(extension.path);
+    extension.tools.set(tool.name, {
+      definition: tool,
+      sourceInfo
+    });
+  }
+  registerPhase(extension, registration) {
+    if (!registration.id) {
+      throw new Error(`Phase registration requires an "id" field.`);
+    }
+    if (this.validatePhaseOverride?.(registration.id, extension.path)) {
+      throw new Error(
+        `External extension cannot override built-in phase: ${registration.id}`
+      );
+    }
+    if (this.phases.has(registration.id)) {
+      throw new Error(`Duplicate phase id: ${registration.id}`);
+    }
+    let buildPrompt = registration.buildPrompt;
+    if (!buildPrompt) {
+      const promptConfig = registration.prompt;
+      if (promptConfig?.instructions?.length) {
+        buildPrompt = (input) => {
+          const req = buildModelRequest(input);
+          req.messages.push({
+            role: "user",
+            content: promptConfig.instructions.join("\n")
+          });
+          return req;
+        };
+      } else {
+        buildPrompt = (input) => buildModelRequest(input);
+      }
+    }
+    const definition = {
+      id: registration.id,
+      name: registration.name ?? registration.id,
+      description: registration.description ?? "",
+      run: registration.run,
+      buildPrompt
+    };
+    this.phases.set(registration.id, {
+      definition,
+      handler: { buildPrompt },
+      source: { extensionPath: extension.path }
+    });
+    extension.phases.set(registration.id, {
+      definition,
+      handler: { buildPrompt },
+      source: { extensionPath: extension.path }
+    });
+    this._phaseCache = null;
+  }
+  registerProvider(config) {
+    if (this.bound) {
+      applyProviderRegistration(config);
+    } else {
+      this.pendingProviders.push({ kind: "register", config });
+    }
+  }
+  unregisterProvider(name) {
+    if (this.bound) {
+      applyProviderUnregistration(name);
+    } else {
+      this.pendingProviders.push({ kind: "unregister", name });
+    }
+  }
+  flushPendingProviders() {
+    for (const action of this.pendingProviders) {
+      if (action.kind === "register") {
+        applyProviderRegistration(action.config);
+      } else {
+        applyProviderUnregistration(action.name);
+      }
+    }
+    this.pendingProviders.length = 0;
+  }
+  getRegisteredPhase(id) {
+    return this.collectRegisteredPhases().get(id);
+  }
+  collectRegisteredPhases() {
+    if (this._phaseCache) return this._phaseCache;
+    this._phaseCache = new Map(this.phases);
+    return this._phaseCache;
+  }
+};
+function createExtensionRunner(options) {
+  return new ExtensionRunner(options);
+}
+
+// src/extensions/builtin.ts
+import { resolve as resolve2, dirname as dirname2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/extensions/loader.ts
+import { existsSync, readFileSync } from "fs";
+import { readdir, readFile, stat } from "fs/promises";
+import { fileURLToPath } from "url";
+import { dirname, extname, join, resolve } 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 = join(dir, "package.json");
+  if (!existsSync(manifestPath)) {
+    return void 0;
+  }
+  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;
+  }
+}
+function jitiAliases() {
+  return {
+    "@rowan-agent/agent": fileURLToPath(new URL("../index.ts", import.meta.url)),
+    "@rowan-agent/models": fileURLToPath(new URL("../../../models/src/index.ts", import.meta.url))
+  };
+}
+var sharedJiti;
+function getJiti() {
+  sharedJiti ??= createJiti(import.meta.url, {
+    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 (!existsSync(path)) {
+    return void 0;
+  }
+  const content = await readFile(path, "utf8");
+  return JSON.parse(content);
+}
+async function resolveExtensionEntries(dir) {
+  const manifest = await readPackageManifest(join(dir, "package.json"));
+  const declared = manifest?.rowan?.extensions;
+  if (declared && declared.length > 0) {
+    return declared.map((entry) => resolve(dir, entry));
+  }
+  for (const name of ["index.ts", "index.js"]) {
+    const entry = join(dir, name);
+    if (existsSync(entry)) {
+      return [entry];
+    }
+  }
+  return void 0;
+}
+async function discoverExtensionsInDir(dir) {
+  const entries = await readdir(dir, { withFileTypes: true }).catch((error) => {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  });
+  const paths = [];
+  for (const entry of [...entries].sort((a, b) => a.name.localeCompare(b.name))) {
+    const entryPath = join(dir, entry.name);
+    if ((entry.isFile() || entry.isSymbolicLink()) && isExtensionFile(entry.name)) {
+      paths.push(entryPath);
+      continue;
+    }
+    if (entry.isDirectory() || entry.isSymbolicLink()) {
+      const info = entry.isSymbolicLink() ? await stat(entryPath).catch(() => void 0) : void 0;
+      if (entry.isDirectory() || info?.isDirectory()) {
+        const resolvedEntries = await resolveExtensionEntries(entryPath);
+        if (resolvedEntries) {
+          paths.push(...resolvedEntries);
+        }
+      }
+    }
+  }
+  return paths;
+}
+function loadExtensionFromFactory(factory, cwd, extensionPath = "<inline>") {
+  const resolvedCwd = resolve(cwd);
+  const resolvedPath = isSyntheticPath(extensionPath) ? extensionPath : resolve(resolvedCwd, extensionPath);
+  const name = isSyntheticPath(extensionPath) ? extensionPath : dirname(resolvedPath).split("/").pop() ?? "unknown";
+  const manifestDir = isSyntheticPath(extensionPath) ? resolvedCwd : dirname(resolvedPath);
+  const manifest = readManifestSync(manifestDir);
+  return {
+    path: extensionPath,
+    resolvedPath,
+    name,
+    factory,
+    manifest
+  };
+}
+var loadExtensionFromFactorySync = loadExtensionFromFactory;
+async function loadExtensions(paths, cwd) {
+  const extensions = [];
+  const errors = [];
+  const resolvedCwd = resolve(cwd);
+  for (const path of paths) {
+    const resolvedPath = resolve(resolvedCwd, path);
+    try {
+      const factory = await loadExtensionModule(resolvedPath);
+      if (!factory) {
+        errors.push({
+          path: resolvedPath,
+          error: `Extension does not export a valid factory function: ${path}`
+        });
+        continue;
+      }
+      extensions.push(loadExtensionFromFactory(factory, resolvedCwd, resolvedPath));
+    } catch (error) {
+      errors.push({
+        path: resolvedPath,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return { extensions, errors };
+}
+async function discoverAndLoadExtensions(cwd) {
+  const extensionsDir = join(resolve(cwd), ROWAN_DIR, EXTENSIONS_DIR);
+  const paths = await discoverExtensionsInDir(extensionsDir);
+  return loadExtensions(paths, cwd);
+}
+
+// src/extensions/builtin.ts
+var BUILTIN_PHASE_IDS = /* @__PURE__ */ new Set(["chat", "plan", "execute", "verify"]);
+var __dirname = dirname2(fileURLToPath2(import.meta.url));
+var builtinPhaseDirs = [
+  resolve2(__dirname, "../loop/phases/built-in/chat"),
+  resolve2(__dirname, "../loop/phases/built-in/plan"),
+  resolve2(__dirname, "../loop/phases/built-in/execute"),
+  resolve2(__dirname, "../loop/phases/built-in/verify")
+];
+var builtinPhaseNames = ["chat", "plan", "execute", "verify"];
+function isBuiltinSource(path) {
+  return path.startsWith("<builtin:");
+}
+function isBuiltinPhaseOverride(phaseId, extensionPath) {
+  return BUILTIN_PHASE_IDS.has(phaseId) && !isBuiltinSource(extensionPath);
+}
+var _builtinRunner;
+var _builtinExtensions = [];
+async function ensureBuiltin() {
+  if (!_builtinRunner) {
+    const extensions = builtinPhases.map(
+      (factory, index) => loadExtensionFromFactory(factory, builtinPhaseDirs[index], `<builtin:phase:${builtinPhaseNames[index]}>`)
+    );
+    _builtinRunner = createExtensionRunner({
+      validatePhaseOverride: isBuiltinPhaseOverride
+    });
+    await _builtinRunner.loadExtensions(extensions);
+    _builtinRunner.bind();
+    _builtinExtensions = extensions;
+  }
+  return { runner: _builtinRunner, extensions: _builtinExtensions };
+}
+async function getBuiltinExtensions() {
+  const { extensions } = await ensureBuiltin();
+  return [...extensions];
+}
+function getBuiltinRunner() {
+  if (!_builtinRunner) {
+    throw new Error("Builtin runner not initialized. Call getBuiltinExtensions() first.");
+  }
+  return _builtinRunner;
+}
+async function createBuiltinPhaseRegistry(input = {}) {
+  const { runner } = await ensureBuiltin();
+  return runner.createPhaseRegistry({ entryPhaseId: input.entryPhaseId ?? DEFAULT_PHASE_ID });
+}
+async function createDefaultPhaseRegistry(options = {}) {
+  const cwd = resolve2(options.cwd ?? process.cwd());
+  const runner = createExtensionRunner({
+    validatePhaseOverride: isBuiltinPhaseOverride
+  });
+  const builtinExts = builtinPhases.map(
+    (factory, index) => loadExtensionFromFactory(factory, builtinPhaseDirs[index], `<builtin:phase:${builtinPhaseNames[index]}>`)
+  );
+  await runner.loadExtensions(builtinExts);
+  const result = await discoverAndLoadExtensions(cwd);
+  if (result.errors.length > 0) {
+    const details = result.errors.map((error) => `${error.path}: ${error.error}`).join("; ");
+    throw new Error(`Failed to load Rowan extensions: ${details}`);
+  }
+  await runner.loadExtensions(result.extensions);
+  runner.bind();
+  return runner.createPhaseRegistry({ entryPhaseId: options.entryPhaseId ?? DEFAULT_PHASE_ID });
+}
+
+// src/harness/tools/index.ts
+import { mkdir, readFile as readFile2, stat as stat2, writeFile } from "fs/promises";
+import { dirname as dirname3, isAbsolute, relative, resolve as resolve3, sep } from "path";
+import Type3 from "typebox";
+import Schema from "typebox/schema";
+
+// src/harness/tools/route-tool.ts
+import Type from "typebox";
+var PhaseRouteTool = "route";
+function buildRouteDescription(availablePhases) {
+  const phasesBlock = buildStructuredSection("phase", [
+    ...availablePhases.map((p) => ({ id: p.id, description: p.description })),
+    { id: "stop", description: "End execution and return the result to the user" }
+  ]);
+  return [
+    "Decide the next step in the workflow by routing to a specific phase.",
+    "",
+    "You MUST call this tool when you have completed the current phase's work",
+    "and are ready to hand off to the next phase or end execution.",
+    "",
+    "<available_phases>",
+    phasesBlock,
+    "</available_phases>",
+    "",
+    "Choose the phase that best matches what needs to happen next.",
+    "Use the 'reason' field to briefly explain your routing decision."
+  ].join("\n");
+}
+function createRouteTool(availablePhases) {
+  return {
+    name: PhaseRouteTool,
+    description: buildRouteDescription(availablePhases),
+    parameters: Type.Object({
+      route: Type.Union([
+        ...availablePhases.map((p) => Type.Literal(p.id)),
+        Type.Literal("stop")
+      ], { description: "Target phase id, or 'stop' to end" }),
+      reason: Type.Optional(Type.String({ description: "Brief reason for the routing decision" }))
+    }),
+    // No-op: this tool is intercepted by phases, never executed via tool execution
+    execute: async (args, context) => ({
+      toolCallId: context.toolCallId,
+      toolName: PhaseRouteTool,
+      ok: true,
+      content: ""
+    })
+  };
+}
+function extractRouteCall(toolCalls) {
+  const routeCall = toolCalls.find((t) => t.name === PhaseRouteTool);
+  if (!routeCall) return void 0;
+  const args = routeCall.args;
+  return {
+    route: typeof args.route === "string" ? args.route : "stop",
+    reason: typeof args.reason === "string" ? args.reason : void 0
+  };
+}
+
+// src/harness/tools/thread-tool.ts
+import Type2 from "typebox";
+var ThreadTool = "thread";
+function buildThreadDescription(availableSkills) {
+  const lines = [
+    "Spawn a sub-agent to handle an independent subtask.",
+    "",
+    "The sub-agent runs a full agent loop on the given prompt,",
+    "then returns the result. Use this to delegate well-scoped, parallelizable work",
+    "that would otherwise clutter the current context.",
+    "",
+    "When to use:",
+    "- A self-contained subtask that doesn't need back-and-forth with the current conversation.",
+    "- Parallel work that can run independently (e.g. research, file generation, testing).",
+    "- When the current context is getting long and a fresh scope would be cleaner.",
+    "",
+    "When NOT to use:",
+    "- Tasks that require access to the current conversation's full history.",
+    "- Simple tool calls that can be done directly in the current phase.",
+    "- Tasks that need real-time interaction with the user."
+  ];
+  if (availableSkills.length > 0) {
+    const skillsBlock = buildStructuredSection(
+      "skill",
+      availableSkills.map((s) => ({ name: s.name, description: s.description }))
+    );
+    lines.push("");
+    lines.push("<available_skills>");
+    lines.push(skillsBlock);
+    lines.push("</available_skills>");
+  }
+  lines.push("");
+  lines.push("The sub-agent inherits the current model and system prompt.");
+  return lines.join("\n");
+}
+function extractThreadSummary(result) {
+  for (let i = result.messages.length - 1; i >= 0; i--) {
+    const msg = result.messages[i];
+    if (msg.role === "assistant" && msg.content.trim().length > 0) {
+      return msg.content.trim();
+    }
+  }
+  if (result.outcome.message) {
+    return result.outcome.message;
+  }
+  return `Sub-agent completed with outcome: ${result.outcome.id}`;
+}
+function resolveSkills(names, available) {
+  const byName = new Map(available.map((s) => [s.name, s]));
+  const resolved = [];
+  for (const name of names) {
+    const skill = byName.get(name);
+    if (skill) {
+      resolved.push(skill);
+    }
+  }
+  return resolved;
+}
+function resolveTools(names, available) {
+  const byName = new Map(available.map((t) => [t.name, t]));
+  const resolved = [];
+  for (const name of names) {
+    const tool = byName.get(name);
+    if (tool) {
+      resolved.push(tool);
+    }
+  }
+  return resolved;
+}
+function createThreadTool(availableTools, availableSkills, spawnThread) {
+  return {
+    name: ThreadTool,
+    description: buildThreadDescription(availableSkills),
+    parameters: Type2.Object({
+      prompt: Type2.String({
+        description: "Clear, self-contained instructions for the sub-agent. Include all context needed \u2014 the sub-agent does NOT see the current conversation."
+      }),
+      tools: Type2.Optional(Type2.Array(
+        Type2.String(),
+        { description: "Tool names to make available to the sub-agent. Only include tools the subtask actually needs." }
+      )),
+      skills: Type2.Optional(Type2.Array(
+        Type2.String(),
+        { description: "Skill names to make available to the sub-agent. Only include skills the subtask actually needs." }
+      )),
+      limits: Type2.Optional(Type2.Object({
+        maxIterations: Type2.Optional(Type2.Number({
+          description: "Maximum phase iterations the sub-agent is allowed. Default: 50."
+        }))
+      }, { description: "Resource limits for the sub-agent. Omit to inherit defaults." }))
+    }),
+    execute: async (args, context) => {
+      const { prompt, tools: toolNames, skills: skillNames, limits } = args;
+      if (!prompt || prompt.trim().length === 0) {
+        return {
+          toolCallId: context.toolCallId,
+          toolName: ThreadTool,
+          ok: false,
+          content: "",
+          error: "Thread prompt must not be empty."
+        };
+      }
+      const resolvedTools = toolNames ? resolveTools(toolNames, availableTools) : void 0;
+      const resolvedSkills = skillNames ? resolveSkills(skillNames, context.state.skills) : void 0;
+      const result = await spawnThread({
+        prompt: prompt.trim(),
+        ...resolvedTools && resolvedTools.length > 0 ? { tools: resolvedTools } : {},
+        ...resolvedSkills && resolvedSkills.length > 0 ? { skills: resolvedSkills } : {},
+        ...limits ? { limits } : {}
+      });
+      const summary = extractThreadSummary(result);
+      const ok = result.outcome.id !== "aborted";
+      return {
+        toolCallId: context.toolCallId,
+        toolName: ThreadTool,
+        ok,
+        content: JSON.stringify({
+          summary,
+          outcome: result.outcome.id,
+          sessionId: result.sessionId,
+          messageCount: result.messages.length
+        }),
+        ...ok ? {} : { error: result.outcome.message || `Sub-agent ended with outcome: ${result.outcome.id}` }
+      };
+    }
+  };
+}
+
+// src/harness/tools/index.ts
+var DEFAULT_MAX_READ_BYTES = 64e3;
+var DEFAULT_BASH_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_BASH_OUTPUT_BYTES = 64e3;
+var ReadArgsSchema = Type3.Object({
+  path: Type3.String(),
+  maxBytes: Type3.Optional(Type3.Number())
+});
+var ReadArgsValidator = Schema.Compile(ReadArgsSchema);
+var WriteArgsSchema = Type3.Object({
+  path: Type3.String(),
+  content: Type3.String()
+});
+var WriteArgsValidator = Schema.Compile(WriteArgsSchema);
+var EditArgsSchema = Type3.Object({
+  path: Type3.String(),
+  oldText: Type3.String(),
+  newText: Type3.String(),
+  replaceAll: Type3.Optional(Type3.Boolean())
+});
+var EditArgsValidator = Schema.Compile(EditArgsSchema);
+var BashArgsSchema = Type3.Object({
+  command: Type3.String(),
+  cwd: Type3.Optional(Type3.String()),
+  timeoutMs: Type3.Optional(Type3.Number()),
+  maxOutputBytes: Type3.Optional(Type3.Number())
+});
+var BashArgsValidator = Schema.Compile(BashArgsSchema);
+var validatorCache = /* @__PURE__ */ new WeakMap();
+function validatorFor(schema) {
+  const cached = validatorCache.get(schema);
+  if (cached) {
+    return cached;
+  }
+  const validator = Schema.Compile(schema);
+  validatorCache.set(schema, validator);
+  return validator;
+}
+function normalizeRelativePath(path) {
+  return path.split(sep).join("/");
+}
+function normalizeCoreToolInputPath(path = ".") {
+  const trimmed = path.trim();
+  if (!trimmed || trimmed === "/" || trimmed === "\\") {
+    return ".";
+  }
+  return path;
+}
+function createCoreToolContext(input = {}) {
+  return {
+    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 = resolve3(context.root);
+  const inputPath = normalizeCoreToolInputPath(path);
+  const absolutePath = resolve3(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 || ".")
+  };
+}
+function toolResult(input) {
+  return {
+    toolCallId: input.context.toolCallId,
+    toolName: input.toolName,
+    ok: input.ok,
+    content: input.content,
+    ...input.error ? { error: input.error } : {}
+  };
+}
+async function executeRuntimeToolCall(input) {
+  const tool = input.tools.find((candidate) => candidate.name === input.toolCall.name);
+  if (!tool) {
+    const result = toolResult({
+      context: input.toolContext,
+      toolName: input.toolCall.name,
+      ok: false,
+      content: null,
+      error: `Unknown tool: ${input.toolCall.name}`
+    });
+    await input.observe?.({ type: "tool_end", toolName: input.toolCall.name, result });
+    return result;
+  }
+  let args;
+  try {
+    args = validatorFor(tool.parameters).Parse(input.toolCall.args);
+  } catch (error) {
+    const result = toolResult({
+      context: input.toolContext,
+      toolName: tool.name,
+      ok: false,
+      content: null,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    await input.observe?.({ type: "tool_end", toolName: tool.name, result });
+    return result;
+  }
+  let decision;
+  if (input.beforeToolCall) {
+    await input.observe?.({ type: "approval_requested", tool, args });
+    decision = await input.beforeToolCall({ tool, args });
+    await input.observe?.({
+      type: "approval_result",
+      tool,
+      args,
+      decision: decision ?? { allow: true }
+    });
+  }
+  if (decision && !decision.allow) {
+    const result = toolResult({
+      context: input.toolContext,
+      toolName: tool.name,
+      ok: false,
+      content: null,
+      error: decision.reason
+    });
+    await input.observe?.({ type: "tool_blocked", tool, reason: decision.reason });
+    return result;
+  }
+  await input.observe?.({ type: "tool_start", tool, args });
+  try {
+    const rawResult = await tool.execute(args, input.toolContext, input.signal);
+    let result = {
+      ...rawResult,
+      toolCallId: input.toolCall.id,
+      toolName: tool.name
+    };
+    if (input.afterToolCall) {
+      await input.observe?.({
+        type: "result_review_requested",
+        tool,
+        result
+      });
+      result = await input.afterToolCall({ tool, result });
+      await input.observe?.({
+        type: "result_review_result",
+        tool,
+        result
+      });
+    }
+    await input.observe?.({ type: "tool_end", toolName: tool.name, result });
+    return result;
+  } catch (error) {
+    const result = toolResult({
+      context: input.toolContext,
+      toolName: tool.name,
+      ok: false,
+      content: null,
+      error: error instanceof Error ? error.message : "Tool execution failed."
+    });
+    await input.observe?.({ type: "tool_end", toolName: tool.name, result });
+    return result;
+  }
+}
+function positiveNumber(value, name) {
+  if (!Number.isFinite(value) || value <= 0) {
+    return `${name} must be a positive number.`;
+  }
+  return void 0;
+}
+async function captureStream(stream, maxBytes) {
+  const reader = stream.getReader();
+  const chunks = [];
+  let totalBytes = 0;
+  let truncated = false;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    if (!value) {
+      continue;
+    }
+    const remainingBytes = maxBytes - totalBytes;
+    if (remainingBytes > 0) {
+      const kept = value.subarray(0, remainingBytes);
+      chunks.push(kept);
+      totalBytes += kept.byteLength;
+    }
+    if (value.byteLength > remainingBytes || totalBytes >= maxBytes) {
+      truncated = true;
+      await reader.cancel().catch(() => void 0);
+      break;
+    }
+  }
+  const bytes = new Uint8Array(totalBytes);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return {
+    text: new TextDecoder().decode(bytes),
+    truncated
+  };
+}
+function createReadTool(context) {
+  return {
+    name: "read",
+    description: "Reads a text file within the workspace.",
+    parameters: ReadArgsSchema,
+    promptSnippet: "Read a text file (max 64KB default).",
+    promptGuidelines: [
+      "Always read a file before editing or writing to understand its current content.",
+      "Use maxBytes to limit output for large files."
+    ],
+    async execute(args, toolContext) {
+      const parsed = ReadArgsValidator.Parse(args);
+      const resolved = resolveCoreToolPath(context, parsed.path);
+      const maxBytes = parsed.maxBytes ?? context.maxReadBytes;
+      const invalidLimit = positiveNumber(maxBytes, "maxBytes");
+      if (invalidLimit) {
+        return toolResult({
+          context: toolContext,
+          toolName: "read",
+          ok: false,
+          content: null,
+          error: invalidLimit
+        });
+      }
+      const fileStat = await stat2(resolved.absolutePath);
+      if (!fileStat.isFile()) {
+        return toolResult({
+          context: toolContext,
+          toolName: "read",
+          ok: false,
+          content: null,
+          error: `Not a file: ${resolved.relativePath}`
+        });
+      }
+      const bytes = await readFile2(resolved.absolutePath);
+      const sliced = bytes.subarray(0, maxBytes);
+      return toolResult({
+        context: toolContext,
+        toolName: "read",
+        ok: true,
+        content: {
+          path: resolved.relativePath,
+          content: new TextDecoder().decode(sliced),
+          sizeBytes: bytes.byteLength,
+          truncated: bytes.byteLength > maxBytes
+        }
+      });
+    }
+  };
+}
+function createWriteTool(context) {
+  return {
+    name: "write",
+    description: "Writes provided text content to a workspace file, creating parent directories as needed.",
+    parameters: WriteArgsSchema,
+    promptSnippet: "Write content to a file (creates parent dirs automatically).",
+    promptGuidelines: [
+      "Use write for new files or full file rewrites.",
+      "For partial edits, prefer the edit tool to avoid overwriting unchanged content."
+    ],
+    async execute(args, toolContext) {
+      const parsed = WriteArgsValidator.Parse(args);
+      const resolved = resolveCoreToolPath(context, parsed.path);
+      await mkdir(dirname3(resolved.absolutePath), { recursive: true });
+      await writeFile(resolved.absolutePath, parsed.content, "utf8");
+      return toolResult({
+        context: toolContext,
+        toolName: "write",
+        ok: true,
+        content: {
+          path: resolved.relativePath,
+          bytesWritten: new TextEncoder().encode(parsed.content).byteLength
+        }
+      });
+    }
+  };
+}
+function createEditTool(context) {
+  return {
+    name: "edit",
+    description: "Edits a workspace text file by replacing exact oldText with newText.",
+    parameters: EditArgsSchema,
+    promptSnippet: "Replace exact text in a file (oldText \u2192 newText).",
+    promptGuidelines: [
+      "Read the file first to get the exact oldText to replace.",
+      "oldText must be an exact match including whitespace and indentation.",
+      "If oldText appears multiple times, set replaceAll=true or provide more surrounding context."
+    ],
+    async execute(args, toolContext) {
+      const parsed = EditArgsValidator.Parse(args);
+      if (!parsed.oldText) {
+        return toolResult({
+          context: toolContext,
+          toolName: "edit",
+          ok: false,
+          content: null,
+          error: "oldText must not be empty."
+        });
+      }
+      const resolved = resolveCoreToolPath(context, parsed.path);
+      const current = await readFile2(resolved.absolutePath, "utf8");
+      if (!current.includes(parsed.oldText)) {
+        return toolResult({
+          context: toolContext,
+          toolName: "edit",
+          ok: false,
+          content: null,
+          error: `oldText not found in ${resolved.relativePath}.`
+        });
+      }
+      const matches = current.split(parsed.oldText).length - 1;
+      if (matches > 1 && !parsed.replaceAll) {
+        return toolResult({
+          context: toolContext,
+          toolName: "edit",
+          ok: false,
+          content: null,
+          error: `oldText appears ${matches} times in ${resolved.relativePath}; set replaceAll=true or provide more context.`
+        });
+      }
+      const replacements = parsed.replaceAll ? matches : 1;
+      const next = parsed.replaceAll ? current.split(parsed.oldText).join(parsed.newText) : current.replace(parsed.oldText, parsed.newText);
+      await writeFile(resolved.absolutePath, next, "utf8");
+      return toolResult({
+        context: toolContext,
+        toolName: "edit",
+        ok: true,
+        content: {
+          path: resolved.relativePath,
+          replacements,
+          bytesWritten: new TextEncoder().encode(next).byteLength
+        }
+      });
+    }
+  };
+}
+function createBashTool(context) {
+  return {
+    name: "bash",
+    description: "Runs a bash command within the workspace.",
+    parameters: BashArgsSchema,
+    promptSnippet: "Execute a bash command (30s timeout, 64KB output limit).",
+    promptGuidelines: [
+      "Use bash for build commands, tests, git operations, and system tools.",
+      "Prefer dedicated tools (read/write/edit) for file operations.",
+      "Set timeoutMs for long-running commands."
+    ],
+    async execute(args, toolContext, signal) {
+      const parsed = BashArgsValidator.Parse(args);
+      const timeoutMs = parsed.timeoutMs ?? context.bashTimeoutMs;
+      const maxOutputBytes = parsed.maxOutputBytes ?? context.maxBashOutputBytes;
+      const invalidTimeout = positiveNumber(timeoutMs, "timeoutMs");
+      const invalidOutputLimit = positiveNumber(maxOutputBytes, "maxOutputBytes");
+      if (invalidTimeout || invalidOutputLimit) {
+        return toolResult({
+          context: toolContext,
+          toolName: "bash",
+          ok: false,
+          content: null,
+          error: invalidTimeout ?? invalidOutputLimit
+        });
+      }
+      const cwd = resolveCoreToolPath(context, parsed.cwd ?? ".");
+      let timedOut = false;
+      let aborted = false;
+      const proc = Bun.spawn(["bash", "-lc", parsed.command], {
+        cwd: cwd.absolutePath,
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const kill = () => {
+        proc.kill();
+      };
+      const timeout = setTimeout(() => {
+        timedOut = true;
+        kill();
+      }, timeoutMs);
+      const onAbort = () => {
+        aborted = true;
+        kill();
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+      try {
+        const [stdout, stderr, exitCode] = await Promise.all([
+          captureStream(proc.stdout, maxOutputBytes),
+          captureStream(proc.stderr, maxOutputBytes),
+          proc.exited
+        ]);
+        const ok = exitCode === 0 && !timedOut && !aborted;
+        return toolResult({
+          context: toolContext,
+          toolName: "bash",
+          ok,
+          content: {
+            command: parsed.command,
+            cwd: cwd.relativePath,
+            exitCode,
+            stdout: stdout.text,
+            stderr: stderr.text,
+            stdoutTruncated: stdout.truncated,
+            stderrTruncated: stderr.truncated
+          },
+          ...ok ? {} : {
+            error: timedOut ? `Command timed out after ${timeoutMs}ms.` : aborted ? "Command aborted." : `Command exited with ${exitCode}.`
+          }
+        });
+      } finally {
+        clearTimeout(timeout);
+        signal?.removeEventListener("abort", onAbort);
+      }
+    }
+  };
+}
+function createCoreTools(input = {}) {
+  const context = createCoreToolContext(input);
+  return [
+    createReadTool(context),
+    createWriteTool(context),
+    createEditTool(context),
+    createBashTool(context)
+  ];
+}
+
+// src/loop/errors.ts
+var LoopGuard = {
+  /** Returns abort result if signal is aborted */
+  checkAbort(signal) {
+    if (signal?.aborted) {
+      return { stopReason: "aborted", message: "Agent run aborted." };
+    }
+    return { stopReason: "none" };
+  }
+};
+
+// src/loop/outcomes.ts
+var createOutcome = {
+  fromResult(result) {
+    if (result.stopReason === "none") {
+      return { id: createId("out"), message: "Completed." };
+    }
+    if (result.stopReason === "aborted") {
+      return createOutcome.aborted();
+    }
+    return createOutcome.error(result.message);
+  },
+  phase() {
+    return { id: "default", message: "Phase completed." };
+  },
+  default(output) {
+    return { id: createId("out"), message: output.message || "Completed." };
+  },
+  aborted() {
+    return { id: createId("out"), message: "Agent run aborted." };
+  },
+  error(message) {
+    return { id: createId("out"), message };
+  }
+};
+
+// src/loop/state.ts
+function snapshotMessage(message) {
+  return {
+    ...message,
+    ...message.metadata ? { metadata: { ...message.metadata } } : {}
+  };
+}
+function snapshotMessages(messages) {
+  return messages.map(snapshotMessage);
+}
+
+// src/loop/compaction.ts
+function needsCompaction(messages, options = {}) {
+  const maxMessages = options.maxMessages ?? 50;
+  return messages.length > maxMessages;
+}
+function buildSummary(messages) {
+  const parts = [];
+  let currentRole;
+  let currentContent = [];
+  function flush() {
+    if (currentRole && currentContent.length > 0) {
+      const combined = currentContent.join("\n");
+      const truncated = combined.length > 500 ? combined.slice(0, 500) + "..." : combined;
+      parts.push(`[${currentRole}]: ${truncated}`);
+    }
+    currentContent = [];
+  }
+  for (const msg of messages) {
+    if (msg.role !== currentRole) {
+      flush();
+      currentRole = msg.role;
+    }
+    currentContent.push(msg.content);
+  }
+  flush();
+  return parts.join("\n\n");
+}
+function compactMessages(messages, options = {}) {
+  if (!needsCompaction(messages, options)) {
+    return { compacted: false, messages };
+  }
+  const keepRecent = options.keepRecent ?? 10;
+  const minCompact = options.minCompact ?? 20;
+  const firstUserIdx = messages.findIndex(
+    (m) => m.role === "user"
+  );
+  const recentStart = Math.max(messages.length - keepRecent, firstUserIdx + 1);
+  const oldMessages = messages.slice(firstUserIdx >= 0 ? firstUserIdx + 1 : 0, recentStart);
+  if (oldMessages.length < minCompact) {
+    return { compacted: false, messages };
+  }
+  const recentMessages = messages.slice(recentStart);
+  const summary = buildSummary(oldMessages);
+  const result = [];
+  if (firstUserIdx >= 0) {
+    result.push(messages[firstUserIdx]);
+  }
+  result.push(
+    createMessage("assistant", `[Context compaction summary]
+
+${summary}`, {
+      type: "compaction_summary",
+      compactedCount: oldMessages.length
+    })
+  );
+  result.push(...recentMessages);
+  return {
+    compacted: true,
+    messages: result,
+    summarizedCount: oldMessages.length,
+    summary
+  };
+}
+
+// src/agent-loop.ts
+function resolvePhaseOutput(result, state) {
+  if (result) return result;
+  return {
+    message: state.transcript.filter((m) => m.role === "assistant").pop()?.content ?? "",
+    route: "stop"
+  };
+}
+function createLoopLifecycle(input) {
+  const context = contextFromLoopInput(input);
+  if (!context) {
+    throw new Error("Agent loop runs require either context or state.");
+  }
+  const agentState = input.state ? syncStateFromContext(input.state, context) : createStateFromContext(context, { id: input.sessionId });
+  const config = {
+    model: input.model,
+    stream: input.stream,
+    tools: input.tools ?? context.tools ?? [],
+    maxAttempts: input.maxAttempts ?? 2,
+    limits: input.limits,
+    signal: input.signal,
+    runtime: input.runtime,
+    beforeToolCall: input.beforeToolCall,
+    afterToolCall: input.afterToolCall,
+    beforePhase: input.beforePhase,
+    afterPhase: input.afterPhase,
+    emit: input.emit,
+    phaseConfig: input.phaseConfig
+  };
+  const state = {
+    agentState,
+    currentPhase: "",
+    attempt: 0,
+    transcript: snapshotMessages(agentState.messages),
+    metrics: {
+      iterations: 0,
+      phaseTransitions: [],
+      compactionCount: 0,
+      retryCount: 0,
+      startedAt: createTimestamp(),
+      startedAtMs: Date.now()
+    }
+  };
+  return { config, state };
+}
+function emit(state, emitFn, event) {
+  state.agentState.updatedAt = event.ts;
+  emitFn?.(event);
+}
+function emitTurn(state, emitFn, type, extra) {
+  emit(state, emitFn, {
+    type,
+    content: snapshotMessages(state.transcript),
+    ...extra,
+    ts: createTimestamp()
+  });
+}
+function appendMessage(state, message, toState = false) {
+  if (toState) {
+    state.agentState.messages.push(message);
+  }
+  state.transcript.push(message);
+}
+function createRunResult(state, outcome) {
+  return {
+    sessionId: state.agentState.id,
+    messages: snapshotMessages(state.agentState.messages),
+    outcome,
+    metrics: state.metrics
+  };
+}
+function completeRun(state, outcome) {
+  state.metrics.endedAt = createTimestamp();
+  state.metrics.durationMs = Date.now() - state.metrics.startedAtMs;
+  return createRunResult(state, outcome);
+}
+function createAgentLoopContext(config, state, availablePhases) {
+  const routeTool = createRouteTool(availablePhases);
+  const threadTool = createThreadTool(config.tools, state.agentState.skills, async (input) => {
+    const result = await runAgentLoop({
+      context: {
+        systemPrompt: state.agentState.systemPrompt,
+        messages: [createMessage("user", input.prompt)],
+        tools: input.tools?.slice() ?? config.tools.slice(),
+        skills: input.skills?.slice() ?? state.agentState.skills.slice()
+      },
+      model: config.model,
+      stream: config.stream,
+      maxAttempts: config.maxAttempts,
+      limits: input.limits ?? config.limits,
+      signal: config.signal,
+      runtime: config.runtime,
+      beforeToolCall: config.beforeToolCall,
+      afterToolCall: config.afterToolCall,
+      beforePhase: config.beforePhase,
+      afterPhase: config.afterPhase,
+      beforePrompt: config.beforePrompt,
+      emit: config.emit,
+      phaseConfig: config.phaseConfig
+    });
+    return result;
+  });
+  return {
+    systemPrompt: state.agentState.systemPrompt,
+    messages: snapshotMessages(state.agentState.messages),
+    tools: [...config.tools, routeTool, threadTool],
+    skills: state.agentState.skills.slice(),
+    config,
+    state,
+    ...config.signal ? { signal: config.signal } : {},
+    emit: (event) => emit(state, config.emit, event),
+    appendMessage: (message) => appendMessage(state, message),
+    appendStateMessage: (message) => appendMessage(state, message, true)
+  };
+}
+function cloneContext(context) {
+  return {
+    systemPrompt: context.systemPrompt,
+    messages: snapshotMessages(context.messages),
+    ...context.tools ? { tools: context.tools.slice() } : {},
+    ...context.skills ? { skills: context.skills.slice() } : {}
+  };
+}
+function contextFromState(state, tools) {
+  return {
+    systemPrompt: state.systemPrompt,
+    messages: snapshotMessages(state.messages),
+    tools: tools?.slice() ?? [],
+    skills: state.skills.slice()
+  };
+}
+function contextFromLoopInput(input) {
+  if (input.context) return cloneContext(input.context);
+  if (input.state) return contextFromState(input.state, input.tools);
+  return void 0;
+}
+function createStateFromContext(context, meta = {}) {
+  const firstUser = context.messages.find((m) => m.role === "user");
+  if (!firstUser) throw new Error("Agent context must include at least one user message.");
+  const state = createAgentState({
+    ...meta.id ? { id: meta.id } : {},
+    systemPrompt: context.systemPrompt,
+    input: meta.input ?? firstUser.content,
+    skills: context.skills ?? [],
+    ...meta.parentSessionId ? { parentSessionId: meta.parentSessionId } : {}
+  });
+  if (context.messages.length > 0) {
+    state.messages = snapshotMessages(context.messages);
+  }
+  state.skills = context.skills?.slice() ?? [];
+  state.updatedAt = createTimestamp();
+  return state;
+}
+function syncStateFromContext(state, context) {
+  state.systemPrompt = context.systemPrompt;
+  if (context.messages.length > 0) {
+    state.messages = snapshotMessages(context.messages);
+  }
+  state.skills = context.skills?.slice() ?? state.skills;
+  state.updatedAt = createTimestamp();
+  return state;
+}
+async function runAgentLoop(input) {
+  const { config: initialConfig, state } = createLoopLifecycle(input);
+  const config = { ...initialConfig };
+  const emitFn = config.emit;
+  emit(state, emitFn, { type: "agent_start", sessionId: state.agentState.id, ts: createTimestamp() });
+  try {
+    const abortResult = LoopGuard.checkAbort(config.signal);
+    if (abortResult.stopReason !== "none") {
+      return completeRun(state, createOutcome.aborted());
+    }
+    const result = await runLoop(config, state);
+    return result;
+  } finally {
+    emit(state, emitFn, {
+      type: "agent_end",
+      sessionId: state.agentState.id,
+      messages: snapshotMessages(state.agentState.messages),
+      ts: createTimestamp()
+    });
+  }
+}
+async function runLoop(config, state) {
+  const phaseConfig = config.phaseConfig ?? await createBuiltinPhaseRegistry();
+  if (config.phaseConfig) ensurePhaseRegistry(phaseConfig);
+  config.phaseConfig = phaseConfig;
+  const availablePhases = phaseConfig.phases.map((p) => ({ id: p.id, name: p.name, description: p.description }));
+  let currentPhaseId = phaseConfig.entryPhaseId;
+  const maxIterations = config.limits?.maxIterations ?? 50;
+  const maxPhaseRounds = config.limits?.maxPhaseRounds ?? 10;
+  let phaseRounds = 0;
+  let isContinuing = false;
+  while (currentPhaseId) {
+    const abortResult = LoopGuard.checkAbort(config.signal);
+    if (abortResult.stopReason !== "none") {
+      return completeRun(state, createOutcome.aborted());
+    }
+    state.metrics.iterations++;
+    if (state.metrics.iterations > maxIterations) {
+      return completeRun(state, {
+        id: "max_iterations",
+        message: `Loop exceeded maximum iterations (${maxIterations}). Stopping to prevent infinite loop.`
+      });
+    }
+    if (needsCompaction(state.transcript)) {
+      const compacted = compactMessages(state.transcript);
+      if (compacted.compacted) {
+        state.transcript = compacted.messages;
+        state.agentState.messages = compacted.messages;
+        state.metrics.compactionCount++;
+        emit(state, config.emit, {
+          type: "message_start",
+          message: {
+            id: "compaction",
+            role: "assistant",
+            content: `[Compacted ${compacted.summarizedCount} older messages to stay within context limits]`,
+            createdAt: createTimestamp(),
+            metadata: { type: "compaction_notice" }
+          },
+          ts: createTimestamp()
+        });
+      }
+    }
+    const phase = resolvePhaseEntry(phaseConfig, currentPhaseId);
+    state.currentPhase = currentPhaseId;
+    const loopContext = createAgentLoopContext(config, state, availablePhases);
+    const context = createPhaseContext(config, state, phase, loopContext, availablePhases);
+    const phaseTools = phase.tools ? loopContext.tools.filter((t) => phase.tools.includes(t.name)) : loopContext.tools;
+    const phaseSkills = phase.skills ? state.agentState.skills.filter((s) => phase.skills.includes(s.name)) : state.agentState.skills;
+    let phaseInput = {
+      phase: currentPhaseId,
+      systemPrompt: loopContext.systemPrompt,
+      messages: context.messages.visible(),
+      tools: loopContext.tools,
+      // All tools (for systemPrompt, cache-friendly)
+      skills: loopContext.skills,
+      // All skills (for systemPrompt)
+      phaseTools,
+      // Phase-filtered tools (for LlmRequest.tools)
+      phaseSkills
+      // Phase-filtered skills
+    };
+    if (!isContinuing) {
+      emit(state, config.emit, { type: "phase_start", phase: currentPhaseId, ts: createTimestamp() });
+    }
+    isContinuing = false;
+    if (config.beforePhase) {
+      const extBefore = await config.beforePhase(currentPhaseId, phaseInput);
+      if (extBefore.abort) {
+        emit(state, config.emit, { type: "phase_end", phase: currentPhaseId, ts: createTimestamp() });
+        return completeRun(state, extBefore.abort);
+      }
+      if (extBefore.skip) {
+        emit(state, config.emit, { type: "phase_end", phase: currentPhaseId, ts: createTimestamp() });
+        if (extBefore.skip.route === "stop") {
+          return completeRun(state, {
+            id: "skip",
+            message: extBefore.skip.message || "Skipped."
+          });
+        }
+        currentPhaseId = extBefore.skip.route;
+        continue;
+      }
+      if (extBefore.input) {
+        phaseInput = extBefore.input;
+      }
+    }
+    let output;
+    if (phase.run) {
+      output = resolvePhaseOutput(await phase.run(context, phaseInput), state);
+    } else {
+      const collected = await context.turn(() => context.model.invoke({ input: phaseInput }));
+      output = {
+        message: collected.text,
+        route: "stop",
+        toolCalls: collected.toolCalls
+      };
+    }
+    if (phaseInput.toolChoice && typeof phaseInput.toolChoice === "object" && phaseInput.toolChoice.type === "tool") {
+      const requiredTool = phaseInput.toolChoice.name;
+      const hasRequiredTool = output.toolCalls?.some((tc) => tc.name === requiredTool);
+      if (!hasRequiredTool) {
+        state.metrics.retryCount++;
+      }
+    }
+    if (output.toolCalls && output.toolCalls.length > 0) {
+      const routeDecision = context.routeDecision(output.toolCalls);
+      if (routeDecision) {
+        output.route = routeDecision.route;
+        if (routeDecision.reason) {
+          output.routeReason = routeDecision.reason;
+        }
+      }
+    }
+    if (config.afterPhase) {
+      const extAfter = await config.afterPhase(currentPhaseId, output);
+      if (extAfter.abort) {
+        emit(state, config.emit, { type: "phase_end", phase: currentPhaseId, ts: createTimestamp() });
+        return completeRun(state, extAfter.abort);
+      }
+      if (extAfter.retry && phase.run) {
+        output = resolvePhaseOutput(await phase.run(context, extAfter.retry), state);
+        if (output.toolCalls && output.toolCalls.length > 0) {
+          const routeDecision = context.routeDecision(output.toolCalls);
+          if (routeDecision) {
+            output.route = routeDecision.route;
+            if (routeDecision.reason) {
+              output.routeReason = routeDecision.reason;
+            }
+          }
+        }
+      }
+      if (extAfter.output) {
+        output = extAfter.output;
+      }
+    }
+    if (output.route === "continue") {
+      phaseRounds++;
+      if (phaseRounds > maxPhaseRounds) {
+        emit(state, config.emit, { type: "phase_end", phase: currentPhaseId, ts: createTimestamp() });
+        phaseRounds = 0;
+        currentPhaseId = "chat";
+        continue;
+      }
+      isContinuing = true;
+      state.metrics.iterations++;
+      continue;
+    }
+    phaseRounds = 0;
+    emit(state, config.emit, { type: "phase_end", phase: currentPhaseId, ts: createTimestamp() });
+    if (output.route === "stop") {
+      const outcome = createOutcome.default(output);
+      return completeRun(state, outcome);
+    }
+    if (!phaseConfig.phases.some((p) => p.id === output.route)) {
+      return completeRun(state, createOutcome.phase());
+    }
+    state.metrics.phaseTransitions.push({
+      from: currentPhaseId,
+      to: output.route,
+      ts: createTimestamp()
+    });
+    currentPhaseId = output.route;
+  }
+  throw new Error("Phase machine exited without a stop or abort transition.");
+}
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_BASE_DELAY_MS = 1e3;
+var DEFAULT_MAX_DELAY_MS = 3e4;
+function isRetryableError(error) {
+  if (!(error instanceof Error)) return false;
+  const message = error.message.toLowerCase();
+  if (message.includes("rate limit") || message.includes("429")) return true;
+  if (message.includes("overloaded") || message.includes("529")) return true;
+  if (message.includes("server error") || message.includes("500")) return true;
+  if (message.includes("bad gateway") || message.includes("502")) return true;
+  if (message.includes("service unavailable") || message.includes("503")) return true;
+  if (message.includes("gateway timeout") || message.includes("504")) return true;
+  if (message.includes("econnreset") || message.includes("econnrefused")) return true;
+  return false;
+}
+function getRetryDelay(attempt, baseMs, maxMs) {
+  const exponential = baseMs * Math.pow(2, attempt);
+  const jitter = exponential * (0.5 + Math.random() * 0.5);
+  return Math.min(jitter, maxMs);
+}
+async function withRetry(fn, options = {}) {
+  const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+  const baseDelayMs = options.baseDelayMs ?? DEFAULT_BASE_DELAY_MS;
+  const maxDelayMs = options.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt >= maxRetries || !isRetryableError(error)) {
+        throw error;
+      }
+      if (options.signal?.aborted) {
+        throw error;
+      }
+      const delayMs = getRetryDelay(attempt, baseDelayMs, maxDelayMs);
+      options.onRetry?.(attempt, error, delayMs);
+      await new Promise((resolve7) => setTimeout(resolve7, delayMs));
+      if (options.signal?.aborted) {
+        throw lastError;
+      }
+    }
+  }
+  throw lastError;
+}
+async function collectStructured(input) {
+  let activeMessageId;
+  let lastPartial;
+  let stopReason;
+  for await (const event of input.events) {
+    const abortResult = LoopGuard.checkAbort(input.context.signal);
+    if (abortResult.stopReason !== "none") {
+      return { text: abortResult.message, contentBlocks: [], toolCalls: [], stopReason: "aborted" };
+    }
+    if (event.type === "model_requested") {
+      input.context.emit({
+        type: "model_requested",
+        model: event.model,
+        usage: event.usage,
+        ts: createTimestamp()
+      });
+    }
+    if (event.type === "error") {
+      throw event.error;
+    }
+    if (event.type === "start") {
+      lastPartial = event.partial;
+      if (!activeMessageId) {
+        activeMessageId = input.message.start("assistant", "", {
+          phase: input.metadataPhase
+        });
+      }
+    }
+    if (event.type === "text_delta") {
+      lastPartial = event.partial;
+      if (!activeMessageId) {
+        activeMessageId = input.message.start("assistant", event.text, {
+          phase: input.metadataPhase
+        });
+      } else {
+        await input.message.update(activeMessageId, event.text);
+      }
+    }
+    if (event.type === "tool_call_start" || event.type === "tool_call_delta" || event.type === "tool_call_end") {
+      lastPartial = event.partial;
+    }
+    if (event.type === "thinking_delta") {
+      lastPartial = event.partial;
+    }
+    if (event.type === "done") {
+      stopReason = event.response?.stopReason;
+      const toolCallBlocks = lastPartial?.contentBlocks?.filter((b) => b.type === "tool_call") ?? [];
+      if (!activeMessageId && toolCallBlocks.length > 0) {
+        activeMessageId = input.message.start("assistant", "", {
+          phase: input.metadataPhase,
+          toolCalls: toolCallBlocks.map((tc) => ({ id: tc.id, name: tc.name, args: tc.args }))
+        });
+      }
+      if (activeMessageId) {
+        await input.message.end(activeMessageId);
+        activeMessageId = void 0;
+      }
+    }
+  }
+  if (activeMessageId) {
+    await input.message.end(activeMessageId);
+  }
+  const contentBlocks = lastPartial?.contentBlocks ?? [];
+  const text = contentBlocks.filter((b) => b.type === "text").map((b) => b.text).join("");
+  const toolCalls = contentBlocks.filter((b) => b.type === "tool_call").map((b) => {
+    let parsedArgs = b.args;
+    try {
+      parsedArgs = JSON.parse(b.args);
+    } catch {
+    }
+    return { id: b.id, name: b.name, args: parsedArgs };
+  });
+  return { text, contentBlocks, toolCalls, stopReason };
+}
+async function executeToolCall(input) {
+  if (input.context.config.runtime?.tools) {
+    return input.context.config.runtime.tools({
+      context: input.context,
+      toolCall: input.toolCall
+    });
+  }
+  const toolContext = {
+    state: input.context.state.agentState,
+    toolCallId: input.toolCall.id
+  };
+  return executeRuntimeToolCall({
+    tools: input.context.tools,
+    toolCall: input.toolCall,
+    toolContext,
+    beforeToolCall: input.context.config.beforeToolCall,
+    afterToolCall: input.context.config.afterToolCall,
+    signal: input.context.signal
+  });
+}
+function createPhaseContext(config, state, phase, loopContext, availablePhases) {
+  const activeMessages = /* @__PURE__ */ new Map();
+  let turnDepth = 0;
+  let autoTurnCount = 0;
+  function beginAutoTurn() {
+    if (turnDepth === 0) {
+      autoTurnCount++;
+      if (autoTurnCount === 1) {
+        emitTurn(state, config.emit, "turn_start");
+      }
+    }
+  }
+  function endAutoTurn() {
+    if (turnDepth === 0 && autoTurnCount > 0) {
+      autoTurnCount--;
+      if (autoTurnCount === 0) {
+        emitTurn(state, config.emit, "turn_end");
+      }
+    }
+  }
+  const messageManager = {
+    visible: () => [...state.transcript],
+    start(role, content, metadata) {
+      const msg = createMessage(role, content, metadata);
+      activeMessages.set(msg.id, msg);
+      beginAutoTurn();
+      emit(state, config.emit, { type: "message_start", message: snapshotMessage(msg), ts: createTimestamp() });
+      return msg.id;
+    },
+    async update(messageId, delta) {
+      const msg = activeMessages.get(messageId);
+      if (!msg) return;
+      msg.content += delta;
+      emit(state, config.emit, {
+        type: "message_update",
+        message: snapshotMessage(msg),
+        delta,
+        ts: createTimestamp()
+      });
+    },
+    async end(messageId) {
+      const msg = activeMessages.get(messageId);
+      if (!msg) return;
+      activeMessages.delete(messageId);
+      state.transcript.push(msg);
+      state.agentState.messages.push(msg);
+      emit(state, config.emit, { type: "message_end", message: snapshotMessage(msg), ts: createTimestamp() });
+      endAutoTurn();
+    },
+    snapshot() {
+      return {
+        transcriptLength: state.transcript.length,
+        stateMessagesLength: state.agentState.messages.length
+      };
+    },
+    restore(snap) {
+      state.transcript.length = snap.transcriptLength;
+      state.agentState.messages.length = snap.stateMessagesLength;
+      activeMessages.clear();
+    },
+    delete(target) {
+      const transcriptIdx = typeof target === "number" ? target : state.transcript.findIndex((m) => m.id === target);
+      if (transcriptIdx >= 0 && transcriptIdx < state.transcript.length) {
+        const msg = state.transcript[transcriptIdx];
+        state.transcript.splice(transcriptIdx, 1);
+        const stateIdx = state.agentState.messages.findIndex((m) => m.id === msg.id);
+        if (stateIdx !== -1) {
+          state.agentState.messages.splice(stateIdx, 1);
+        }
+        activeMessages.delete(msg.id);
+      }
+    },
+    insert(target, message) {
+      const idx = typeof target === "number" ? target : state.transcript.findIndex((m) => m.id === target);
+      const insertIdx = idx >= 0 ? idx : state.transcript.length;
+      state.transcript.splice(insertIdx, 0, message);
+      state.agentState.messages.push(message);
+    },
+    clear() {
+      state.transcript.length = 0;
+      state.agentState.messages.length = 0;
+      activeMessages.clear();
+    }
+  };
+  const toolExecutionManager = {
+    async start(toolCallId, toolName, args) {
+      beginAutoTurn();
+      emit(state, config.emit, {
+        type: "tool_execution_start",
+        toolCallId,
+        toolName,
+        args,
+        ts: createTimestamp()
+      });
+    },
+    async update(_toolCallId, _partialResult) {
+    },
+    async end(toolCallId, toolName, result, isError) {
+      emit(state, config.emit, {
+        type: "tool_execution_end",
+        toolCallId,
+        toolName,
+        result,
+        isError,
+        ts: createTimestamp()
+      });
+      endAutoTurn();
+    }
+  };
+  return {
+    phaseId: phase.id,
+    state: loopContext.state,
+    messages: messageManager,
+    toolExecution: toolExecutionManager,
+    model: {
+      invoke: async (input) => {
+        const { autoExecuteTools, maxToolRounds = 10, excludeTools = [] } = input;
+        const invokeOnce = async (phaseInput) => {
+          if (loopContext.config.beforePrompt) {
+            phaseInput = await loopContext.config.beforePrompt(phase.id, phaseInput);
+          }
+          const request = phase.buildPrompt(phaseInput);
+          request.model = loopContext.config.model;
+          if (!request.tools) {
+            const modelTools = phaseInput.phaseTools ?? phaseInput.tools;
+            if (modelTools.length > 0) {
+              request.tools = modelTools.map((t) => ({
+                name: t.name,
+                description: t.description,
+                parameters: t.parameters
+              }));
+            }
+          }
+          if (phaseInput.toolChoice && !request.toolChoice) {
+            request.toolChoice = phaseInput.toolChoice;
+          }
+          return withRetry(
+            () => collectStructured({
+              context: loopContext,
+              message: messageManager,
+              events: loopContext.config.stream(request, { signal: loopContext.signal }),
+              metadataPhase: phase.id
+            }),
+            {
+              signal: loopContext.signal,
+              onRetry: (attempt, error, delayMs) => {
+                state.metrics.retryCount++;
+                const errMsg = error instanceof Error ? error.message : String(error);
+                loopContext.emit({
+                  type: "message_start",
+                  message: {
+                    id: `retry_${attempt}`,
+                    role: "assistant",
+                    content: `[Retry ${attempt + 1}/${DEFAULT_MAX_RETRIES}] Transient error: ${errMsg}. Retrying in ${Math.round(delayMs)}ms...`,
+                    createdAt: createTimestamp(),
+                    metadata: { type: "retry_notice" }
+                  },
+                  ts: createTimestamp()
+                });
+              }
+            }
+          );
+        };
+        if (!autoExecuteTools) {
+          return invokeOnce(input.input);
+        }
+        let currentInput = input.input;
+        let lastResult;
+        for (let round = 0; round < maxToolRounds; round++) {
+          lastResult = await invokeOnce(currentInput);
+          const executableToolCalls = lastResult.toolCalls.filter(
+            (tc) => !excludeTools.includes(tc.name)
+          );
+          if (executableToolCalls.length === 0) {
+            break;
+          }
+          for (const toolCall of executableToolCalls) {
+            await toolExecutionManager.start(toolCall.id, toolCall.name, toolCall.args);
+            const result = await executeToolCall({ context: loopContext, toolCall });
+            await toolExecutionManager.end(result.toolCallId, result.toolName, result, !result.ok);
+            const toolResultContent = JSON.stringify({
+              toolName: result.toolName,
+              ok: result.ok,
+              content: result.content,
+              ...result.error ? { error: result.error } : {}
+            });
+            const toolMsgId = messageManager.start("tool", toolResultContent, {
+              toolCallId: result.toolCallId,
+              toolName: result.toolName,
+              isError: !result.ok
+            });
+            await messageManager.end(toolMsgId);
+          }
+          currentInput = {
+            ...currentInput,
+            messages: messageManager.visible()
+          };
+        }
+        return lastResult;
+      }
+    },
+    tools: {
+      execute: async (input) => {
+        return executeToolCall({
+          context: loopContext,
+          toolCall: input.toolCall
+        });
+      }
+    },
+    skills: state.agentState.skills.slice(),
+    turn: async (fn) => {
+      turnDepth++;
+      emitTurn(state, config.emit, "turn_start");
+      try {
+        return await fn();
+      } finally {
+        turnDepth--;
+        emitTurn(state, config.emit, "turn_end");
+      }
+    },
+    maxAttempts: config.maxAttempts,
+    incrementAttempt() {
+      state.attempt += 1;
+      loopContext.state.attempt = state.attempt;
+    },
+    availablePhases,
+    routeDecision(toolCalls) {
+      return extractRouteCall(toolCalls);
+    }
+  };
+}
+
+// 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
+    };
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  emitToListeners(event) {
+    for (const listener of this.listeners) {
+      try {
+        const result = listener(event);
+        if (result && typeof result === "object" && "then" in result) {
+          const task = Promise.resolve(result).catch((error) => {
+            this.listenerErrors.push(error);
+          }).finally(() => {
+            this.pendingListenerTasks.delete(task);
+          });
+          this.pendingListenerTasks.add(task);
+        }
+      } catch (error) {
+        this.listenerErrors.push(error);
+      }
+    }
+  }
+  async flushEvents() {
+    while (this.pendingListenerTasks.size > 0) {
+      await Promise.all([...this.pendingListenerTasks]);
+    }
+    for (const listener of this.listeners) {
+      try {
+        await listener.flush?.();
+      } catch (error) {
+        this.listenerErrors.push(error);
+      }
+    }
+    if (this.listenerErrors.length > 0) {
+      const [error] = this.listenerErrors;
+      throw error instanceof Error ? error : new Error(String(error));
+    }
+  }
+  processEvents(event) {
+    switch (event.type) {
+      case "message_start":
+        this.state.currentResult = void 0;
+        break;
+      case "message_end":
+        break;
+      case "agent_end":
+        break;
+    }
+    this.emitToListeners(event);
+    this.options.extensionRunnerRef?.current?.emitAgentEvent(event);
+  }
+  /**
+   * Hook for before_tool_call — called before a tool executes.
+   * Extensions can block execution by setting allow=false.
+   */
+  async handleBeforeToolCall(tool, args) {
+    const runner = this.options.extensionRunnerRef?.current;
+    if (!runner) return { allow: true };
+    return runner.emitBeforeToolCall(tool, args);
+  }
+  /**
+   * Hook for after_tool_call — called after a tool executes.
+   * Extensions can mutate the result.
+   */
+  async handleAfterToolCall(tool, result) {
+    const runner = this.options.extensionRunnerRef?.current;
+    if (!runner) return result;
+    return runner.emitAfterToolCall(tool, result);
+  }
+  /**
+   * Hook for before_phase — called before a phase executes.
+   * Extensions can abort, skip, or replace the phase input.
+   */
+  async handleBeforePhase(phaseId, input) {
+    const runner = this.options.extensionRunnerRef?.current;
+    if (!runner) return {};
+    return runner.emitBeforePhase(phaseId, input);
+  }
+  /**
+   * Hook for after_phase — called after a phase executes.
+   * Extensions can abort, retry, or replace the output.
+   */
+  async handleAfterPhase(phaseId, output) {
+    const runner = this.options.extensionRunnerRef?.current;
+    if (!runner) return {};
+    return runner.emitAfterPhase(phaseId, output);
+  }
+  /**
+   * Hook for before_prompt — called before buildPrompt, allowing extensions to transform PhaseInput.
+   * Extensions can transform the PhaseInput (messages, tools, systemPrompt, etc.).
+   */
+  async handleBeforePrompt(phaseId, input) {
+    const runner = this.options.extensionRunnerRef?.current;
+    if (!runner) return input;
+    return runner.emitBeforePrompt(phaseId, input);
+  }
+  handleRunFailure(error, aborted) {
+    const message = error instanceof Error ? error.message : "Agent run failed.";
+    this.state.error = message;
+  }
+  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 run(config) {
+    const resolved = this.resolveRunConfig(config);
+    const previousSessionId = this.state.sessionId ?? this.options.sessionId;
+    const sessionId = resolved.sessionId ?? this.state.sessionId;
+    const hadExistingSession = Boolean(sessionId && previousSessionId === sessionId);
+    this.options = resolved;
+    if (sessionId) {
+      this.state.sessionId = sessionId;
+    }
+    this.state.context = cloneAgentContext(resolved.context);
+    this.state.model = resolved.model;
+    this.state.tools = resolved.context.tools ?? [];
+    this.state.currentResult = void 0;
+    this.state.error = void 0;
+    return this.runWithLifecycle(async (signal) => {
+      const emit2 = (event) => {
+        this.processEvents(event);
+      };
+      const phaseConfig = resolved.phaseConfig ?? await createDefaultPhaseRegistry({
+        cwd: resolved.cwd ?? process.cwd()
+      });
+      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: resolved.context,
+        ...sessionId ? { sessionId } : {},
+        model: resolved.model,
+        stream: resolved.stream,
+        maxAttempts: resolved.maxAttempts,
+        limits: resolved.limits,
+        signal,
+        beforeToolCall,
+        afterToolCall,
+        beforePhase: (phaseId, input) => this.handleBeforePhase(phaseId, input),
+        afterPhase: (phaseId, output) => this.handleAfterPhase(phaseId, output),
+        beforePrompt: (phaseId, input) => this.handleBeforePrompt(phaseId, input),
+        phaseConfig,
+        emit: emit2
+      });
+      this.state.sessionId = result.sessionId;
+      this.state.context = {
+        ...cloneAgentContext(resolved.context),
+        messages: snapshotMessages(result.messages)
+      };
+      this.state.currentResult = result;
+      this.options = {
+        ...resolved,
+        sessionId: result.sessionId,
+        context: cloneAgentContext(this.state.context)
+      };
+      return result;
+    });
+  }
+  abort(reason = "Aborted by caller.") {
+    this.activeRun?.abortController.abort(reason);
+  }
+  async waitForIdle() {
+    if (!this.activeRun) {
+      return;
+    }
+    await this.activeRun.promise.catch(() => void 0);
+    await this.flushEvents().catch(() => void 0);
+  }
+  resolveRunConfig(config) {
+    const context = cloneAgentContext(config?.context ?? this.createContextSnapshot());
+    return {
+      ...this.options,
+      ...config,
+      context,
+      sessionId: config?.sessionId ?? this.state.sessionId ?? this.options.sessionId
+    };
+  }
+  createContextSnapshot() {
+    return cloneAgentContext(this.state.context);
+  }
+};
+function cloneAgentContext(context) {
+  return {
+    systemPrompt: context.systemPrompt,
+    messages: snapshotMessages(context.messages),
+    ...context.tools ? { tools: context.tools.slice() } : {},
+    ...context.skills ? { skills: context.skills.slice() } : {}
+  };
+}
+
+// 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));
+    }
+    const waiter = this.waiting.shift();
+    if (waiter) {
+      waiter({ value: event, done: false });
+    } else {
+      this.queue.push(event);
+    }
+  }
+  end(result) {
+    this.done = true;
+    if (result !== void 0) {
+      this.resolveFinalResult(result);
+    }
+    while (this.waiting.length > 0) {
+      const waiter = this.waiting.shift();
+      waiter({ value: void 0, done: true });
+    }
+  }
+  async *[Symbol.asyncIterator]() {
+    while (true) {
+      if (this.queue.length > 0) {
+        yield this.queue.shift();
+      } else if (this.done) {
+        return;
+      } else {
+        const result = await new Promise((resolve7) => this.waiting.push(resolve7));
+        if (result.done) return;
+        yield result.value;
+      }
+    }
+  }
+  result() {
+    return this.finalResultPromise;
+  }
+};
+var AgentEventStream = class extends EventStream {
+  constructor() {
+    super(
+      (event) => event.type === "agent_end",
+      (event) => event.type === "agent_end" ? event.messages : []
+    );
+  }
+};
+
+// src/harness/session/session.ts
+import Type4 from "typebox";
+var SESSION_SCHEMA_VERSION = "0.4.4";
+var AgentMessageSchema = Type4.Object({
+  id: Type4.String(),
+  role: Type4.Union([
+    Type4.Literal("system"),
+    Type4.Literal("user"),
+    Type4.Literal("assistant"),
+    Type4.Literal("tool")
+  ]),
+  content: Type4.String(),
+  createdAt: Type4.String(),
+  metadata: Type4.Optional(Type4.Record(Type4.String(), Type4.Unknown()))
+});
+var SkillSchema = Type4.Object({
+  name: Type4.String(),
+  description: Type4.String(),
+  filePath: Type4.String(),
+  baseDir: Type4.String(),
+  disableModelInvocation: Type4.Boolean()
+});
+function createId2(prefix) {
+  return `${prefix}_${crypto.randomUUID().slice(0, 8)}`;
+}
+function padDatePart2(value, length = 2) {
+  return String(value).padStart(length, "0");
+}
+function formatLocalTimestamp2(date = /* @__PURE__ */ new Date()) {
+  const offsetMinutes = -date.getTimezoneOffset();
+  const offsetSign = offsetMinutes >= 0 ? "+" : "-";
+  const offsetAbsolute = Math.abs(offsetMinutes);
+  const offsetHours = Math.floor(offsetAbsolute / 60);
+  const offsetRemainingMinutes = offsetAbsolute % 60;
+  return [
+    `${date.getFullYear()}-${padDatePart2(date.getMonth() + 1)}-${padDatePart2(date.getDate())}`,
+    "T",
+    `${padDatePart2(date.getHours())}${padDatePart2(date.getMinutes())}${padDatePart2(date.getSeconds())}`,
+    "-",
+    padDatePart2(Math.floor(date.getMilliseconds() / 10)),
+    offsetSign,
+    padDatePart2(offsetHours),
+    ":",
+    padDatePart2(offsetRemainingMinutes)
+  ].join("");
+}
+function nowIso() {
+  return formatLocalTimestamp2();
+}
+function createMessage2(role, content, metadata) {
+  return {
+    id: createId2("msg"),
+    role,
+    content,
+    createdAt: nowIso(),
+    ...metadata ? { metadata } : {}
+  };
+}
+function createSession(input) {
+  const createdAt = nowIso();
+  const messages = [
+    createMessage2("user", input.input)
+  ];
+  return {
+    version: SESSION_SCHEMA_VERSION,
+    id: input.id ?? createId2("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 = nowIso();
+  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 = nowIso();
+  return {
+    type: "header",
+    id: input.id ?? createId2("ses"),
+    version: SESSION_MANAGER_SCHEMA_VERSION,
+    createdAt,
+    updatedAt: createdAt,
+    systemPrompt: input.systemPrompt,
+    input: input.input,
+    ...input.parentSessionId ? { parentSessionId: input.parentSessionId } : {},
+    skills: input.skills?.map(clone) ?? [],
+    ...input.title ? { title: input.title } : {},
+    currentLeafId: null
+  };
+}
+function filterExecutionTurns(steps, filter = {}) {
+  return steps.filter((step) => {
+    if (filter.phase && step.phase !== filter.phase) return false;
+    if (filter.afterMs !== void 0 && step.requestedAtMs < filter.afterMs) return false;
+    return true;
+  }).map(clone);
+}
+var InMemorySessionManager = class _InMemorySessionManager {
+  constructor(header, entries = []) {
+    this.header = header;
+    this.entries = entries;
+  }
+  header;
+  entries;
+  static create(input) {
+    return new _InMemorySessionManager(createSessionHeader(input));
+  }
+  static fromRecords(records) {
+    const [header, ...entries] = records;
+    if (!header || header.type !== "header") {
+      throw new Error("Session records must start with a header.");
+    }
+    return new _InMemorySessionManager(clone(header), clone(entries));
+  }
+  getSessionId() {
+    return this.header.id;
+  }
+  getSessionFile() {
+    return void 0;
+  }
+  async getHeader() {
+    return clone(this.header);
+  }
+  async appendMessage(message) {
+    return this.appendEntry({ type: "message", message: clone(message) });
+  }
+  async appendOutcome(outcome) {
+    return this.appendEntry({ type: "outcome", outcome: clone(outcome) });
+  }
+  async appendExecutionTurn(turn) {
+    return this.appendEntry({
+      type: "execution_turn",
+      turn: clone({
+        ...turn,
+        sessionId: this.header.id
+      })
+    });
+  }
+  async appendCompaction(input) {
+    return this.appendEntry({ type: "compaction", ...input });
+  }
+  async appendBranchSummary(input) {
+    return this.appendEntry({ type: "branch_summary", ...input });
+  }
+  async appendSessionInfo(input) {
+    this.header = {
+      ...this.header,
+      title: input.title,
+      updatedAt: nowIso()
+    };
+    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 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: nowIso()
+    };
+  }
+  async buildAgentContext(input = {}) {
+    const entries = this.entriesForLeaf(input.leafId ?? this.header.currentLeafId ?? null);
+    return {
+      systemPrompt: this.header.systemPrompt,
+      messages: entries.filter((entry) => entry.type === "message").map((entry) => entry.message).map(clone),
+      tools: input.tools?.slice() ?? [],
+      skills: input.skills?.map(clone) ?? this.header.skills.map(clone)
+    };
+  }
+  async listEntries() {
+    return this.entries.map(clone);
+  }
+  async loadExecutionTurns(filter) {
+    return filterExecutionTurns(
+      this.entries.filter((entry) => entry.type === "execution_turn").map((entry) => entry.turn),
+      filter
+    );
+  }
+  appendImportedEntry(entry) {
+    this.entries.push(clone(entry));
+    this.header = {
+      ...this.header,
+      currentLeafId: entry.id,
+      updatedAt: entry.timestamp
+    };
+  }
+  appendEntry(input) {
+    const timestamp = nowIso();
+    const entry = {
+      id: createId2("entry"),
+      parentId: this.header.currentLeafId ?? null,
+      timestamp,
+      ...input
+    };
+    this.entries.push(entry);
+    this.header = {
+      ...this.header,
+      currentLeafId: entry.id,
+      updatedAt: timestamp
+    };
+    return entry.id;
+  }
+  entriesForLeaf(leafId) {
+    if (!leafId) {
+      return [];
+    }
+    const byId = new Map(this.entries.map((entry) => [entry.id, entry]));
+    const ordered = [];
+    let currentId = leafId;
+    while (currentId) {
+      const entry = byId.get(currentId);
+      if (!entry) {
+        throw new Error(`Session entry not found: ${currentId}`);
+      }
+      ordered.unshift(entry);
+      currentId = entry.parentId;
+    }
+    return ordered;
+  }
+};
+function summarizeSessionManagerRecords(records) {
+  const [header, ...entries] = records;
+  if (!header || header.type !== "header") {
+    throw new Error("Session records must start with a header.");
+  }
+  const messages = entries.filter((entry) => entry.type === "message").map((entry) => entry.message);
+  const latestMessage = messages.at(-1)?.content;
+  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 readFile3, readdir as readdir2, stat as stat3, unlink, writeFile as writeFile2 } from "fs/promises";
+import { join as join2, relative as relative2, resolve as resolve4, 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 = resolve4(sessionsDir);
+  const path = resolve4(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 readFile3(path, "utf8").catch((error) => {
+    if (error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  });
+  if (!text) {
+    return void 0;
+  }
+  const records = text.split("\n").map((line) => line.trim()).filter(Boolean).map(parseRecord);
+  const header = records[0];
+  if (!header || header.type !== "header") {
+    throw new Error("Session JSONL must start with a header record.");
+  }
+  const lastEntry = records.slice(1).reverse().find((record) => record.type !== "header");
+  return [
+    {
+      ...header,
+      updatedAt: lastEntry?.timestamp ?? header.updatedAt,
+      currentLeafId: lastEntry?.id ?? header.currentLeafId ?? null
+    },
+    ...records.slice(1)
+  ];
+}
+async function appendRecord(path, record) {
+  await appendFile(path, `${JSON.stringify(record)}
+`, "utf8");
+}
+var LocalJsonlSessionManager = class _LocalJsonlSessionManager {
+  constructor(sessionsDir, filePath, inner) {
+    this.sessionsDir = sessionsDir;
+    this.filePath = filePath;
+    this.inner = inner;
+  }
+  sessionsDir;
+  filePath;
+  inner;
+  static async create(sessionsDir, input) {
+    const header = createSessionHeader(input);
+    const path = safeSessionPath(sessionsDir, header.id);
+    if (!path) {
+      throw new Error(`Invalid session id: ${header.id}`);
+    }
+    const exists = await stat3(path).then(() => true).catch((error) => {
+      if (error.code === "ENOENT") {
+        return false;
+      }
+      throw error;
+    });
+    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])
+    );
+  }
+  static async open(sessionsDir, id) {
+    const path = safeSessionPath(sessionsDir, id);
+    if (!path) {
+      return void 0;
+    }
+    const records = await readRecords(path);
+    if (!records) {
+      return void 0;
+    }
+    const header = records[0];
+    if (header.id !== id) {
+      throw new Error(`Session id mismatch: expected ${id}, found ${header.id}`);
+    }
+    return new _LocalJsonlSessionManager(
+      sessionsDir,
+      path,
+      InMemorySessionManager.fromRecords(records)
+    );
+  }
+  static async list(sessionsDir) {
+    const entries = await readdir2(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 = 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));
+  }
+  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;
+    });
+  }
+  getSessionId() {
+    return this.inner.getSessionId();
+  }
+  getSessionFile() {
+    return this.filePath;
+  }
+  async getHeader() {
+    return this.inner.getHeader();
+  }
+  async appendMessage(message) {
+    return this.appendThroughInner(() => this.inner.appendMessage(message));
+  }
+  async appendOutcome(outcome) {
+    return this.appendThroughInner(() => this.inner.appendOutcome(outcome));
+  }
+  async appendExecutionTurn(turn) {
+    return this.appendThroughInner(() => this.inner.appendExecutionTurn(turn));
+  }
+  async appendCompaction(input) {
+    return this.appendThroughInner(() => this.inner.appendCompaction(input));
+  }
+  async appendBranchSummary(input) {
+    return this.appendThroughInner(() => this.inner.appendBranchSummary(input));
+  }
+  async appendSessionInfo(input) {
+    return this.appendThroughInner(() => this.inner.appendSessionInfo(input));
+  }
+  async appendCustom(input) {
+    return this.appendThroughInner(() => this.inner.appendCustom(input));
+  }
+  async branch(entryId) {
+    await this.inner.branch(entryId);
+    if (entryId) {
+      await this.appendThroughInner(() => this.inner.appendBranchSummary({
+        fromId: entryId,
+        summary: `Selected branch at ${entryId}`
+      }));
+    }
+  }
+  async buildAgentContext(input) {
+    return this.inner.buildAgentContext(input);
+  }
+  async listEntries() {
+    return this.inner.listEntries();
+  }
+  async loadExecutionTurns(filter) {
+    return this.inner.loadExecutionTurns(filter);
+  }
+  async appendThroughInner(append) {
+    const before = await this.inner.listEntries();
+    const entryId = await append();
+    const after = await this.inner.listEntries();
+    const entry = after.find((candidate) => candidate.id === entryId);
+    if (!entry || before.some((candidate) => candidate.id === entry.id)) {
+      throw new Error(`Session entry was not appended: ${entryId}`);
+    }
+    await mkdir2(this.sessionsDir, { recursive: true });
+    await appendRecord(this.filePath, entry);
+    return entryId;
+  }
+};
+
+// src/harness/skills.ts
+import { existsSync as existsSync3 } from "fs";
+import { readFile as readFile4 } from "fs/promises";
+import { basename as basename2, dirname as dirname5, extname as extname2, isAbsolute as isAbsolute3, join as join4, resolve as resolve6 } from "path";
+
+// src/harness/env/path.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { homedir } from "os";
+import { basename, dirname as dirname4, isAbsolute as isAbsolute2, join as join3, parse, relative as relative3, resolve as resolve5, sep as sep3 } from "path";
+var WORKSPACE_ENV = "ROWAN_WORKSPACE";
+var RUNTIME_ENV = "ROWAN_RUNTIME";
+var PACKAGED_ENV = "ROWAN_PACKAGED";
+var BINARY_WORKSPACE_DIR = ".rowan";
+function nonEmptyEnv(env, key) {
+  const value = env[key]?.trim();
+  return value ? value : void 0;
+}
+function isTruthyEnvValue(value) {
+  return value === "1" || value?.toLowerCase() === "true" || value?.toLowerCase() === "yes";
+}
+function resolveUserPath(path, homeDir) {
+  if (path === "~") {
+    return homeDir;
+  }
+  if (path.startsWith("~/") || path.startsWith("~\\")) {
+    return join3(homeDir, path.slice(2));
+  }
+  return resolve5(path);
+}
+function isSourceWorkspaceRoot(path) {
+  const packagePath = join3(path, "package.json");
+  if (!existsSync2(packagePath)) {
+    return false;
+  }
+  try {
+    const manifest = JSON.parse(readFileSync2(packagePath, "utf8"));
+    return manifest.name === "rowan-agent" || Array.isArray(manifest.workspaces);
+  } catch {
+    return false;
+  }
+}
+function findSourceWorkspaceRoot(startDir = process.cwd()) {
+  let current = resolve5(startDir);
+  const { root } = parse(current);
+  while (true) {
+    if (isSourceWorkspaceRoot(current)) {
+      return current;
+    }
+    if (current === root) {
+      return resolve5(startDir);
+    }
+    current = dirname4(current);
+  }
+}
+function detectRuntimeMode(input = {}) {
+  const env = input.env ?? process.env;
+  const explicitMode = nonEmptyEnv(env, RUNTIME_ENV)?.toLowerCase();
+  if (explicitMode === "source" || explicitMode === "binary") {
+    return explicitMode;
+  }
+  if (isTruthyEnvValue(nonEmptyEnv(env, PACKAGED_ENV))) {
+    return "binary";
+  }
+  const executable = basename(input.execPath ?? process.execPath).toLowerCase().replace(/\.exe$/, "");
+  return executable === "bun" ? "source" : "binary";
+}
+function defaultSourceStartDir(options) {
+  if (options.cwd) {
+    return options.cwd;
+  }
+  const entrypoint = options.entrypoint ?? process.argv[1];
+  if (entrypoint) {
+    const entrypointPath = resolve5(process.cwd(), entrypoint);
+    if (existsSync2(entrypointPath)) {
+      return dirname4(entrypointPath);
+    }
+  }
+  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);
+  }
+  const mode = options.mode ?? detectRuntimeMode(options);
+  if (mode === "binary") {
+    return homeDir;
+  }
+  return findSourceWorkspaceRoot(defaultSourceStartDir(options));
+}
+function resolveWorkspacePaths(options = {}) {
+  const mode = options.mode ?? detectRuntimeMode(options);
+  const cwd = resolveWorkspaceRoot({ ...options, mode });
+  return {
+    mode,
+    cwd,
+    rowanDir: join3(cwd, BINARY_WORKSPACE_DIR)
+  };
+}
+function resolveInWorkspace(path, rootOrPaths) {
+  if (path === "~" || path.startsWith("~/") || path.startsWith("~\\")) {
+    return resolveUserPath(path, homedir());
+  }
+  if (isAbsolute2(path)) {
+    return path;
+  }
+  const root = typeof rootOrPaths === "string" ? rootOrPaths : rootOrPaths.cwd;
+  return resolve5(root, path);
+}
+
+// src/harness/skills.ts
+function inferSkillName(path) {
+  const file = basename2(path);
+  if (file.toLowerCase() === "skill.md") {
+    return basename2(dirname5(path));
+  }
+  const extension = extname2(file);
+  return extension ? file.slice(0, -extension.length) : file;
+}
+function isExplicitPath(input) {
+  return input.includes("/") || input.includes("\\") || Boolean(extname2(input));
+}
+function resolveSkillPath(input, workspace = resolveWorkspacePaths()) {
+  if (isAbsolute3(input)) {
+    return input;
+  }
+  if (!isExplicitPath(input)) {
+    return join4(workspace.rowanDir, "skills", input, "SKILL.md");
+  }
+  const workspacePath = resolveInWorkspace(input, workspace);
+  if (existsSync3(workspacePath)) {
+    return workspacePath;
+  }
+  return resolve6(input);
+}
+function parseFrontmatter(raw) {
+  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+  if (!match) return { frontmatter: {}, body: raw };
+  const frontmatter = {};
+  for (const line of match[1].split("\n")) {
+    const idx = line.indexOf(":");
+    if (idx === -1) continue;
+    const key = line.slice(0, idx).trim();
+    const value = line.slice(idx + 1).trim();
+    if (key) frontmatter[key] = value;
+  }
+  return { frontmatter, body: raw.slice(match[0].length) };
+}
+async function loadSkill(path, workspace) {
+  const resolved = resolveSkillPath(path, workspace);
+  const raw = await readFile4(resolved, "utf8");
+  const { frontmatter } = parseFrontmatter(raw);
+  return {
+    name: frontmatter.name ?? inferSkillName(resolved),
+    description: frontmatter.description ?? "",
+    filePath: resolved,
+    baseDir: dirname5(resolved),
+    disableModelInvocation: frontmatter["disable-model-invocation"] === "true"
+  };
+}
+async function loadSkills(paths = [], workspace) {
+  return Promise.all(paths.map((path) => loadSkill(path, workspace)));
+}
+export {
+  AGENT_STATE_SCHEMA_VERSION,
+  Agent,
+  AgentEventStream,
+  AgentMessageSchema,
+  DEFAULT_PHASE_ID,
+  EventStream,
+  ExtensionRunner,
+  HooksManager,
+  InMemorySessionManager,
+  LocalJsonlSessionManager,
+  SESSION_MANAGER_SCHEMA_VERSION,
+  SESSION_SCHEMA_VERSION,
+  SkillSchema,
+  appendUserTurn,
+  buildModelRequest,
+  buildSystemPrompt,
+  conversationMessages,
+  createAgentState,
+  createBuiltinPhaseRegistry,
+  createCoreTools,
+  createDefaultPhaseRegistry,
+  createEventBus,
+  createExtension,
+  createExtensionRunner,
+  createExtensionRuntime,
+  createId,
+  createJson,
+  createMessage,
+  createPhaseRegistry,
+  createSession,
+  createSessionHeader,
+  createSourceInfo,
+  createTimestamp,
+  definePhase,
+  discoverAndLoadExtensions,
+  getBuiltinExtensions,
+  getBuiltinRunner,
+  getGlobalHooks,
+  isBuiltinPhaseOverride,
+  isBuiltinSource,
+  latestUserInput,
+  loadExtensionFromFactory,
+  loadExtensionFromFactorySync,
+  loadExtensions,
+  loadSkill,
+  loadSkills,
+  resetGlobalHooks,
+  resolveInWorkspace,
+  resolveSkillPath,
+  resolveWorkspacePaths,
+  serializeSkills,
+  summarizeSessionManagerRecords
+};