@rowan-agent/agent 0.8.5 → 0.8.6

package/dist/index.js

@@ -33,6 +33,18 @@ function buildSkillsDescription(skills) {
   lines.push("</available_skills>");
   return lines.join("\n");
 }
+function buildContextDescription(contexts) {
+  if (contexts.length === 0) return "";
+  const lines = ["<agent_context>"];
+  for (const context of contexts) {
+    lines.push(`  <context name="${escapeXml(context.name)}">`);
+    const value = jsonToXml(context.value, 2);
+    if (value) lines.push(value);
+    lines.push("  </context>");
+  }
+  lines.push("</agent_context>");
+  return lines.join("\n");
+}
 function formatResourceOutput(resource) {
   const parts = [`<${resource.type} name="${escapeXml(resource.name)}" location="${escapeXml(resource.location)}">`];
   if (resource.baseDir) {
@@ -955,6 +967,7 @@ function createExtensionAPI(hooks, options, runtime, eventBus) {
   };
   const ctx = options?.context ?? noopContext;
   const phaseIn = options?.phase;
+  const trackCleanup = options?.trackCleanup;
   let outputPayload = phaseIn?.state?.payload;
   let nextPhase;
   let outputMessage;
@@ -962,6 +975,7 @@ function createExtensionAPI(hooks, options, runtime, eventBus) {
     on: (eventType, handler) => {
       assertActive();
       hooks?.on(eventType, handler);
+      trackCleanup?.(() => hooks?.off(eventType, handler));
     },
     off: (eventType, handler) => {
       assertActive();
@@ -978,6 +992,7 @@ function createExtensionAPI(hooks, options, runtime, eventBus) {
     registerProvider: (config) => {
       assertActive();
       options?.registerProvider?.(config);
+      trackCleanup?.(() => options?.unregisterProvider?.(config.id));
     },
     unregisterProvider: (name) => {
       assertActive();
@@ -989,7 +1004,17 @@ function createExtensionAPI(hooks, options, runtime, eventBus) {
       formatJson
     },
     context: ctx,
-    events: eventBus ?? { on: () => () => {
+    events: eventBus ? {
+      on: (event, listener) => {
+        const unsubscribe = eventBus.on(event, listener);
+        trackCleanup?.(unsubscribe);
+        return unsubscribe;
+      },
+      off: (event) => eventBus.off(event),
+      emit: (event, ...args) => eventBus.emit(event, ...args),
+      has: (event) => eventBus.has(event),
+      count: (event) => eventBus.count(event)
+    } : { on: () => () => {
     }, off: () => {
     }, emit: () => {
     }, has: () => false, count: () => 0 },
@@ -1025,9 +1050,10 @@ function assertAgentDefinition(value) {
   requiredString(value.content, "definition.content");
   optionalStringList(value.tools, "definition.tools");
   optionalStringList(value.skills, "definition.skills");
-  optionalStringList(value.phases, "definition.phases");
-  optionalStringList(value.extensions, "definition.extensions");
-  optionalString(value.entryPhase, "definition.entryPhase");
+  optionalPhaseRegistrySelection(value.phases, "definition.phases");
+  optionalStringList(value.context, "definition.context");
+  if ("extensions" in value) throw new TypeError("definition.extensions is not supported; Extensions are Runtime-global");
+  if ("entryPhase" in value) throw new TypeError("definition.entryPhase is not supported; use definition.phases.entryPhaseId");
   if (value.model !== void 0) {
     if (!isRecord(value.model) || typeof value.model.provider !== "string" || value.model.provider.trim() === "" || typeof value.model.id !== "string" || value.model.id.trim() === "") {
       throw new TypeError("definition.model must be a valid model reference");
@@ -1044,9 +1070,14 @@ function normalizeAgentDefinition(frontmatter, content, options = {}) {
   const normalizedContent = requiredString(content, "content");
   const tools = optionalStringList(frontmatter.tools, "tools");
   const skills = optionalStringList(frontmatter.skills, "skills");
-  const phases = optionalStringList(frontmatter.phases, "phases");
-  const extensions = optionalStringList(frontmatter.extensions, "extensions");
-  const entryPhase = optionalString(frontmatter.entryPhase, "entryPhase");
+  const phases = optionalPhaseRegistrySelection(frontmatter.phases, "phases");
+  if (frontmatter.extensions !== void 0) {
+    throw new TypeError("extensions is not supported; Extensions are Runtime-global");
+  }
+  const context = optionalStringList(frontmatter.context, "context");
+  if (frontmatter.entryPhase !== void 0) {
+    throw new TypeError("entryPhase is not supported; use phases.entryPhaseId");
+  }
   const model = optionalModel(frontmatter.model);
   return {
     name,
@@ -1055,8 +1086,7 @@ function normalizeAgentDefinition(frontmatter, content, options = {}) {
     ...tools ? { tools } : {},
     ...skills ? { skills } : {},
     ...phases ? { phases } : {},
-    ...extensions ? { extensions } : {},
-    ...entryPhase ? { entryPhase } : {},
+    ...context ? { context } : {},
     ...model ? { model } : {}
   };
 }
@@ -1089,6 +1119,22 @@ function optionalStringList(value, field) {
   }
   return names;
 }
+function optionalPhaseRegistrySelection(value, field) {
+  if (value === void 0) return void 0;
+  if (!isRecord(value)) throw new TypeError(`${field} must be an object`);
+  if (!("entryPhaseId" in value)) throw new TypeError(`${field}.entryPhaseId is required`);
+  if (!("phaseIds" in value)) throw new TypeError(`${field}.phaseIds is required`);
+  const entryPhaseId = value.entryPhaseId;
+  if (entryPhaseId !== null && (typeof entryPhaseId !== "string" || entryPhaseId.trim() === "")) {
+    throw new TypeError(`${field}.entryPhaseId must be a non-empty string or null`);
+  }
+  const phaseIds = optionalStringList(value.phaseIds, `${field}.phaseIds`);
+  if (!phaseIds) throw new TypeError(`${field}.phaseIds is required`);
+  return {
+    entryPhaseId: entryPhaseId === null ? null : entryPhaseId.trim(),
+    phaseIds
+  };
+}
 function optionalModel(value) {
   const source = optionalString(value, "model");
   if (!source) return void 0;
@@ -1693,7 +1739,7 @@ function createTerminalOutcome(phase, output, transcript) {
   return phase.run || phase.factory ? createOutcome.phase(output, transcript) : createOutcome.default(output, transcript);
 }
 function buildToolsWithRouting(config, availablePhases) {
-  const tools = [...config.context.tools];
+  const tools = config.context.tools.filter((tool) => tool.name !== PhaseRouteTool);
   if (availablePhases.length > 0) {
     tools.push(createRouteTool(availablePhases));
   }
@@ -2158,7 +2204,7 @@ async function withRetry(fn, options = {}) {
       }
       const delayMs = getRetryDelay(attempt, baseDelayMs, maxDelayMs);
       options.onRetry?.(attempt, error, delayMs);
-      await new Promise((resolve6) => setTimeout(resolve6, delayMs));
+      await new Promise((resolve7) => setTimeout(resolve7, delayMs));
       if (options.signal?.aborted) {
         throw lastError;
       }
@@ -2663,6 +2709,9 @@ function isContinuation(value) {
 }
 
 // src/runtime/contracts.ts
+function isAgentConfiguration(config) {
+  return !("resources" in config);
+}
 var METADATA_LIMIT = 64 * 1024;
 var IDENTITY_LIMIT = 256;
 function isRecord3(value) {
@@ -2715,6 +2764,39 @@ function assertAgentConfig(config) {
     throw new TypeError("config.resources is invalid");
   }
   for (const tool of config.resources.tools) projectToolDefinition(tool);
+  const names = /* @__PURE__ */ new Set();
+  for (const context of config.resources.contexts ?? []) {
+    if (typeof context.name !== "string" || context.name.trim() === "") {
+      throw new TypeError("Context candidate name must be non-empty");
+    }
+    if (names.has(context.name)) throw new TypeError(`Duplicate Context candidate "${context.name}".`);
+    names.add(context.name);
+    assertJsonValue(context.value, `Context candidate "${context.name}" value`);
+  }
+}
+function assertAgentConfigRequest(config) {
+  if (!isAgentConfiguration(config)) {
+    assertAgentConfig(config);
+    return;
+  }
+  if (typeof config.identity !== "string" || config.identity.length === 0) throw new TypeError("config.identity must be non-empty");
+  assertUtf8ByteLimit(config.identity, IDENTITY_LIMIT, "config.identity");
+  if (!config.definition || typeof config.definition.name !== "string" || config.definition.name.trim() === "") {
+    throw new TypeError("config.definition.name must be non-empty");
+  }
+  const view = config.resourceView;
+  if (!view || !Array.isArray(view.agents) || !Array.isArray(view.tools) || !Array.isArray(view.skills) || !Array.isArray(view.phases)) {
+    throw new TypeError("config.resourceView is invalid");
+  }
+  for (const [kind, ids] of Object.entries(view)) {
+    for (const sourceId of ids) {
+      if (typeof sourceId !== "string" || sourceId.trim() === "") throw new TypeError(`config.resourceView.${kind} contains an invalid Source ID`);
+    }
+  }
+  for (const context of config.contexts ?? []) {
+    if (typeof context.name !== "string" || context.name.trim() === "") throw new TypeError("Context candidate name must be non-empty");
+    assertJsonValue(context.value, `Context candidate "${context.name}" value`);
+  }
 }
 function assertToolExecutionResult(value) {
   if (!isToolResult(value)) throw new TypeError("Tool result must be JSON-safe and contain no Runtime identity");
@@ -2808,21 +2890,92 @@ function validateConfigResolution(agentId, value) {
   throw new Error(`Config Provider returned an invalid resolution for Agent ${agentId}.`);
 }
 function snapshotConfig(config) {
+  if (isAgentConfiguration(config)) return snapshotConfiguration(config);
   const definition = Object.freeze({
     ...config.definition,
     ...config.definition.tools ? { tools: Object.freeze([...config.definition.tools]) } : {},
     ...config.definition.skills ? { skills: Object.freeze([...config.definition.skills]) } : {},
-    ...config.definition.phases ? { phases: Object.freeze([...config.definition.phases]) } : {},
-    ...config.definition.extensions ? { extensions: Object.freeze([...config.definition.extensions]) } : {}
+    ...config.definition.phases ? {
+      phases: Object.freeze({
+        entryPhaseId: config.definition.phases.entryPhaseId,
+        phaseIds: Object.freeze([...config.definition.phases.phaseIds])
+      })
+    } : {},
+    ...config.definition.context ? { context: Object.freeze([...config.definition.context]) } : {}
   });
   const resources = Object.freeze({
     ...config.resources,
     tools: Object.freeze([...config.resources.tools]),
     skills: Object.freeze([...config.resources.skills]),
-    ...config.resources.extensions ? { extensions: Object.freeze([...config.resources.extensions]) } : {}
+    ...config.resources.resourceView ? {
+      resourceView: Object.freeze({
+        agents: Object.freeze([...config.resources.resourceView.agents]),
+        tools: Object.freeze([...config.resources.resourceView.tools]),
+        skills: Object.freeze([...config.resources.resourceView.skills]),
+        phases: Object.freeze([...config.resources.resourceView.phases])
+      })
+    } : {},
+    ...config.resources.resourceRefs ? { resourceRefs: Object.freeze(config.resources.resourceRefs.map((ref) => Object.freeze({ ...ref }))) } : {},
+    ...config.resources.resourceRevisions ? {
+      resourceRevisions: Object.freeze(Object.fromEntries(
+        Object.entries(config.resources.resourceRevisions).map(([kind, revisions]) => [kind, Object.freeze([...revisions])])
+      ))
+    } : {},
+    ...config.resources.contexts ? {
+      contexts: Object.freeze(config.resources.contexts.map((context) => Object.freeze({
+        name: context.name,
+        value: snapshotJsonValue(context.value)
+      })))
+    } : {}
   });
   return Object.freeze({ ...config, definition, resources });
 }
+function snapshotConfiguration(config) {
+  const layer = config.definition.layer;
+  const definition = Object.freeze({
+    name: config.definition.name,
+    ...layer === void 0 ? {} : {
+      layer: Object.freeze({
+        ...layer,
+        ...layer.tools ? { tools: Object.freeze([...layer.tools]) } : {},
+        ...layer.skills ? { skills: Object.freeze([...layer.skills]) } : {},
+        ...layer.phases ? {
+          phases: Object.freeze({
+            entryPhaseId: layer.phases.entryPhaseId,
+            phaseIds: Object.freeze([...layer.phases.phaseIds])
+          })
+        } : {}
+      })
+    }
+  });
+  const resourceView = Object.freeze({
+    agents: Object.freeze([...config.resourceView.agents]),
+    tools: Object.freeze([...config.resourceView.tools]),
+    skills: Object.freeze([...config.resourceView.skills]),
+    phases: Object.freeze([...config.resourceView.phases])
+  });
+  return Object.freeze({
+    ...config,
+    definition,
+    resourceView,
+    ...config.contexts ? {
+      contexts: Object.freeze(config.contexts.map((context) => Object.freeze({
+        name: context.name,
+        value: snapshotJsonValue(context.value)
+      })))
+    } : {}
+  });
+}
+function snapshotJsonValue(value) {
+  return deepFreeze(JSON.parse(canonicalJson(value)));
+}
+function deepFreeze(value) {
+  if (value && typeof value === "object") {
+    for (const child of Object.values(value)) deepFreeze(child);
+    Object.freeze(value);
+  }
+  return value;
+}
 function assertConfigIdentity(identity) {
   if (typeof identity !== "string" || identity.length === 0) throw new TypeError("config.identity must be non-empty");
   assertUtf8ByteLimit(identity, 256, "config.identity");
@@ -2867,7 +3020,7 @@ var ConfigCommandService = class {
   configs;
   storeIncarnation;
   async createAgent(input) {
-    assertAgentConfig(input.config);
+    assertAgentConfigRequest(input.config);
     assertIdentity(input.config.identity);
     const reserved = await this.store.reserveAgent({
       idempotencyKey: input.idempotencyKey,
@@ -2889,7 +3042,7 @@ var ConfigCommandService = class {
     return reserved.id;
   }
   async updateAgentConfig(input) {
-    assertAgentConfig(input.config);
+    assertAgentConfigRequest(input.config);
     assertIdentity(input.config.identity);
     const agent = await this.findAgent(input.agentId);
     const operationId = this.operationId("update_agent_config", input.agentId, input.idempotencyKey);
@@ -2916,6 +3069,23 @@ var ConfigCommandService = class {
     const resolution = validateConfigResolution(input.agent.id, result);
     return resolution;
   }
+  /** Persist one resolved Configuration Snapshot under a Run-specific token.
+   * The durable Run pins this token at claim time, so later Source replacement
+   * cannot mutate an active or input-waiting Run. */
+  async storeSnapshot(input) {
+    assertAgentConfigRequest(input.config);
+    const result = await this.put({
+      agentId: input.agent.id,
+      agentMetadata: input.agent.metadata,
+      config: input.config,
+      operationId: input.operationId,
+      signal: input.signal
+    });
+    if (result.kind === "identity_conflict") {
+      throw idempotencyConflict("update_agent_config", input.operationId);
+    }
+    return brandConfigToken(result.token);
+  }
   async findAgent(agentId) {
     const agent = (await this.store.listAgents()).find((candidate) => candidate.id === agentId);
     if (!agent) throw new RuntimeError("agent_not_found", { agentId });
@@ -3149,157 +3319,401 @@ function jsonText(value) {
   return typeof value === "string" ? value : JSON.stringify(value) ?? "null";
 }
 
-// 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();
-  on(eventType, handler) {
-    const handlers = this.handlers.get(eventType) ?? [];
-    handlers.push(handler);
-    this.handlers.set(eventType, handlers);
-  }
-  off(eventType, handler) {
-    const handlers = this.handlers.get(eventType);
-    if (!handlers) return;
-    const index = handlers.indexOf(handler);
-    if (index >= 0) handlers.splice(index, 1);
-  }
-  async emit(eventType, event) {
-    const handlers = this.handlers.get(eventType);
-    if (!handlers?.length) return;
-    const results = await Promise.allSettled(handlers.map((handler) => handler(event)));
-    const failure = results.find((result) => result.status === "rejected");
-    if (failure) {
-      throw new HookError(
-        eventType,
-        `${results.filter((result) => result.status === "rejected").length} handler(s) failed for "${eventType}"`,
-        failure.reason instanceof Error ? failure.reason : new Error(String(failure.reason))
-      );
-    }
+// src/runtime/extensions.ts
+function assembleRegisteredExtensions(config, runner) {
+  const extensionTools = runner.getAllRegisteredTools().map(adaptExtensionTool);
+  const tools = [...config.resources.tools];
+  const names = new Set(tools.map((tool) => tool.name));
+  for (const tool of extensionTools) {
+    if (names.has(tool.name)) throw new TypeError(`Extension Tool collides with Context Tool "${tool.name}"`);
+    names.add(tool.name);
+    tools.push(tool);
   }
-  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))
-        );
-      }
+  const extensionPhases = runner.createPhaseRegistry({ entryPhaseId: null });
+  const phases = mergePhases(config.resources.phases, extensionPhases);
+  const context = resolveDefinitionContext(config, { tools, phases });
+  return {
+    context,
+    beforePhase: (phaseId, input) => runner.emitBeforePhase(phaseId, input),
+    afterPhase: (phaseId, output) => runner.emitAfterPhase(phaseId, output),
+    beforePrompt: (phaseId, input) => runner.emitBeforePrompt(phaseId, input),
+    beforeToolCall: async (input) => {
+      const tool = projectTool(input.tool, input.context.agentId, input.context.runId);
+      const decision = await runner.emitBeforeToolCall(tool, input.args);
+      return decision.allow ? { allow: true } : { allow: false, reason: decision.reason ?? "Extension hook rejected the Tool." };
+    },
+    afterToolCall: async (input) => {
+      const tool = projectTool(input.tool, input.context.agentId, input.context.runId);
+      const result = await runner.emitAfterToolCall(tool, toLoopResult(input.result, input.context.toolCallId, input.tool.name));
+      return fromLoopResult(result);
+    },
+    setContext: (context2) => {
+      runner.currentContext = context2;
     }
-    return void 0;
+  };
+}
+function resolveDefinitionContext(config, assembled = {}) {
+  const tools = selectNamedResources(
+    assembled.tools ?? config.resources.tools,
+    config.definition.tools,
+    "Tool"
+  );
+  const skills = selectNamedResources(
+    config.resources.skills,
+    config.definition.skills,
+    "Skill"
+  );
+  const contexts = selectNamedResources(
+    config.resources.contexts ?? [],
+    config.definition.context,
+    "Context"
+  );
+  const candidateRegistry = assembled.phases ?? config.resources.phases;
+  const selectedPhases = selectNamedResources(
+    [...candidateRegistry?.phases.values() ?? []],
+    config.definition.phases?.phaseIds,
+    "Phase"
+  );
+  const phases = new Map(selectedPhases.map((phase) => [phase.name, phase]));
+  const requestedEntry = config.definition.phases ? config.definition.phases.entryPhaseId : candidateRegistry?.entryPhaseId ?? null;
+  const entryPhaseId = requestedEntry === DEFAULT_PHASE_ID ? DEFAULT_PHASE_ID : requestedEntry && phases.has(requestedEntry) ? requestedEntry : null;
+  if (requestedEntry && requestedEntry !== DEFAULT_PHASE_ID && !phases.has(requestedEntry)) {
+    console.warn(`Phase entry "${requestedEntry}" is not available; Rowan will use "default".`);
   }
-};
-
-// src/extensions/runner.ts
-import { execFile } from "child_process";
-import {
-  registerModel,
-  unregisterProviderModels,
-  registerApiProvider
-} from "@rowan-agent/models";
-
-// src/extensions/types.ts
-function createSourceInfo(extensionPath, options = {}) {
-  const source = options.source ?? (extensionPath.startsWith("<") ? "synthetic" : "local");
-  const displayName = extensionPath.startsWith("<") ? extensionPath.slice(1, -1) : extensionPath.split("/").pop() ?? extensionPath;
   return {
-    source,
-    baseDir: options.baseDir,
-    displayName
+    systemPrompt: [config.definition.content, buildContextDescription(contexts)].filter((section) => section.length > 0).join("\n\n"),
+    tools,
+    skills,
+    phases: { phases, entryPhaseId }
   };
 }
-function createExtensionRuntime() {
-  const state = {};
-  const assertActive = () => {
-    if (state.staleMessage) {
-      throw new Error(state.staleMessage);
-    }
+function mergePhases(base, extension) {
+  if (!base && extension.phases.size === 0) return void 0;
+  const phases = new Map(base?.phases ?? []);
+  for (const [name, phase] of extension.phases) {
+    if (phases.has(name)) throw new TypeError(`Extension Phase collides with Context Phase "${name}"`);
+    phases.set(name, phase);
+  }
+  return {
+    phases,
+    entryPhaseId: base?.entryPhaseId ?? extension.entryPhaseId
   };
+}
+function adaptExtensionTool(input) {
+  const definition = input.definition;
   return {
-    assertActive,
-    invalidate: (message) => {
-      state.staleMessage ??= message ?? "This extension context is stale after runtime replacement or reload. Do not use a captured extension API after the runner has been replaced.";
+    name: definition.name,
+    description: definition.description,
+    parameters: definition.parameters,
+    execute: async (args, _context, signal) => {
+      const result = await definition.execute(args, signal);
+      const content = JSON.parse(JSON.stringify(result.content));
+      return result.isError ? { ok: false, content, error: "Extension Tool failed." } : { ok: true, content };
     }
   };
 }
-
-// src/extensions/runner.ts
-import { parseModelRef as parseModelRef2 } from "@rowan-agent/models";
-
-// src/extensions/event-bus.ts
-function createEventBus() {
-  const listeners = /* @__PURE__ */ new Map();
+function toLoopResult(result, toolCallId, toolName) {
   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;
-    }
+    toolCallId,
+    toolName,
+    ok: result.ok,
+    content: result.content,
+    ...!result.ok ? { error: result.error } : {}
   };
 }
+function fromLoopResult(result) {
+  return result.ok ? { ok: true, content: result.content } : { ok: false, content: result.content, error: result.error ?? "Extension hook rejected the Tool result." };
+}
 
-// src/extensions/runner.ts
-async function execCommand(command, args, cwd, options) {
-  return new Promise((resolve6, 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;
-        }
-        resolve6({
-          exitCode: typeof error?.code === "number" ? error.code : error ? 1 : 0,
-          stdout: stdout ?? "",
+// src/runtime/transient-run-events.ts
+var MAX_BUFFERED_EVENTS = 128;
+var MAX_BUFFERED_TEXT = 64 * 1024;
+function deferred() {
+  let resolve7;
+  const promise = new Promise((done) => {
+    resolve7 = done;
+  });
+  return { promise, resolve: resolve7 };
+}
+var TransientRunEventSubscription = class {
+  queue = [];
+  wake = deferred();
+  version = 0;
+  stopped = false;
+  push(event) {
+    if (this.stopped) return;
+    const previous = this.queue.at(-1);
+    if (previous?.kind === "message_delta" && event.kind === "message_delta" && previous.executionId === event.executionId && previous.messageId === event.messageId && previous.offset + previous.text.length === event.offset) {
+      this.queue[this.queue.length - 1] = {
+        ...previous,
+        text: previous.text + event.text
+      };
+    } else {
+      if (this.queue.length >= MAX_BUFFERED_EVENTS) this.queue.shift();
+      this.queue.push(event);
+    }
+    this.trimText();
+    this.notify();
+  }
+  shift() {
+    return this.queue.shift();
+  }
+  clear(executionId) {
+    if (executionId === void 0) this.queue.length = 0;
+    else {
+      for (let index = this.queue.length - 1; index >= 0; index -= 1) {
+        if (this.queue[index]?.executionId === executionId) this.queue.splice(index, 1);
+      }
+    }
+    this.notify();
+  }
+  clearMessage(messageId) {
+    for (let index = this.queue.length - 1; index >= 0; index -= 1) {
+      const event = this.queue[index];
+      if (event?.kind === "message_delta" && event.messageId === messageId) this.queue.splice(index, 1);
+    }
+    this.notify();
+  }
+  clearTool(toolCallId) {
+    for (let index = this.queue.length - 1; index >= 0; index -= 1) {
+      const event = this.queue[index];
+      if (event?.kind === "tool_progress" && event.toolCallId === toolCallId) this.queue.splice(index, 1);
+    }
+    this.notify();
+  }
+  checkpoint() {
+    return this.version;
+  }
+  changed(since) {
+    if (this.version !== since || this.queue.length > 0 || this.stopped) return Promise.resolve();
+    return this.wake.promise;
+  }
+  stop() {
+    if (this.stopped) return;
+    this.stopped = true;
+    this.queue.length = 0;
+    this.notify();
+  }
+  notify() {
+    const wake = this.wake;
+    this.wake = deferred();
+    this.version += 1;
+    wake.resolve();
+  }
+  trimText() {
+    let buffered = this.queue.reduce(
+      (length, event) => length + (event.kind === "message_delta" ? event.text.length : 0),
+      0
+    );
+    while (buffered > MAX_BUFFERED_TEXT) {
+      const index = this.queue.findIndex((event2) => event2.kind === "message_delta");
+      if (index < 0) return;
+      const event = this.queue[index];
+      const overflow = buffered - MAX_BUFFERED_TEXT;
+      if (event.text.length <= overflow) {
+        this.queue.splice(index, 1);
+        buffered -= event.text.length;
+      } else {
+        this.queue[index] = {
+          ...event,
+          offset: event.offset + overflow,
+          text: event.text.slice(overflow)
+        };
+        buffered -= overflow;
+      }
+    }
+  }
+};
+var TransientRunEventHub = class {
+  subscriptions = /* @__PURE__ */ new Map();
+  subscribe(runId) {
+    const subscription = new TransientRunEventSubscription();
+    const current = this.subscriptions.get(runId) ?? /* @__PURE__ */ new Set();
+    current.add(subscription);
+    this.subscriptions.set(runId, current);
+    return subscription;
+  }
+  unsubscribe(runId, subscription) {
+    subscription.stop();
+    const current = this.subscriptions.get(runId);
+    current?.delete(subscription);
+    if (current?.size === 0) this.subscriptions.delete(runId);
+  }
+  publish(event) {
+    for (const subscription of this.subscriptions.get(event.runId) ?? []) {
+      subscription.push(event);
+    }
+  }
+  clear(runId, executionId) {
+    for (const subscription of this.subscriptions.get(runId) ?? []) {
+      subscription.clear(executionId);
+    }
+  }
+  clearMessage(runId, messageId) {
+    for (const subscription of this.subscriptions.get(runId) ?? []) subscription.clearMessage(messageId);
+  }
+  clearTool(runId, toolCallId) {
+    for (const subscription of this.subscriptions.get(runId) ?? []) subscription.clearTool(toolCallId);
+  }
+  close() {
+    for (const subscriptions of this.subscriptions.values()) {
+      for (const subscription of subscriptions) subscription.stop();
+    }
+    this.subscriptions.clear();
+  }
+};
+
+// 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();
+  on(eventType, handler) {
+    const handlers = this.handlers.get(eventType) ?? [];
+    handlers.push(handler);
+    this.handlers.set(eventType, handlers);
+  }
+  off(eventType, handler) {
+    const handlers = this.handlers.get(eventType);
+    if (!handlers) return;
+    const index = handlers.indexOf(handler);
+    if (index >= 0) handlers.splice(index, 1);
+  }
+  async emit(eventType, event) {
+    const handlers = this.handlers.get(eventType);
+    if (!handlers?.length) return;
+    const results = await Promise.allSettled(handlers.map((handler) => handler(event)));
+    const failure = results.find((result) => result.status === "rejected");
+    if (failure) {
+      throw new HookError(
+        eventType,
+        `${results.filter((result) => result.status === "rejected").length} handler(s) failed for "${eventType}"`,
+        failure.reason instanceof Error ? failure.reason : new Error(String(failure.reason))
+      );
+    }
+  }
+  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;
+  }
+};
+
+// src/extensions/runner.ts
+import { execFile } from "child_process";
+import {
+  registerModel,
+  unregisterProviderModels,
+  registerApiProvider
+} from "@rowan-agent/models";
+
+// src/extensions/types.ts
+function createSourceInfo(extensionPath, options = {}) {
+  const source = options.source ?? (extensionPath.startsWith("<") ? "synthetic" : "local");
+  const displayName = extensionPath.startsWith("<") ? extensionPath.slice(1, -1) : extensionPath.split("/").pop() ?? extensionPath;
+  return {
+    source,
+    baseDir: options.baseDir,
+    displayName
+  };
+}
+function createExtensionRuntime() {
+  const state = {};
+  const assertActive = () => {
+    if (state.staleMessage) {
+      throw new Error(state.staleMessage);
+    }
+  };
+  return {
+    assertActive,
+    invalidate: (message) => {
+      state.staleMessage ??= message ?? "This extension context is stale after runtime replacement or reload. Do not use a captured extension API after the runner has been replaced.";
+    }
+  };
+}
+
+// src/extensions/runner.ts
+import { parseModelRef as parseModelRef2 } from "@rowan-agent/models";
+
+// src/extensions/event-bus.ts
+function createEventBus() {
+  const listeners = /* @__PURE__ */ new Map();
+  return {
+    on(event, listener) {
+      const set = listeners.get(event) ?? /* @__PURE__ */ new Set();
+      set.add(listener);
+      listeners.set(event, set);
+      return () => {
+        set.delete(listener);
+        if (set.size === 0) listeners.delete(event);
+      };
+    },
+    emit(event, ...args) {
+      const set = listeners.get(event);
+      if (!set) return;
+      for (const listener of set) {
+        try {
+          listener(...args);
+        } catch (err) {
+          console.error(`[event-bus] Listener error for "${event}":`, err);
+        }
+      }
+    },
+    off(event) {
+      if (event) {
+        listeners.delete(event);
+      } else {
+        listeners.clear();
+      }
+    },
+    has(event) {
+      const set = listeners.get(event);
+      return set !== void 0 && set.size > 0;
+    },
+    count(event) {
+      return listeners.get(event)?.size ?? 0;
+    }
+  };
+}
+
+// src/extensions/runner.ts
+async function execCommand(command, args, cwd, options) {
+  return new Promise((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 ?? ""
         });
       }
@@ -3416,6 +3830,7 @@ var ExtensionRunner = class {
    */
   invalidate(message) {
     this.runtime.invalidate(message);
+    for (const extension of this.extensions) extension.runtime.invalidate(message);
   }
   // ---------------------------------------------------------------------------
   // Direct hook API
@@ -3445,13 +3860,21 @@ var ExtensionRunner = class {
    */
   async loadExtensions(extensions) {
     for (const ext of extensions) {
+      const extension = {
+        path: ext.path,
+        tools: /* @__PURE__ */ new Map(),
+        phases: /* @__PURE__ */ new Set(),
+        cleanup: [],
+        runtime: createExtensionRuntime()
+      };
       try {
-        const extension = { path: ext.path, tools: /* @__PURE__ */ new Map() };
         const api = this.createExtensionAPI(extension, ext.manifest);
-        await ext.factory(api);
+        const disposer = await ext.factory(api);
+        if (typeof disposer === "function") extension.disposer = disposer;
         this.extensions.push(extension);
         this._phaseCache = null;
       } catch (error) {
+        await this.rollbackExtension(extension);
         const message = error instanceof Error ? error.message : String(error);
         this.emitError({
           extensionPath: ext.path,
@@ -3463,6 +3886,17 @@ var ExtensionRunner = class {
       }
     }
   }
+  /** Dispose all active Extensions in reverse activation order. */
+  async close() {
+    this.abortController.abort();
+    for (const extension of [...this.extensions].reverse()) {
+      await this.disposeExtension(extension, "This Extension Runtime has been closed.");
+    }
+    this.extensions.length = 0;
+    this.phases.clear();
+    this._phaseCache = null;
+    this.runtime.invalidate("This Extension Runtime has been closed.");
+  }
   // ---------------------------------------------------------------------------
   // Tool management
   // ---------------------------------------------------------------------------
@@ -3660,8 +4094,9 @@ var ExtensionRunner = class {
       unregisterProvider: (name) => this.unregisterProvider(name),
       registerTool: (tool) => this.registerTool(extension, tool),
       context: extContext,
-      manifest
-    }, this.runtime, this.events);
+      manifest,
+      trackCleanup: (cleanup) => extension.cleanup.push(cleanup)
+    }, extension.runtime, this.events);
   }
   registerTool(extension, tool) {
     if (extension.tools.has(tool.name)) {
@@ -3718,6 +4153,7 @@ var ExtensionRunner = class {
       source: { extensionPath: extension.path }
     };
     this.phases.set(name, registered);
+    extension.phases.add(name);
     this._phaseCache = null;
   }
   registerProvider(config) {
@@ -3752,260 +4188,834 @@ var ExtensionRunner = class {
     this._phaseCache = new Map(this.phases);
     return this._phaseCache;
   }
+  async rollbackExtension(extension) {
+    await this.disposeExtension(extension, "This Extension activation was rolled back.");
+  }
+  async disposeExtension(extension, message) {
+    extension.runtime.invalidate(message);
+    for (const name of extension.phases) this.phases.delete(name);
+    for (const cleanup of [...extension.cleanup].reverse()) {
+      await Promise.resolve().then(() => cleanup()).catch(() => void 0);
+    }
+    if (extension.disposer) {
+      await Promise.resolve().then(() => extension.disposer()).catch(() => void 0);
+    }
+    this._phaseCache = null;
+  }
 };
 function createExtensionRunner(options) {
   return new ExtensionRunner(options);
 }
 
-// src/runtime/extensions.ts
-async function assembleExtensions(config) {
-  const selectedExtensions = selectNamedResources(
-    config.resources.extensions ?? [],
-    config.definition.extensions,
-    "Extension"
-  );
-  if (selectedExtensions.length === 0) {
-    return { context: resolveDefinitionContext(config) };
+// src/extensions/loader.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { readdir as readdir2, readFile as readFile3, stat as stat2 } from "fs/promises";
+import { fileURLToPath } from "url";
+import { basename as basename3, dirname as dirname4, extname as extname2, join as join2, resolve as resolve4 } from "path";
+import { createJiti } from "jiti";
+function isExtensionFile(path) {
+  const extension = extname2(path).toLowerCase();
+  return extension === ".ts" || extension === ".js";
+}
+function isSyntheticPath(path) {
+  return path.startsWith("<") && path.endsWith(">");
+}
+function readManifestSync(dir) {
+  const manifestPath = join2(dir, "package.json");
+  if (!existsSync2(manifestPath)) {
+    return void 0;
   }
-  const runner = createExtensionRunner({ cwd: config.cwd });
-  await runner.loadExtensions(selectedExtensions);
-  runner.bind();
-  const extensionTools = runner.getAllRegisteredTools().map(adaptExtensionTool);
-  const tools = [...config.resources.tools];
-  const names = new Set(tools.map((tool) => tool.name));
-  for (const tool of extensionTools) {
-    if (names.has(tool.name)) throw new TypeError(`Extension Tool collides with Context Tool "${tool.name}"`);
-    names.add(tool.name);
-    tools.push(tool);
+  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;
   }
-  const extensionPhases = runner.createPhaseRegistry({ entryPhaseId: null });
-  const phases = mergePhases(config.resources.phases, extensionPhases);
-  const context = resolveDefinitionContext(config, { tools, phases });
-  return {
-    context,
-    beforePhase: (phaseId, input) => runner.emitBeforePhase(phaseId, input),
-    afterPhase: (phaseId, output) => runner.emitAfterPhase(phaseId, output),
-    beforePrompt: (phaseId, input) => runner.emitBeforePrompt(phaseId, input),
-    beforeToolCall: async (input) => {
-      const tool = projectTool(input.tool, input.context.agentId, input.context.runId);
-      const decision = await runner.emitBeforeToolCall(tool, input.args);
-      return decision.allow ? { allow: true } : { allow: false, reason: decision.reason ?? "Extension hook rejected the Tool." };
-    },
-    afterToolCall: async (input) => {
-      const tool = projectTool(input.tool, input.context.agentId, input.context.runId);
-      const result = await runner.emitAfterToolCall(tool, toLoopResult(input.result, input.context.toolCallId, input.tool.name));
-      return fromLoopResult(result);
-    },
-    setContext: (context2) => {
-      runner.currentContext = context2;
-    }
-  };
 }
-function resolveDefinitionContext(config, assembled = {}) {
-  const tools = selectNamedResources(
-    assembled.tools ?? config.resources.tools,
-    config.definition.tools,
-    "Tool"
-  );
-  const skills = selectNamedResources(
-    config.resources.skills,
-    config.definition.skills,
-    "Skill"
-  );
-  const candidateRegistry = assembled.phases ?? config.resources.phases;
-  const selectedPhases = selectNamedResources(
-    [...candidateRegistry?.phases.values() ?? []],
-    config.definition.phases,
-    "Phase"
-  );
-  const phases = new Map(selectedPhases.map((phase) => [phase.name, phase]));
-  const requestedEntry = config.definition.entryPhase ?? candidateRegistry?.entryPhaseId ?? null;
-  const entryPhaseId = requestedEntry === DEFAULT_PHASE_ID ? DEFAULT_PHASE_ID : requestedEntry && phases.has(requestedEntry) ? requestedEntry : null;
-  if (requestedEntry && requestedEntry !== DEFAULT_PHASE_ID && !phases.has(requestedEntry)) {
-    console.warn(`Phase entry "${requestedEntry}" is not available; Rowan will use "default".`);
+function jitiAliases() {
+  const moduleUrl = import.meta.url;
+  if (!moduleUrl) {
+    return {};
   }
-  return {
-    systemPrompt: config.definition.content,
-    tools,
-    skills,
-    phases: { phases, entryPhaseId }
-  };
+  const agentSourcePath = fileURLToPath(new URL("../index.ts", moduleUrl));
+  if (!existsSync2(agentSourcePath)) {
+    return {};
+  }
+  return { "@rowan-agent/agent": agentSourcePath };
 }
-function mergePhases(base, extension) {
-  if (!base && extension.phases.size === 0) return void 0;
-  const phases = new Map(base?.phases ?? []);
-  for (const [name, phase] of extension.phases) {
-    if (phases.has(name)) throw new TypeError(`Extension Phase collides with Context Phase "${name}"`);
-    phases.set(name, phase);
+var sharedJiti;
+function getJiti() {
+  sharedJiti ??= createJiti(import.meta.url || process.cwd(), {
+    fsCache: false,
+    moduleCache: false,
+    tryNative: false,
+    alias: jitiAliases()
+  });
+  return sharedJiti;
+}
+async function loadExtensionModule(extensionPath) {
+  const jiti = getJiti();
+  const module = await jiti.import(extensionPath, { default: true });
+  return typeof module === "function" ? module : void 0;
+}
+async function readPackageManifest(path) {
+  if (!existsSync2(path)) {
+    return void 0;
+  }
+  const content = await readFile3(path, "utf8");
+  return JSON.parse(content);
+}
+async function resolveExtensionEntries(dir) {
+  const manifest = await readPackageManifest(join2(dir, "package.json"));
+  const declared = manifest?.rowan?.extensions;
+  if (declared && declared.length > 0) {
+    return declared.map((entry) => resolve4(dir, entry));
+  }
+  for (const name of ["index.ts", "index.js"]) {
+    const entry = join2(dir, name);
+    if (existsSync2(entry)) {
+      return [entry];
+    }
+  }
+  return void 0;
+}
+async function discoverExtensionsInDir(dir) {
+  const entries = await readdir2(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 = join2(dir, entry.name);
+    if ((entry.isFile() || entry.isSymbolicLink()) && isExtensionFile(entry.name)) {
+      paths.push(entryPath);
+      continue;
+    }
+    if (entry.isDirectory() || entry.isSymbolicLink()) {
+      const info = entry.isSymbolicLink() ? await stat2(entryPath).catch(() => void 0) : void 0;
+      if (entry.isDirectory() || info?.isDirectory()) {
+        const resolvedEntries = await resolveExtensionEntries(entryPath);
+        if (resolvedEntries) {
+          paths.push(...resolvedEntries);
+        }
+      }
+    }
   }
+  return paths;
+}
+function loadExtensionFromFactory(factory, cwd, extensionPath = "<inline>") {
+  const resolvedCwd = resolve4(cwd);
+  const resolvedPath = isSyntheticPath(extensionPath) ? extensionPath : resolve4(resolvedCwd, extensionPath);
+  const name = isSyntheticPath(extensionPath) ? extensionPath : basename3(dirname4(resolvedPath)) || "unknown";
+  const manifestDir = isSyntheticPath(extensionPath) ? resolvedCwd : dirname4(resolvedPath);
+  const manifest = readManifestSync(manifestDir);
   return {
-    phases,
-    entryPhaseId: base?.entryPhaseId ?? extension.entryPhaseId
+    path: resolvedPath,
+    name,
+    factory,
+    manifest
   };
 }
-function adaptExtensionTool(input) {
-  const definition = input.definition;
-  return {
-    name: definition.name,
-    description: definition.description,
-    parameters: definition.parameters,
-    execute: async (args, _context, signal) => {
-      const result = await definition.execute(args, signal);
-      const content = JSON.parse(JSON.stringify(result.content));
-      return result.isError ? { ok: false, content, error: "Extension Tool failed." } : { ok: true, content };
+async function loadExtensions(paths, cwd) {
+  const extensions = [];
+  const errors = [];
+  const resolvedCwd = resolve4(cwd);
+  for (const path of paths) {
+    const resolvedPath = resolve4(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 };
 }
-function toLoopResult(result, toolCallId, toolName) {
+async function loadExtensionsFromPath(path) {
+  const resolvedPath = resolve4(path);
+  const info = await stat2(resolvedPath);
+  if (!info.isDirectory()) {
+    return loadExtensions([resolvedPath], dirname4(resolvedPath));
+  }
+  const entries = await resolveExtensionEntries(resolvedPath) ?? await discoverExtensionsInDir(resolvedPath);
+  return loadExtensions(entries, resolvedPath);
+}
+
+// src/runtime/resource-registry.ts
+import { stat as stat3, readdir as readdir4 } from "fs/promises";
+import { join as join4, resolve as resolve6 } from "path";
+
+// src/harness/skills.ts
+import { existsSync as existsSync3, statSync as statSync2 } from "fs";
+import { readdir as readdir3 } from "fs/promises";
+import { dirname as dirname5, join as join3, resolve as resolve5 } from "path";
+var SKILL_MARKER = "SKILL.md";
+function resolveSkillPath(input) {
+  const resolved = resolve5(input);
+  return existsSync3(resolved) && statSync2(resolved).isDirectory() ? join3(resolved, SKILL_MARKER) : resolved;
+}
+async function loadSkill(path) {
+  const resolved = resolveSkillPath(path);
+  let loaded;
+  try {
+    loaded = await loadMarkdown(resolved);
+  } catch (error) {
+    if (!(error instanceof FrontmatterParseError)) throw error;
+    warnResourceDiagnostics("skill", resolved, [`frontmatter could not be parsed: ${error.message}`]);
+    throw new ResourceMetadataError("parse_failed", error.message);
+  }
+  const { frontmatter, body } = loaded;
+  const metadata = frontmatter;
+  const id = inferResourceName(resolved, SKILL_MARKER);
+  const frontmatterName = typeof metadata.name === "string" ? metadata.name : void 0;
+  const name = frontmatterName || id;
+  const description = validateDescription(metadata.description);
+  const diagnostics = validateResourceId(id);
+  if (frontmatterName && frontmatterName !== id) {
+    diagnostics.push(...validateResourceName(frontmatterName, id));
+  }
+  diagnostics.push(...description.warnings);
+  warnResourceDiagnostics("skill", resolved, diagnostics);
+  if (description.missing) {
+    throw new ResourceMetadataError("invalid_metadata", "description is required");
+  }
   return {
-    toolCallId,
-    toolName,
-    ok: result.ok,
-    content: result.content,
-    ...!result.ok ? { error: result.error } : {}
+    name,
+    description: description.description,
+    filePath: resolved,
+    baseDir: dirname5(resolved),
+    content: body,
+    disableModelInvocation: metadata["disable-model-invocation"] === true
   };
 }
-function fromLoopResult(result) {
-  return result.ok ? { ok: true, content: result.content } : { ok: false, content: result.content, error: result.error ?? "Extension hook rejected the Tool result." };
+async function loadSkills(targetPath) {
+  const skillsDir = resolve5(targetPath);
+  if (existsSync3(skillsDir) && statSync2(skillsDir).isFile()) {
+    try {
+      return [await loadSkill(skillsDir)];
+    } catch (error) {
+      if (error instanceof ResourceMetadataError) return [];
+      throw error;
+    }
+  }
+  if (existsSync3(join3(skillsDir, SKILL_MARKER))) {
+    try {
+      return [await loadSkill(skillsDir)];
+    } catch (error) {
+      if (error instanceof ResourceMetadataError) return [];
+      throw error;
+    }
+  }
+  const entries = await readdir3(skillsDir, { withFileTypes: true });
+  const skills = [];
+  for (const entry of [...entries].sort((a, b) => a.name.localeCompare(b.name))) {
+    if (!entry.isDirectory()) continue;
+    const skillFile = join3(skillsDir, entry.name, SKILL_MARKER);
+    if (!existsSync3(skillFile)) continue;
+    try {
+      const skill = await loadSkill(skillFile);
+      skills.push(skill);
+    } catch (error) {
+      if (error instanceof ResourceMetadataError) continue;
+      console.warn(`Failed to load skill "${entry.name}":`, error);
+    }
+  }
+  return skills;
 }
 
-// src/runtime/transient-run-events.ts
-var MAX_BUFFERED_EVENTS = 128;
-var MAX_BUFFERED_TEXT = 64 * 1024;
-function deferred() {
-  let resolve6;
-  const promise = new Promise((done) => {
-    resolve6 = done;
-  });
-  return { promise, resolve: resolve6 };
-}
-var TransientRunEventSubscription = class {
-  queue = [];
-  wake = deferred();
-  version = 0;
-  stopped = false;
-  push(event) {
-    if (this.stopped) return;
-    const previous = this.queue.at(-1);
-    if (previous?.kind === "message_delta" && event.kind === "message_delta" && previous.executionId === event.executionId && previous.messageId === event.messageId && previous.offset + previous.text.length === event.offset) {
-      this.queue[this.queue.length - 1] = {
-        ...previous,
-        text: previous.text + event.text
+// src/runtime/resource-registry.ts
+var ResourceRegistryError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "ResourceRegistryError";
+    this.code = code;
+  }
+};
+var RESOURCE_NAME = /^[A-Za-z0-9][A-Za-z0-9._:-]*$/;
+var SOURCE_ID = /^[A-Za-z0-9][A-Za-z0-9._:-]*$/;
+var ResourceRegistry = class {
+  sources = /* @__PURE__ */ new Map();
+  /** Sources registered by the bootstrap boundary (currently Extensions). */
+  implicitSources = /* @__PURE__ */ new Map();
+  revisionSequence = 0;
+  async loadAgents(input) {
+    assertSourceId(input.sourceId);
+    const collected = await this.collect("agent", input);
+    return this.commit("agent", input.sourceId, collected.values, collected.skipped);
+  }
+  async loadSkills(input) {
+    assertSourceId(input.sourceId);
+    const collected = await this.collect("skill", input);
+    return this.commit("skill", input.sourceId, collected.values, collected.skipped);
+  }
+  async loadPhases(input) {
+    assertSourceId(input.sourceId);
+    const collected = await this.collect("phase", input);
+    return this.commit("phase", input.sourceId, collected.values, collected.skipped);
+  }
+  async loadTools(input) {
+    assertSourceId(input.sourceId);
+    return this.commit("tool", input.sourceId, input.values, []);
+  }
+  async unload(input) {
+    assertSourceId(input.sourceId);
+    if (this.hasImplicit(input.kind, input.sourceId)) {
+      throw new ResourceRegistryError(
+        "implicit_source_protected",
+        `Implicit ${input.kind} source "${input.sourceId}" is managed by Runtime bootstrap.`
+      );
+    }
+    const bySource = this.sources.get(input.kind);
+    const existing = bySource?.get(input.sourceId);
+    if (!existing) {
+      return {
+        revision: this.nextRevision(input.kind, input.sourceId),
+        registered: [],
+        skipped: []
       };
-    } else {
-      if (this.queue.length >= MAX_BUFFERED_EVENTS) this.queue.shift();
-      this.queue.push(event);
     }
-    this.trimText();
-    this.notify();
+    bySource.delete(input.sourceId);
+    return {
+      revision: this.nextRevision(input.kind, input.sourceId),
+      registered: [],
+      skipped: []
+    };
   }
-  shift() {
-    return this.queue.shift();
+  resolveView(view) {
+    const sourceIds = {
+      agents: this.withImplicit("agent", view.agents),
+      tools: this.withImplicit("tool", view.tools),
+      skills: this.withImplicit("skill", view.skills),
+      phases: this.withImplicit("phase", view.phases)
+    };
+    return {
+      agents: this.resolveKind("agent", sourceIds.agents),
+      tools: this.resolveKind("tool", sourceIds.tools),
+      skills: this.resolveKind("skill", sourceIds.skills),
+      phases: this.resolveKind("phase", sourceIds.phases),
+      revisions: {
+        agent: this.resolveRevisions("agent", sourceIds.agents),
+        tool: this.resolveRevisions("tool", sourceIds.tools),
+        skill: this.resolveRevisions("skill", sourceIds.skills),
+        phase: this.resolveRevisions("phase", sourceIds.phases)
+      },
+      refs: {
+        agent: this.resolveRefs("agent", sourceIds.agents),
+        tool: this.resolveRefs("tool", sourceIds.tools),
+        skill: this.resolveRefs("skill", sourceIds.skills),
+        phase: this.resolveRefs("phase", sourceIds.phases)
+      }
+    };
   }
-  clear(executionId) {
-    if (executionId === void 0) this.queue.length = 0;
-    else {
-      for (let index = this.queue.length - 1; index >= 0; index -= 1) {
-        if (this.queue[index]?.executionId === executionId) this.queue.splice(index, 1);
+  /** Mark one already-loaded source as implicit for every Resource View. */
+  markImplicit(kind, sourceId) {
+    assertSourceId(sourceId);
+    const entries = this.implicitSources.get(kind) ?? [];
+    if (!entries.includes(sourceId)) entries.push(sourceId);
+    this.implicitSources.set(kind, entries);
+  }
+  /** Bootstrap-only helper for replacing an implicit contribution source. */
+  async replaceImplicit(kind, sourceId, values) {
+    const result = await this.commit(kind, sourceId, values, []);
+    this.markImplicit(kind, sourceId);
+    return result;
+  }
+  hasImplicit(kind, sourceId) {
+    return this.implicitSources.get(kind)?.includes(sourceId) ?? false;
+  }
+  withImplicit(kind, sourceIds) {
+    const combined = [...sourceIds];
+    for (const sourceId of this.implicitSources.get(kind) ?? []) {
+      if (!combined.includes(sourceId)) combined.push(sourceId);
+    }
+    return combined;
+  }
+  async collect(kind, input) {
+    const hasDirectory = input.directory !== void 0;
+    const hasValues = input.values !== void 0;
+    if (!hasDirectory && !hasValues) {
+      throw new ResourceRegistryError(
+        "resource_input_missing",
+        `Resource source "${input.sourceId}" requires directory or values.`
+      );
+    }
+    const directoryValues = hasDirectory ? await loadDirectoryValues(kind, input.directory, input.sourceId) : { values: [], skipped: [] };
+    return {
+      values: [...directoryValues.values, ...input.values ?? []],
+      skipped: directoryValues.skipped
+    };
+  }
+  async commit(kind, sourceId, values, skipped) {
+    assertSourceId(sourceId);
+    const names = /* @__PURE__ */ new Set();
+    for (const value of values) {
+      assertNamedResource(value, kind, sourceId);
+      if (isImplicitCoreName(kind, value.name) && sourceId !== "rowan.core") {
+        throw new ResourceRegistryError(
+          "resource_collision",
+          `${capitalize(kind)} resource "${value.name}" is reserved by Rowan core.`
+        );
+      }
+      if (names.has(value.name)) {
+        throw new ResourceRegistryError(
+          "resource_collision",
+          `Duplicate ${capitalize(kind)} resource "${value.name}" in source "${sourceId}".`
+        );
       }
+      names.add(value.name);
+    }
+    const revision = this.nextRevision(kind, sourceId);
+    const record = {
+      kind,
+      sourceId,
+      revision,
+      values: Object.freeze([...values])
+    };
+    let bySource = this.sources.get(kind);
+    if (!bySource) {
+      bySource = /* @__PURE__ */ new Map();
+      this.sources.set(kind, bySource);
     }
-    this.notify();
+    bySource.set(sourceId, record);
+    return {
+      revision,
+      registered: values.map((value) => ({ kind, sourceId, name: value.name })),
+      skipped
+    };
   }
-  clearMessage(messageId) {
-    for (let index = this.queue.length - 1; index >= 0; index -= 1) {
-      const event = this.queue[index];
-      if (event?.kind === "message_delta" && event.messageId === messageId) this.queue.splice(index, 1);
+  resolveKind(kind, sourceIds) {
+    const names = /* @__PURE__ */ new Set();
+    const values = [];
+    for (const source of this.sourcesFor(kind, sourceIds)) {
+      for (const value of source.values) {
+        if (names.has(value.name)) {
+          throw new ResourceRegistryError(
+            "resource_collision",
+            `Duplicate ${capitalize(kind)} resource "${value.name}" in Resource View.`
+          );
+        }
+        names.add(value.name);
+        values.push(value);
+      }
     }
-    this.notify();
+    return values;
   }
-  clearTool(toolCallId) {
-    for (let index = this.queue.length - 1; index >= 0; index -= 1) {
-      const event = this.queue[index];
-      if (event?.kind === "tool_progress" && event.toolCallId === toolCallId) this.queue.splice(index, 1);
+  resolveRevisions(kind, sourceIds) {
+    return this.sourcesFor(kind, sourceIds).map(({ revision }) => revision);
+  }
+  resolveRefs(kind, sourceIds) {
+    const seenNames = /* @__PURE__ */ new Set();
+    const refs = [];
+    for (const source of this.sourcesFor(kind, sourceIds)) {
+      for (const value of source.values) {
+        if (seenNames.has(value.name)) throw new ResourceRegistryError("resource_collision", `Duplicate ${capitalize(kind)} resource "${value.name}" in Resource View.`);
+        seenNames.add(value.name);
+        refs.push({ kind, sourceId: source.sourceId, name: value.name });
+      }
     }
-    this.notify();
+    return refs;
+  }
+  sourcesFor(kind, sourceIds) {
+    const bySource = this.sources.get(kind);
+    const seen = /* @__PURE__ */ new Set();
+    const sources = [];
+    for (const sourceId of sourceIds) {
+      assertSourceId(sourceId);
+      if (seen.has(sourceId)) continue;
+      seen.add(sourceId);
+      const source = bySource?.get(sourceId);
+      if (!source) {
+        throw new ResourceRegistryError(
+          "unknown_resource_source",
+          `Unknown resource source "${sourceId}" for ${kind}.`
+        );
+      }
+      sources.push(source);
+    }
+    return sources;
   }
-  checkpoint() {
-    return this.version;
+  nextRevision(kind, sourceId) {
+    this.revisionSequence += 1;
+    return `${kind}:${sourceId}:${this.revisionSequence}`;
   }
-  changed(since) {
-    if (this.version !== since || this.queue.length > 0 || this.stopped) return Promise.resolve();
-    return this.wake.promise;
+};
+function assertSourceId(sourceId) {
+  if (typeof sourceId !== "string" || !SOURCE_ID.test(sourceId)) {
+    throw new ResourceRegistryError("invalid_source_id", `Invalid resource source "${String(sourceId)}".`);
   }
-  stop() {
-    if (this.stopped) return;
-    this.stopped = true;
-    this.queue.length = 0;
-    this.notify();
+}
+function assertNamedResource(value, kind, sourceId) {
+  if (!value || typeof value !== "object" || typeof value.name !== "string") {
+    throw new ResourceRegistryError("invalid_resource_name", `Invalid ${kind} resource in source "${sourceId}".`);
   }
-  notify() {
-    const wake = this.wake;
-    this.wake = deferred();
-    this.version += 1;
-    wake.resolve();
+  const name = value.name;
+  if (!RESOURCE_NAME.test(name)) {
+    throw new ResourceRegistryError("invalid_resource_name", `Invalid ${capitalize(kind)} resource name "${name}".`);
   }
-  trimText() {
-    let buffered = this.queue.reduce(
-      (length, event) => length + (event.kind === "message_delta" ? event.text.length : 0),
-      0
-    );
-    while (buffered > MAX_BUFFERED_TEXT) {
-      const index = this.queue.findIndex((event2) => event2.kind === "message_delta");
-      if (index < 0) return;
-      const event = this.queue[index];
-      const overflow = buffered - MAX_BUFFERED_TEXT;
-      if (event.text.length <= overflow) {
-        this.queue.splice(index, 1);
-        buffered -= event.text.length;
-      } else {
-        this.queue[index] = {
-          ...event,
-          offset: event.offset + overflow,
-          text: event.text.slice(overflow)
+}
+function capitalize(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+function isImplicitCoreName(kind, name) {
+  return kind === "tool" && name === "route" || kind === "phase" && name === "default";
+}
+async function loadDirectoryValues(kind, directory, sourceId) {
+  const root = resolve6(directory);
+  let rootInfo;
+  try {
+    rootInfo = await stat3(root);
+  } catch (error) {
+    if (isMissingPath(error)) {
+      return {
+        values: [],
+        skipped: [{ kind: "missing", sourceId, path: root, message: `Resource directory "${root}" does not exist.` }]
+      };
+    }
+    return {
+      values: [],
+      skipped: [{
+        kind: "invalid",
+        sourceId,
+        path: root,
+        message: `Resource directory "${root}" could not be read: ${error instanceof Error ? error.message : String(error)}`
+      }]
+    };
+  }
+  const marker = markerFor(kind);
+  const targets = [];
+  if (rootInfo.isFile()) {
+    targets.push(root);
+  } else if (rootInfo.isDirectory()) {
+    const markerAtRoot = join4(root, marker);
+    try {
+      const markerInfo = await stat3(markerAtRoot);
+      if (markerInfo.isFile()) targets.push(markerAtRoot);
+    } catch (error) {
+      if (!isMissingPath(error)) throw error;
+      let entries;
+      try {
+        entries = await readdir4(root, { withFileTypes: true });
+      } catch (error2) {
+        return {
+          values: [],
+          skipped: [{
+            kind: "invalid",
+            sourceId,
+            path: root,
+            message: `Resource directory "${root}" could not be read: ${error2 instanceof Error ? error2.message : String(error2)}`
+          }]
         };
-        buffered -= overflow;
+      }
+      for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+        if (!entry.isDirectory()) continue;
+        const target = join4(root, entry.name, marker);
+        try {
+          const targetInfo = await stat3(target);
+          if (targetInfo.isFile()) targets.push(target);
+        } catch (targetError) {
+          if (!isMissingPath(targetError)) throw targetError;
+        }
       }
     }
   }
-};
-var TransientRunEventHub = class {
-  subscriptions = /* @__PURE__ */ new Map();
-  subscribe(runId) {
-    const subscription = new TransientRunEventSubscription();
-    const current = this.subscriptions.get(runId) ?? /* @__PURE__ */ new Set();
-    current.add(subscription);
-    this.subscriptions.set(runId, current);
-    return subscription;
+  const values = [];
+  const skipped = [];
+  for (const target of targets) {
+    try {
+      const value = await loadDirectoryValue(kind, target);
+      values.push(value);
+    } catch (error) {
+      skipped.push({
+        kind: "invalid",
+        sourceId,
+        path: target,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
   }
-  unsubscribe(runId, subscription) {
-    subscription.stop();
-    const current = this.subscriptions.get(runId);
-    current?.delete(subscription);
-    if (current?.size === 0) this.subscriptions.delete(runId);
+  return { values, skipped };
+}
+async function loadDirectoryValue(kind, target) {
+  switch (kind) {
+    case "agent": {
+      let loaded;
+      try {
+        loaded = await loadMarkdown(target);
+      } catch (error) {
+        if (error instanceof FrontmatterParseError) {
+          throw new TypeError(`frontmatter could not be parsed: ${error.message}`);
+        }
+        throw error;
+      }
+      return normalizeAgentDefinition(
+        loaded.frontmatter,
+        loaded.body,
+        { fallbackName: inferResourceName(target, "AGENT.md") }
+      );
+    }
+    case "skill":
+      return await loadSkill(target);
+    case "phase":
+      return await loadPhase(target);
+    case "tool":
+      throw new ResourceRegistryError(
+        "resource_directory_not_supported",
+        "Tool sources accept inline values only."
+      );
   }
-  publish(event) {
-    for (const subscription of this.subscriptions.get(event.runId) ?? []) {
-      subscription.push(event);
+}
+function markerFor(kind) {
+  switch (kind) {
+    case "agent":
+      return "AGENT.md";
+    case "skill":
+      return "SKILL.md";
+    case "phase":
+      return "PHASE.md";
+    case "tool":
+      return "";
+  }
+}
+function isMissingPath(error) {
+  return Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT");
+}
+
+// src/runtime/extension-lifetime.ts
+var ExtensionLifetimeError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "ExtensionLifetimeError";
+    this.code = code;
+  }
+};
+var RuntimeExtensionLifetime = class {
+  runner;
+  frozen = false;
+  closed = false;
+  constructor(options = {}) {
+    this.runner = createExtensionRunner(options);
+  }
+  async activate(extensions) {
+    if (this.closed) throw new ExtensionLifetimeError("extensions_closed", "The Extension Runtime has been closed.");
+    if (this.frozen) throw new ExtensionLifetimeError("extensions_frozen", "Extensions are frozen until Runtime restart.");
+    const active = [];
+    const errors = [];
+    for (const extension of extensions) {
+      try {
+        await this.runner.loadExtensions([extension]);
+        active.push(extension.name);
+      } catch (error) {
+        errors.push({
+          path: extension.path,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
     }
+    this.runner.bind();
+    this.frozen = true;
+    return { active, errors };
   }
-  clear(runId, executionId) {
-    for (const subscription of this.subscriptions.get(runId) ?? []) {
-      subscription.clear(executionId);
+  tools() {
+    return this.runner.getAllRegisteredTools();
+  }
+  phases() {
+    return this.runner.getPhases();
+  }
+  get extensionRunner() {
+    return this.runner;
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    await this.runner.close();
+  }
+};
+var RuntimeBootstrapRegistry = class extends ResourceRegistry {
+  constructor(extensions = new RuntimeExtensionLifetime()) {
+    super();
+    this.extensions = extensions;
+  }
+  extensions;
+  extensionSourceId = "rowan.extensions";
+  /** Install Rowan-owned implicit resources before any host source is read. */
+  async ensureCoreResources() {
+    await this.replaceImplicit("tool", "rowan.core", [createRouteTool([])]);
+    await this.replaceImplicit("phase", "rowan.core", [createDefaultPhase()]);
+  }
+  async loadExtensions(input) {
+    const loaded = Array.isArray(input) ? { extensions: [...input], errors: [] } : (() => {
+      const descriptor = input;
+      return descriptor.directory ? loadExtensionsFromPath(descriptor.directory) : Promise.resolve({ extensions: [...descriptor.values ?? []], errors: [] });
+    })();
+    const normalized = await loaded;
+    const result = await this.extensions.activate(normalized.extensions);
+    await this.replaceImplicit("tool", this.extensionSourceId, this.extensions.tools().map(adaptExtensionTool2));
+    await this.replaceImplicit("phase", this.extensionSourceId, [...this.extensions.phases()]);
+    return {
+      ...result,
+      revision: `extensions:${Date.now()}`,
+      registered: result.active,
+      skipped: normalized.errors.map((error) => ({
+        kind: "invalid",
+        sourceId: "rowan.extensions",
+        path: error.path,
+        message: error.error
+      }))
+    };
+  }
+  get extensionRunner() {
+    return this.extensions.extensionRunner;
+  }
+  get extensionTools() {
+    return this.extensions.tools();
+  }
+  get extensionPhases() {
+    return this.extensions.phases();
+  }
+  async closeExtensions() {
+    await this.extensions.close();
+  }
+};
+function adaptExtensionTool2(input) {
+  const definition = input.definition;
+  return {
+    name: definition.name,
+    description: definition.description,
+    parameters: definition.parameters,
+    execute: async (args, context, signal) => {
+      const result = await definition.execute(args, signal);
+      const content = JSON.parse(JSON.stringify(result.content));
+      return result.isError ? { ok: false, content, error: "Extension Tool failed." } : { ok: true, content };
     }
+  };
+}
+
+// src/runtime/configuration-snapshot.ts
+function resolveConfigurationSnapshot(registry, input) {
+  const resolved = registry.resolveView(input.resourceView);
+  const base = resolved.agents.find(({ name }) => name === input.definition.name);
+  if (!base) {
+    throw new Error(`Agent Definition "${input.definition.name}" is not available in the Resource View.`);
+  }
+  const layer = input.definition.layer;
+  const definition = applyDefinitionLayer(base, layer);
+  const tools = selectNamedResources(resolved.tools, definition.tools, "Tool");
+  const skills = selectNamedResources(resolved.skills, definition.skills, "Skill");
+  const phases = resolvePhases(resolved.phases, definition.phases);
+  const contexts = selectNamedResources(input.contexts ?? [], base.context, "Context");
+  return {
+    identity: input.identity,
+    definition,
+    resources: {
+      tools,
+      skills,
+      ...phases ? { phases } : {},
+      revisions: resolved.revisions,
+      refs: {
+        agent: selectedRefs(resolved.refs.agent, [base.name]),
+        tool: selectedRefs(resolved.refs.tool, tools.map(({ name }) => name)),
+        skill: selectedRefs(resolved.refs.skill, skills.map(({ name }) => name)),
+        phase: selectedRefs(resolved.refs.phase, [...phases?.phases.keys() ?? []])
+      }
+    },
+    contexts,
+    resourceView: input.resourceView,
+    ...input.cwd === void 0 ? {} : { cwd: input.cwd },
+    ...input.maxAttempts === void 0 ? {} : { maxAttempts: input.maxAttempts },
+    ..."stream" in input && input.stream ? { model: layer?.model ?? input.model, stream: input.stream } : { model: layer?.model ?? input.model }
+  };
+}
+function materializeConfigurationSnapshot(snapshot) {
+  return {
+    identity: snapshot.identity,
+    definition: snapshot.definition,
+    resources: {
+      tools: snapshot.resources.tools,
+      skills: snapshot.resources.skills,
+      ...snapshot.resources.phases ? { phases: snapshot.resources.phases } : {},
+      ...snapshot.contexts.length > 0 ? { contexts: snapshot.contexts } : {},
+      resourceView: snapshot.resourceView,
+      resourceRefs: [
+        ...snapshot.resources.refs.agent,
+        ...snapshot.resources.refs.tool,
+        ...snapshot.resources.refs.skill,
+        ...snapshot.resources.refs.phase
+      ],
+      resourceRevisions: snapshot.resources.revisions
+    },
+    ...snapshot.cwd === void 0 ? {} : { cwd: snapshot.cwd },
+    ...snapshot.maxAttempts === void 0 ? {} : { maxAttempts: snapshot.maxAttempts },
+    ..."stream" in snapshot && snapshot.stream ? { model: snapshot.model, stream: snapshot.stream } : { model: snapshot.model }
+  };
+}
+function applyDefinitionLayer(base, layer) {
+  if (!layer) return { ...base };
+  return {
+    ...base,
+    ...layer.description === void 0 ? {} : { description: layer.description },
+    ...layer.content === void 0 ? {} : { content: layer.content },
+    ...layer.model === void 0 ? {} : { model: layer.model },
+    ...layer.tools === void 0 ? {} : { tools: intersectNames(base.tools, layer.tools, "Tool") },
+    ...layer.skills === void 0 ? {} : { skills: intersectNames(base.skills, layer.skills, "Skill") },
+    ...layer.phases === void 0 ? {} : { phases: intersectPhaseSelection(base.phases, layer.phases) }
+  };
+}
+function intersectNames(parent, layer, kind) {
+  if (parent === void 0) return [...layer];
+  const parentNames = new Set(parent);
+  for (const name of layer) {
+    if (!parentNames.has(name)) console.warn(`${kind} "${name}" is not available and will be skipped.`);
   }
-  clearMessage(runId, messageId) {
-    for (const subscription of this.subscriptions.get(runId) ?? []) subscription.clearMessage(messageId);
-  }
-  clearTool(runId, toolCallId) {
-    for (const subscription of this.subscriptions.get(runId) ?? []) subscription.clearTool(toolCallId);
+  return layer.filter((name) => parentNames.has(name));
+}
+function intersectPhaseSelection(parent, layer) {
+  if (!parent) return layer;
+  const parentNames = new Set(parent.phaseIds);
+  for (const name of layer.phaseIds) {
+    if (!parentNames.has(name)) console.warn(`Phase "${name}" is not available and will be skipped.`);
   }
-  close() {
-    for (const subscriptions of this.subscriptions.values()) {
-      for (const subscription of subscriptions) subscription.stop();
-    }
-    this.subscriptions.clear();
+  return {
+    entryPhaseId: layer.entryPhaseId,
+    phaseIds: layer.phaseIds.filter((name) => parentNames.has(name))
+  };
+}
+function resolvePhases(candidates, selection) {
+  const selected = selectNamedResources(candidates, selection?.phaseIds, "Phase");
+  if (selected.length === 0 && selection === void 0) return void 0;
+  const entryPhaseId = selection?.entryPhaseId ?? null;
+  if (entryPhaseId !== null && !selected.some(({ name }) => name === entryPhaseId)) {
+    console.warn(`Phase entry "${entryPhaseId}" is not available and will be skipped.`);
+    return { phases: new Map(selected.map((phase) => [phase.name, phase])), entryPhaseId: null };
   }
-};
+  return {
+    phases: new Map(selected.map((phase) => [phase.name, phase])),
+    entryPhaseId
+  };
+}
+function selectedRefs(refs, names) {
+  const selected = new Set(names);
+  return refs.filter(({ name }) => selected.has(name));
+}
 
 // src/runtime/durable-runtime.ts
 var DEFAULT_CONCURRENCY = 10;
@@ -4022,14 +5032,16 @@ var AgentRuntime = class _AgentRuntime {
   executions = /* @__PURE__ */ new Map();
   consumers = /* @__PURE__ */ new Map();
   transientEvents = new TransientRunEventHub();
+  resources;
   heartbeat;
   pumping = false;
   closed = false;
-  constructor(options, owned) {
+  constructor(options, owned, resources) {
     this.owned = owned;
     this.commands = new ConfigCommandService(owned, options.configs, String(owned.lease.token).split(":")[0]);
     this.storeIncarnation = String(owned.lease.token).split(":")[0];
     this.concurrency = options.concurrency ?? DEFAULT_CONCURRENCY;
+    this.resources = resources;
   }
   static async init(options) {
     if (!options.store) throw new TypeError("AgentRuntime requires a DurableStore");
@@ -4037,10 +5049,38 @@ var AgentRuntime = class _AgentRuntime {
     const concurrency = options.concurrency ?? DEFAULT_CONCURRENCY;
     if (!Number.isInteger(concurrency) || concurrency <= 0) throw new TypeError("concurrency must be a positive integer");
     const owned = await options.store.openOwner({ ownerId: createId("owner"), leaseMs: OWNER_LEASE_MS });
-    const runtime = new _AgentRuntime({ ...options, configs, concurrency }, owned);
-    runtime.startHeartbeat();
-    void runtime.pump();
-    return runtime;
+    const runtime = new _AgentRuntime({ ...options, configs, concurrency }, owned, new RuntimeBootstrapRegistry());
+    try {
+      await runtime.resources.ensureCoreResources();
+      await options.bootstrap?.(runtime.resources);
+      runtime.startHeartbeat();
+      void runtime.pump();
+      return runtime;
+    } catch (error) {
+      await runtime.resources.closeExtensions().catch(() => void 0);
+      await owned.sealAndReleaseOwner().catch(() => void 0);
+      throw error;
+    }
+  }
+  async loadAgents(input) {
+    this.assertOpen();
+    return this.resources.loadAgents(input);
+  }
+  async loadSkills(input) {
+    this.assertOpen();
+    return this.resources.loadSkills(input);
+  }
+  async loadPhases(input) {
+    this.assertOpen();
+    return this.resources.loadPhases(input);
+  }
+  async loadTools(input) {
+    this.assertOpen();
+    return this.resources.loadTools(input);
+  }
+  async unload(input) {
+    this.assertOpen();
+    return this.resources.unload(input);
   }
   async createAgent(config, options = {}) {
     this.assertOpen();
@@ -4100,6 +5140,7 @@ var AgentRuntime = class _AgentRuntime {
     this.executions.clear();
     this.transientEvents.close();
     for (const subscription of this.consumers.values()) subscription.controller.abort();
+    await this.resources.closeExtensions();
     await this.owned.sealAndReleaseOwner();
   }
   async snapshot(runId) {
@@ -4157,7 +5198,7 @@ var AgentRuntime = class _AgentRuntime {
     let executionRevision = run.revision;
     try {
       const agent = await this.requireAgent(run.agentId);
-      const token = run.pinnedConfigToken ?? agent.currentConfigToken;
+      let token = run.pinnedConfigToken ?? agent.currentConfigToken;
       if (!token) {
         await this.failQueued(run, "Agent has no Config Token.");
         return;
@@ -4177,13 +5218,28 @@ var AgentRuntime = class _AgentRuntime {
         await this.failQueued(run, resolution.reason);
         return;
       }
+      let resolvedConfig = resolution.config;
+      if (isAgentConfiguration(resolvedConfig)) {
+        try {
+          const snapshot = this.materializeConfig(resolvedConfig);
+          token = await this.commands.storeSnapshot({
+            agent,
+            config: snapshot,
+            operationId: `run-snapshot:${run.id}`
+          });
+          resolvedConfig = snapshot;
+        } catch (error) {
+          await this.failQueued(run, error instanceof Error ? error.message : "Configuration Snapshot failed.");
+          return;
+        }
+      }
       const executionId = createId("exec");
       claim = await this.owned.claimRun({ runId: run.id, expectedRevision: run.revision, executionId, configToken: token });
       executionRevision = claim.run.revision;
       const controller = new AbortController();
       this.executions.set(run.id, { controller, executionId });
-      const config = resolution.config;
-      const assembly = await assembleExtensions(config);
+      const config = resolvedConfig;
+      const assembly = assembleRegisteredExtensions(config, this.resources.extensionRunner);
       let toolQueue = Promise.resolve();
       const model = "stream" in config && config.stream ? config.model : { provider: config.model.provider, id: config.model.id };
       const stream = "stream" in config && config.stream ? config.stream : createModelStream(config.model);
@@ -4207,7 +5263,9 @@ var AgentRuntime = class _AgentRuntime {
         execution: {
           agentId: run.agentId,
           runId: run.id,
-          executionId: claim.execution.executionId
+          executionId: claim.execution.executionId,
+          ...agent.metadata === void 0 ? {} : { agentMetadata: agent.metadata },
+          ...run.metadata === void 0 ? {} : { runMetadata: run.metadata }
         },
         model,
         stream,
@@ -4236,6 +5294,7 @@ var AgentRuntime = class _AgentRuntime {
             const task = toolQueue.then(async () => {
               const execution = await this.executeToolBatch({
                 run,
+                agentMetadata: agent.metadata,
                 execution: claim.execution,
                 expectedRevision: executionRevision,
                 toolConfig: executionTools,
@@ -4252,6 +5311,7 @@ var AgentRuntime = class _AgentRuntime {
             const task = toolQueue.then(async () => {
               const execution = await this.executeToolBatch({
                 run,
+                agentMetadata: agent.metadata,
                 execution: claim.execution,
                 expectedRevision: executionRevision,
                 toolConfig: executionTools,
@@ -4346,6 +5406,8 @@ var AgentRuntime = class _AgentRuntime {
     const context = {
       agentId: input.run.agentId,
       runId: input.run.id,
+      ...input.agentMetadata === void 0 ? {} : { agentMetadata: input.agentMetadata },
+      ...input.run.metadata === void 0 ? {} : { runMetadata: input.run.metadata },
       toolCallId,
       reportProgress: (progress) => {
         const active = this.executions.get(input.run.id);
@@ -4489,6 +5551,10 @@ var AgentRuntime = class _AgentRuntime {
   assertOpen() {
     if (this.closed) throw new RuntimeError("runtime_closed", null);
   }
+  materializeConfig(config) {
+    if (!isAgentConfiguration(config)) return config;
+    return materializeConfigurationSnapshot(resolveConfigurationSnapshot(this.resources, config));
+  }
   startHeartbeat() {
     this.heartbeat = setInterval(() => {
       void this.owned.renewOwner(OWNER_LEASE_MS).catch(() => {
@@ -4552,10 +5618,10 @@ function boundaryFromSnapshot(snapshot) {
   }
 }
 function delay(ms) {
-  return new Promise((resolve6) => setTimeout(resolve6, ms));
+  return new Promise((resolve7) => setTimeout(resolve7, ms));
 }
 function normalizePhaseRegistry(registry) {
-  if (registry?.phases.has(DEFAULT_PHASE_ID)) {
+  if (registry?.phases.has(DEFAULT_PHASE_ID) && registry.phases.get(DEFAULT_PHASE_ID)?.filePath !== "") {
     throw new TypeError(`Configured Phase collides with Rowan built-in Phase "${DEFAULT_PHASE_ID}".`);
   }
   return {
@@ -4579,13 +5645,13 @@ function toJsonValue(value) {
   return value;
 }
 function deferred2() {
-  let resolve6;
+  let resolve7;
   let reject;
   const promise = new Promise((res, rej) => {
-    resolve6 = (value) => res(value);
+    resolve7 = (value) => res(value);
     reject = rej;
   });
-  return { promise, resolve: resolve6, reject };
+  return { promise, resolve: resolve7, reject };
 }
 
 // src/runtime/durable-store.ts
@@ -6036,236 +7102,6 @@ function assertOwnerInput(ownerId, leaseMs) {
   if (!Number.isFinite(leaseMs) || leaseMs <= 0) throw new TypeError("leaseMs must be a positive finite number");
 }
 
-// src/harness/skills.ts
-import { existsSync as existsSync2, statSync as statSync2 } from "fs";
-import { readdir as readdir2 } from "fs/promises";
-import { dirname as dirname4, join as join2, resolve as resolve4 } from "path";
-var SKILL_MARKER = "SKILL.md";
-function resolveSkillPath(input) {
-  const resolved = resolve4(input);
-  return existsSync2(resolved) && statSync2(resolved).isDirectory() ? join2(resolved, SKILL_MARKER) : resolved;
-}
-async function loadSkill(path) {
-  const resolved = resolveSkillPath(path);
-  let loaded;
-  try {
-    loaded = await loadMarkdown(resolved);
-  } catch (error) {
-    if (!(error instanceof FrontmatterParseError)) throw error;
-    warnResourceDiagnostics("skill", resolved, [`frontmatter could not be parsed: ${error.message}`]);
-    throw new ResourceMetadataError("parse_failed", error.message);
-  }
-  const { frontmatter, body } = loaded;
-  const metadata = frontmatter;
-  const id = inferResourceName(resolved, SKILL_MARKER);
-  const frontmatterName = typeof metadata.name === "string" ? metadata.name : void 0;
-  const name = frontmatterName || id;
-  const description = validateDescription(metadata.description);
-  const diagnostics = validateResourceId(id);
-  if (frontmatterName && frontmatterName !== id) {
-    diagnostics.push(...validateResourceName(frontmatterName, id));
-  }
-  diagnostics.push(...description.warnings);
-  warnResourceDiagnostics("skill", resolved, diagnostics);
-  if (description.missing) {
-    throw new ResourceMetadataError("invalid_metadata", "description is required");
-  }
-  return {
-    name,
-    description: description.description,
-    filePath: resolved,
-    baseDir: dirname4(resolved),
-    content: body,
-    disableModelInvocation: metadata["disable-model-invocation"] === true
-  };
-}
-async function loadSkills(targetPath) {
-  const skillsDir = resolve4(targetPath);
-  if (existsSync2(skillsDir) && statSync2(skillsDir).isFile()) {
-    try {
-      return [await loadSkill(skillsDir)];
-    } catch (error) {
-      if (error instanceof ResourceMetadataError) return [];
-      throw error;
-    }
-  }
-  if (existsSync2(join2(skillsDir, SKILL_MARKER))) {
-    try {
-      return [await loadSkill(skillsDir)];
-    } catch (error) {
-      if (error instanceof ResourceMetadataError) return [];
-      throw error;
-    }
-  }
-  const entries = await readdir2(skillsDir, { withFileTypes: true });
-  const skills = [];
-  for (const entry of [...entries].sort((a, b) => a.name.localeCompare(b.name))) {
-    if (!entry.isDirectory()) continue;
-    const skillFile = join2(skillsDir, entry.name, SKILL_MARKER);
-    if (!existsSync2(skillFile)) continue;
-    try {
-      const skill = await loadSkill(skillFile);
-      skills.push(skill);
-    } catch (error) {
-      if (error instanceof ResourceMetadataError) continue;
-      console.warn(`Failed to load skill "${entry.name}":`, error);
-    }
-  }
-  return skills;
-}
-
-// src/extensions/loader.ts
-import { existsSync as existsSync3, readFileSync } from "fs";
-import { readdir as readdir3, readFile as readFile3, stat as stat2 } from "fs/promises";
-import { fileURLToPath } from "url";
-import { basename as basename3, dirname as dirname5, extname as extname2, join as join3, resolve as resolve5 } from "path";
-import { createJiti } from "jiti";
-function isExtensionFile(path) {
-  const extension = extname2(path).toLowerCase();
-  return extension === ".ts" || extension === ".js";
-}
-function isSyntheticPath(path) {
-  return path.startsWith("<") && path.endsWith(">");
-}
-function readManifestSync(dir) {
-  const manifestPath = join3(dir, "package.json");
-  if (!existsSync3(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() {
-  const moduleUrl = import.meta.url;
-  if (!moduleUrl) {
-    return {};
-  }
-  const agentSourcePath = fileURLToPath(new URL("../index.ts", moduleUrl));
-  if (!existsSync3(agentSourcePath)) {
-    return {};
-  }
-  return { "@rowan-agent/agent": agentSourcePath };
-}
-var sharedJiti;
-function getJiti() {
-  sharedJiti ??= createJiti(import.meta.url || process.cwd(), {
-    fsCache: false,
-    moduleCache: false,
-    tryNative: 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 (!existsSync3(path)) {
-    return void 0;
-  }
-  const content = await readFile3(path, "utf8");
-  return JSON.parse(content);
-}
-async function resolveExtensionEntries(dir) {
-  const manifest = await readPackageManifest(join3(dir, "package.json"));
-  const declared = manifest?.rowan?.extensions;
-  if (declared && declared.length > 0) {
-    return declared.map((entry) => resolve5(dir, entry));
-  }
-  for (const name of ["index.ts", "index.js"]) {
-    const entry = join3(dir, name);
-    if (existsSync3(entry)) {
-      return [entry];
-    }
-  }
-  return void 0;
-}
-async function discoverExtensionsInDir(dir) {
-  const entries = await readdir3(dir, { withFileTypes: true }).catch((error) => {
-    if (error.code === "ENOENT") {
-      return [];
-    }
-    throw error;
-  });
-  const paths = [];
-  for (const entry of [...entries].sort((a, b) => a.name.localeCompare(b.name))) {
-    const entryPath = join3(dir, entry.name);
-    if ((entry.isFile() || entry.isSymbolicLink()) && isExtensionFile(entry.name)) {
-      paths.push(entryPath);
-      continue;
-    }
-    if (entry.isDirectory() || entry.isSymbolicLink()) {
-      const info = entry.isSymbolicLink() ? await stat2(entryPath).catch(() => void 0) : void 0;
-      if (entry.isDirectory() || info?.isDirectory()) {
-        const resolvedEntries = await resolveExtensionEntries(entryPath);
-        if (resolvedEntries) {
-          paths.push(...resolvedEntries);
-        }
-      }
-    }
-  }
-  return paths;
-}
-function loadExtensionFromFactory(factory, cwd, extensionPath = "<inline>") {
-  const resolvedCwd = resolve5(cwd);
-  const resolvedPath = isSyntheticPath(extensionPath) ? extensionPath : resolve5(resolvedCwd, extensionPath);
-  const name = isSyntheticPath(extensionPath) ? extensionPath : basename3(dirname5(resolvedPath)) || "unknown";
-  const manifestDir = isSyntheticPath(extensionPath) ? resolvedCwd : dirname5(resolvedPath);
-  const manifest = readManifestSync(manifestDir);
-  return {
-    path: resolvedPath,
-    name,
-    factory,
-    manifest
-  };
-}
-async function loadExtensions(paths, cwd) {
-  const extensions = [];
-  const errors = [];
-  const resolvedCwd = resolve5(cwd);
-  for (const path of paths) {
-    const resolvedPath = resolve5(resolvedCwd, path);
-    try {
-      const factory = await loadExtensionModule(resolvedPath);
-      if (!factory) {
-        errors.push({
-          path: resolvedPath,
-          error: `Extension does not export a valid factory function: ${path}`
-        });
-        continue;
-      }
-      extensions.push(loadExtensionFromFactory(factory, resolvedCwd, resolvedPath));
-    } catch (error) {
-      errors.push({
-        path: resolvedPath,
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  return { extensions, errors };
-}
-async function loadExtensionsFromPath(path) {
-  const resolvedPath = resolve5(path);
-  const info = await stat2(resolvedPath);
-  if (!info.isDirectory()) {
-    return loadExtensions([resolvedPath], dirname5(resolvedPath));
-  }
-  const entries = await resolveExtensionEntries(resolvedPath) ?? await discoverExtensionsInDir(resolvedPath);
-  return loadExtensions(entries, resolvedPath);
-}
-
 // src/index.ts
 function createCoreTools2(input = {}) {
   return createCoreTools(input).map((tool) => ({
@@ -6280,9 +7116,14 @@ function createCoreTools2(input = {}) {
 }
 export {
   AgentRuntime,
+  ExtensionLifetimeError,
   InMemoryConfigProvider,
   InMemoryStore,
+  ResourceRegistry,
+  ResourceRegistryError,
+  RuntimeBootstrapRegistry,
   RuntimeError,
+  RuntimeExtensionLifetime,
   SqliteStore,
   brandConfigToken,
   createCoreTools2 as createCoreTools,
@@ -6290,6 +7131,8 @@ export {
   loadExtensionsFromPath as loadExtensions,
   loadPhases,
   loadSkills,
+  materializeConfigurationSnapshot,
   parseAgentDefinition,
-  parseFrontmatter
+  parseFrontmatter,
+  resolveConfigurationSnapshot
 };