@rowan-agent/agent 0.8.4 → 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 },
@@ -1015,7 +1040,113 @@ function createExtensionAPI(hooks, options, runtime, eventBus) {
 import { existsSync, statSync } from "fs";
 import { readdir } from "fs/promises";
 import { dirname as dirname3, join, resolve as resolve3 } from "path";
+
+// src/harness/definitions.ts
 import { parseModelRef } from "@rowan-agent/models";
+function assertAgentDefinition(value) {
+  if (!isRecord(value)) throw new TypeError("config.definition is invalid");
+  requiredString(value.name, "definition.name");
+  requiredString(value.description, "definition.description");
+  requiredString(value.content, "definition.content");
+  optionalStringList(value.tools, "definition.tools");
+  optionalStringList(value.skills, "definition.skills");
+  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");
+    }
+  }
+}
+function parseAgentDefinition(raw) {
+  const { frontmatter, body } = parseFrontmatter(raw);
+  return normalizeAgentDefinition(frontmatter, body);
+}
+function normalizeAgentDefinition(frontmatter, content, options = {}) {
+  const name = frontmatter.name === void 0 && options.fallbackName ? options.fallbackName : requiredString(frontmatter.name, "name");
+  const description = requiredString(frontmatter.description, "description");
+  const normalizedContent = requiredString(content, "content");
+  const tools = optionalStringList(frontmatter.tools, "tools");
+  const skills = optionalStringList(frontmatter.skills, "skills");
+  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,
+    description,
+    content: normalizedContent,
+    ...tools ? { tools } : {},
+    ...skills ? { skills } : {},
+    ...phases ? { phases } : {},
+    ...context ? { context } : {},
+    ...model ? { model } : {}
+  };
+}
+function requiredString(value, field) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new TypeError(`${field} is required`);
+  }
+  return value.trim();
+}
+function optionalString(value, field) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new TypeError(`${field} must be a non-empty string`);
+  }
+  return value.trim();
+}
+function optionalStringList(value, field) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value)) throw new TypeError(`${field} must be an array of strings`);
+  const names = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, item] of value.entries()) {
+    if (typeof item !== "string" || item.trim() === "") {
+      throw new TypeError(`${field}[${index}] must be a non-empty string`);
+    }
+    const name = item.trim();
+    if (seen.has(name)) continue;
+    seen.add(name);
+    names.push(name);
+  }
+  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;
+  const model = parseModelRef(source);
+  if (!model || model.provider.trim() === "" || model.id.trim() === "") {
+    throw new TypeError("model must be a valid model reference");
+  }
+  return model;
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
 
 // src/harness/resource-validation.ts
 var MAX_RESOURCE_ID_LENGTH = 64;
@@ -1113,8 +1244,16 @@ async function loadPhase(targetPath) {
   const { frontmatter, body } = loaded;
   const metadata = frontmatter;
   const frontmatterName = typeof metadata.name === "string" ? metadata.name : void 0;
-  const name = frontmatterName || directoryName;
-  const description = validateDescription(metadata.description);
+  let definition;
+  try {
+    definition = normalizeAgentDefinition(metadata, body, { fallbackName: directoryName });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    warnResourceDiagnostics("phase", resolved, [message]);
+    throw new ResourceMetadataError("invalid_metadata", message);
+  }
+  const name = definition.name;
+  const description = validateDescription(definition.description);
   const diagnostics = validateResourceId(directoryName);
   if (frontmatterName && frontmatterName !== directoryName) {
     diagnostics.push(...validateResourceName(frontmatterName, directoryName));
@@ -1123,22 +1262,19 @@ async function loadPhase(targetPath) {
   diagnostics.push(...validateSkillReferences(metadata.skills));
   diagnostics.push(...validatePhaseTarget(metadata.target));
   warnResourceDiagnostics("phase", resolved, diagnostics);
-  if (description.missing) {
-    throw new ResourceMetadataError("invalid_metadata", "description is required");
-  }
   const baseDir = dirname3(resolved);
   const phase = {
     name,
     description: description.description,
-    tools: metadata.tools,
-    skills: metadata.skills,
+    tools: definition.tools ? [...definition.tools] : void 0,
+    skills: definition.skills ? [...definition.skills] : void 0,
     target: metadata.target,
     input: metadata.input,
     isolated: metadata.isolated,
     filePath: resolved,
     baseDir,
-    content: body,
-    model: parseModelRef(metadata.model)
+    content: definition.content,
+    model: definition.model
   };
   const codePath = await discoverPhaseCode(baseDir);
   if (codePath) {
@@ -1236,6 +1372,31 @@ function createDefaultPhase() {
   };
 }
 
+// src/harness/resource-selection.ts
+function selectNamedResources(candidates, names, kind) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    if (byName.has(candidate.name)) {
+      throw new TypeError(`Duplicate ${kind} candidate "${candidate.name}".`);
+    }
+    byName.set(candidate.name, candidate);
+  }
+  if (names === void 0) return [...candidates];
+  const selected = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of names) {
+    if (seen.has(name)) continue;
+    seen.add(name);
+    const candidate = byName.get(name);
+    if (!candidate) {
+      console.warn(`${kind} "${name}" is not available and will be skipped.`);
+      continue;
+    }
+    selected.push(candidate);
+  }
+  return selected;
+}
+
 // src/harness/context/system-prompt.ts
 function buildSystemPrompt(options) {
   const { systemPrompt, promptGuidelines, appendSystemPrompt, tools, skills } = options;
@@ -1578,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));
   }
@@ -1763,8 +1924,8 @@ async function runPhaseLoop(config, state, registry) {
     const messageManager = createMessageManager(config.context, config.onMessage, config.onMessageDelta);
     const toolExecutionManager = createToolExecutionManager();
     const execution = createPhaseExecution(config, state, phase, messageManager, toolExecutionManager, registry);
-    const phaseTools = phase.tools ? allTools.filter((t) => t.name === PhaseRouteTool || phase.tools.includes(t.name)) : allTools;
-    const phaseSkills = phase.skills ? config.context.skills.filter((s) => phase.skills.includes(s.name)) : config.context.skills;
+    const phaseTools = selectPhaseTools(allTools, phase.tools);
+    const phaseSkills = selectNamedResources(config.context.skills, phase.skills, "Skill");
     let phaseContext = {
       systemPrompt: config.context.systemPrompt,
       messages: messageManager.visible(),
@@ -2043,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;
       }
@@ -2254,8 +2415,8 @@ function createPhaseExecution(config, state, phase, messageManager, toolExecutio
 async function executeParallelPhase(config, state, registry, phase, payload, context, availablePhases, instanceId, groupId, index, count, sourcePhaseId) {
   const messages = [...context];
   const allTools = buildToolsWithRouting(config, availablePhases);
-  const phaseTools = phase.tools ? allTools.filter((t) => t.name === PhaseRouteTool || phase.tools.includes(t.name)) : allTools;
-  const phaseSkills = phase.skills ? config.context.skills.filter((s) => phase.skills.includes(s.name)) : config.context.skills;
+  const phaseTools = selectPhaseTools(allTools, phase.tools);
+  const phaseSkills = selectNamedResources(config.context.skills, phase.skills, "Skill");
   const systemPrompt = config.context.systemPrompt;
   const phaseContext = {
     systemPrompt,
@@ -2293,6 +2454,11 @@ async function executeParallelPhase(config, state, registry, phase, payload, con
   const resultPayload = decision?.decision[0]?.payload !== void 0 ? normalizePayload(decision.decision[0].payload) : output.payload;
   return { instanceId, phaseId: phase.name, payload: resultPayload, content: output.message };
 }
+function selectPhaseTools(candidates, names) {
+  const routing = candidates.filter(({ name }) => name === PhaseRouteTool);
+  const ordinary = candidates.filter(({ name }) => name !== PhaseRouteTool);
+  return [...selectNamedResources(ordinary, names, "Tool"), ...routing];
+}
 async function waitForBackgroundTasks(backgroundTasks) {
   const entries = Array.from(backgroundTasks.entries());
   const results = await Promise.allSettled(entries.map(([, t]) => t.promise));
@@ -2523,29 +2689,32 @@ function createMetrics() {
     startedAtMs: Date.now()
   };
 }
-function isRecord(value) {
+function isRecord2(value) {
   return value !== null && typeof value === "object" && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
 }
 function isCheckpointData(value) {
-  if (!isRecord(value) || typeof value.currentPhase !== "string" || !Number.isInteger(value.attempt)) return false;
+  if (!isRecord2(value) || typeof value.currentPhase !== "string" || !Number.isInteger(value.attempt)) return false;
   if (!isMetrics(value.metrics)) return false;
   if (value.continuation !== void 0 && !isContinuation(value.continuation)) return false;
   return true;
 }
 function isMetrics(value) {
-  if (!isRecord(value)) return false;
-  return Number.isInteger(value.iterations) && Array.isArray(value.phaseTransitions) && value.phaseTransitions.every((transition) => isRecord(transition) && typeof transition.from === "string" && typeof transition.to === "string" && typeof transition.ts === "string") && Number.isInteger(value.compactionCount) && Number.isInteger(value.retryCount) && typeof value.startedAt === "string" && Number.isFinite(value.startedAtMs) && (value.endedAt === void 0 || typeof value.endedAt === "string") && (value.durationMs === void 0 || Number.isFinite(value.durationMs));
+  if (!isRecord2(value)) return false;
+  return Number.isInteger(value.iterations) && Array.isArray(value.phaseTransitions) && value.phaseTransitions.every((transition) => isRecord2(transition) && typeof transition.from === "string" && typeof transition.to === "string" && typeof transition.ts === "string") && Number.isInteger(value.compactionCount) && Number.isInteger(value.retryCount) && typeof value.startedAt === "string" && Number.isFinite(value.startedAtMs) && (value.endedAt === void 0 || typeof value.endedAt === "string") && (value.durationMs === void 0 || Number.isFinite(value.durationMs));
 }
 function isContinuation(value) {
-  if (!isRecord(value) || typeof value.isContinuing !== "boolean" || !Array.isArray(value.previousResults)) return false;
+  if (!isRecord2(value) || typeof value.isContinuing !== "boolean" || !Array.isArray(value.previousResults)) return false;
   if (value.previousPayload !== void 0 && !isJsonValue(value.previousPayload)) return false;
-  return value.previousResults.every((result) => isRecord(result) && typeof result.name === "string" && (result.output === void 0 || isJsonValue(result.output))) && (value.pendingInstruction === void 0 || typeof value.pendingInstruction === "string") && (value.previousPhaseMessageId === void 0 || typeof value.previousPhaseMessageId === "string");
+  return value.previousResults.every((result) => isRecord2(result) && typeof result.name === "string" && (result.output === void 0 || isJsonValue(result.output))) && (value.pendingInstruction === void 0 || typeof value.pendingInstruction === "string") && (value.previousPhaseMessageId === void 0 || typeof value.previousPhaseMessageId === "string");
 }
 
 // src/runtime/contracts.ts
+function isAgentConfiguration(config) {
+  return !("resources" in config);
+}
 var METADATA_LIMIT = 64 * 1024;
 var IDENTITY_LIMIT = 256;
-function isRecord2(value) {
+function isRecord3(value) {
   if (value === null || typeof value !== "object") return false;
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
@@ -2554,7 +2723,7 @@ function hasOnlyKeys(value, allowed) {
   return Reflect.ownKeys(value).every((key) => typeof key === "string" && allowed.includes(key));
 }
 function isMetadata(value) {
-  if (!isRecord2(value) || !isJsonValue(value)) return false;
+  if (!isRecord3(value) || !isJsonValue(value)) return false;
   try {
     assertUtf8ByteLimit(canonicalJson(value), METADATA_LIMIT, "metadata");
     return true;
@@ -2566,23 +2735,23 @@ function assertMetadata(value, argument) {
   if (!isMetadata(value)) throw new TypeError(`${argument} must be a JSON-safe metadata object`);
 }
 function isText(value) {
-  return isRecord2(value) && value.type === "text" && typeof value.text === "string";
+  return isRecord3(value) && value.type === "text" && typeof value.text === "string";
 }
 function isImage(value) {
-  return isRecord2(value) && value.type === "image" && typeof value.data === "string" && typeof value.mimeType === "string";
+  return isRecord3(value) && value.type === "image" && typeof value.data === "string" && typeof value.mimeType === "string";
 }
 function isUserContent(value) {
   return typeof value === "string" || Array.isArray(value) && value.every((part) => isText(part) || isImage(part));
 }
 function normalizeUserInput(input) {
   const normalized = typeof input === "string" ? { content: input } : input;
-  if (!isRecord2(normalized) || !hasOnlyKeys(normalized, ["content", "metadata"]) || !isUserContent(normalized.content)) throw new TypeError("input must contain only valid UserContent");
+  if (!isRecord3(normalized) || !hasOnlyKeys(normalized, ["content", "metadata"]) || !isUserContent(normalized.content)) throw new TypeError("input must contain only valid UserContent");
   if (normalized.metadata !== void 0) assertMetadata(normalized.metadata, "input.metadata");
   assertJsonValue(normalized, "input");
   return normalized;
 }
 function isToolResult(value) {
-  if (!isRecord2(value) || !isJsonValue(value.content) || typeof value.ok !== "boolean") return false;
+  if (!isRecord3(value) || !isJsonValue(value.content) || typeof value.ok !== "boolean") return false;
   const expected = value.ok ? ["content", "ok"] : ["content", "error", "ok"];
   if (JSON.stringify(Object.keys(value).sort()) !== JSON.stringify(expected)) return false;
   return value.ok || typeof value.error === "string";
@@ -2590,8 +2759,44 @@ function isToolResult(value) {
 function assertAgentConfig(config) {
   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.context || typeof config.context.systemPrompt !== "string") throw new TypeError("config.context is invalid");
-  for (const tool of config.context.tools) projectToolDefinition(tool);
+  assertAgentDefinition(config.definition);
+  if (!config.resources || !Array.isArray(config.resources.tools) || !Array.isArray(config.resources.skills)) {
+    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");
@@ -2599,7 +2804,7 @@ function assertToolExecutionResult(value) {
 function projectToolDefinition(tool) {
   if (typeof tool.name !== "string" || tool.name.length === 0 || typeof tool.description !== "string") throw new TypeError("Tool definition is invalid");
   assertJsonValue(tool.parameters, "tool.parameters");
-  if (!isRecord2(tool.parameters)) throw new TypeError("tool.parameters must be a JSON object");
+  if (!isRecord3(tool.parameters)) throw new TypeError("tool.parameters must be a JSON object");
   return { name: tool.name, description: tool.description, parameters: JSON.parse(canonicalJson(tool.parameters)) };
 }
 
@@ -2666,7 +2871,7 @@ function brandConfigToken(raw) {
   return raw;
 }
 function validateConfigResolution(agentId, value) {
-  if (!isRecord3(value) || typeof value.kind !== "string") {
+  if (!isRecord4(value) || typeof value.kind !== "string") {
     throw new Error(`Config Provider returned an invalid resolution for Agent ${agentId}.`);
   }
   if (value.kind === "deferred") {
@@ -2679,18 +2884,97 @@ function validateConfigResolution(agentId, value) {
     };
   }
   if (value.kind === "unavailable" && typeof value.reason === "string") return { kind: "unavailable", reason: value.reason };
-  if (value.kind === "available" && isRecord3(value.config) && typeof value.config.identity === "string") {
+  if (value.kind === "available" && isRecord4(value.config) && typeof value.config.identity === "string") {
     return { kind: "available", config: value.config };
   }
   throw new Error(`Config Provider returned an invalid resolution for Agent ${agentId}.`);
 }
 function snapshotConfig(config) {
-  const context = Object.freeze({
-    ...config.context,
-    tools: Object.freeze([...config.context.tools]),
-    skills: Object.freeze([...config.context.skills])
+  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({
+        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.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)
+      })))
+    } : {}
   });
-  return Object.freeze({ ...config, context });
+}
+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");
@@ -2705,7 +2989,7 @@ function throwIfAborted(signal) {
   error.name = "AbortError";
   throw error;
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return value !== null && typeof value === "object";
 }
 
@@ -2736,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,
@@ -2758,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);
@@ -2785,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 });
@@ -3018,326 +3319,590 @@ 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 ?? "",
-          stderr: stderr ?? ""
-        });
-      }
-    );
-    if (options?.signal) {
-      options.signal.addEventListener(
-        "abort",
-        () => {
-          child.kill("SIGTERM");
-        },
-        { once: true }
-      );
-    }
+// 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 };
 }
-function applyProviderRegistration(config) {
-  if (config.streamSimple) {
-    registerApiProvider({ protocol: config.protocol, stream: config.streamSimple });
+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();
   }
-  for (const modelConfig of config.models) {
-    registerModel({
-      id: modelConfig.id,
-      name: modelConfig.name,
-      protocol: config.protocol,
-      provider: config.id,
-      baseUrl: config.baseUrl,
-      apiKey: config.apiKey,
-      reasoning: modelConfig.reasoning,
-      input: modelConfig.input,
-      cost: modelConfig.cost,
-      contextWindow: modelConfig.contextWindow,
-      maxTokens: modelConfig.maxTokens,
-      ...config.headers ? { headers: config.headers } : {},
-      ...config.timeoutMs !== void 0 ? { timeoutMs: config.timeoutMs } : {},
-      ...config.maxRetries !== void 0 ? { maxRetries: config.maxRetries } : {},
-      ...config.retryDelayMs !== void 0 ? { retryDelayMs: config.retryDelayMs } : {}
-    });
+  shift() {
+    return this.queue.shift();
   }
-}
-function applyProviderUnregistration(name) {
-  unregisterProviderModels(name);
-}
-var ExtensionRunner = class {
-  hooks;
-  runtime;
-  events;
-  cwd;
-  abortController = new AbortController();
-  _idle = true;
-  // Per-extension tracking
-  extensions = [];
-  // Phase management
-  phases = /* @__PURE__ */ new Map();
-  _phaseCache = null;
-  // Provider management
-  pendingProviders = [];
-  bound = false;
-  // Error listeners
-  errorListeners = /* @__PURE__ */ new Set();
-  /** Current agent context — set by the agent before each phase */
-  currentContext;
-  constructor(options) {
-    this.hooks = new HooksManager();
-    this.runtime = createExtensionRuntime();
-    this.events = createEventBus();
-    this.cwd = options?.cwd ?? process.cwd();
+  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();
   }
-  /** Whether the agent is currently idle (not streaming). */
-  get isIdle() {
-    return this._idle;
+  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();
   }
-  /** Set idle state — called by the agent loop. */
-  setIdle(idle) {
-    this._idle = idle;
+  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();
   }
-  /** Abort signal for the current runner instance. */
-  get signal() {
-    return this.abortController.signal;
+  checkpoint() {
+    return this.version;
   }
-  /** Abort the current runner operation. */
-  abort() {
-    this.abortController.abort();
+  changed(since) {
+    if (this.version !== since || this.queue.length > 0 || this.stopped) return Promise.resolve();
+    return this.wake.promise;
   }
-  // ---------------------------------------------------------------------------
-  // Error handling
-  // ---------------------------------------------------------------------------
-  /**
-   * Register an error listener.
-   * Returns an unsubscribe function.
-   */
-  onError(listener) {
-    this.errorListeners.add(listener);
-    return () => this.errorListeners.delete(listener);
+  stop() {
+    if (this.stopped) return;
+    this.stopped = true;
+    this.queue.length = 0;
+    this.notify();
   }
-  /**
-   * 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);
+  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;
       }
     }
   }
-  // ---------------------------------------------------------------------------
-  // Lifecycle: invalidate / assertActive
-  // ---------------------------------------------------------------------------
-  /**
-   * Mark all extension contexts as stale.
-   * After calling this, any captured ExtensionAPI or ExtensionContext will throw
-   * on use. Used during runtime replacement or reload.
-   */
-  invalidate(message) {
-    this.runtime.invalidate(message);
+};
+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;
   }
-  // ---------------------------------------------------------------------------
-  // 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);
+  unsubscribe(runId, subscription) {
+    subscription.stop();
+    const current = this.subscriptions.get(runId);
+    current?.delete(subscription);
+    if (current?.size === 0) this.subscriptions.delete(runId);
   }
-  // ---------------------------------------------------------------------------
-  // 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 extension = { path: ext.path, tools: /* @__PURE__ */ new Map() };
-        const api = this.createExtensionAPI(extension, ext.manifest);
-        await ext.factory(api);
-        this.extensions.push(extension);
-        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;
-      }
+  publish(event) {
+    for (const subscription of this.subscriptions.get(event.runId) ?? []) {
+      subscription.push(event);
     }
   }
-  // ---------------------------------------------------------------------------
-  // Tool management
-  // ---------------------------------------------------------------------------
-  /** Get all registered tools from all extensions. */
-  getAllRegisteredTools() {
-    const toolsByName = /* @__PURE__ */ new Map();
+  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 ?? ""
+        });
+      }
+    );
+    if (options?.signal) {
+      options.signal.addEventListener(
+        "abort",
+        () => {
+          child.kill("SIGTERM");
+        },
+        { once: true }
+      );
+    }
+  });
+}
+function applyProviderRegistration(config) {
+  if (config.streamSimple) {
+    registerApiProvider({ protocol: config.protocol, stream: config.streamSimple });
+  }
+  for (const modelConfig of config.models) {
+    registerModel({
+      id: modelConfig.id,
+      name: modelConfig.name,
+      protocol: config.protocol,
+      provider: config.id,
+      baseUrl: config.baseUrl,
+      apiKey: config.apiKey,
+      reasoning: modelConfig.reasoning,
+      input: modelConfig.input,
+      cost: modelConfig.cost,
+      contextWindow: modelConfig.contextWindow,
+      maxTokens: modelConfig.maxTokens,
+      ...config.headers ? { headers: config.headers } : {},
+      ...config.timeoutMs !== void 0 ? { timeoutMs: config.timeoutMs } : {},
+      ...config.maxRetries !== void 0 ? { maxRetries: config.maxRetries } : {},
+      ...config.retryDelayMs !== void 0 ? { retryDelayMs: config.retryDelayMs } : {}
+    });
+  }
+}
+function applyProviderUnregistration(name) {
+  unregisterProviderModels(name);
+}
+var ExtensionRunner = class {
+  hooks;
+  runtime;
+  events;
+  cwd;
+  abortController = new AbortController();
+  _idle = true;
+  // Per-extension tracking
+  extensions = [];
+  // Phase management
+  phases = /* @__PURE__ */ new Map();
+  _phaseCache = null;
+  // Provider management
+  pendingProviders = [];
+  bound = false;
+  // Error listeners
+  errorListeners = /* @__PURE__ */ new Set();
+  /** Current agent context — set by the agent before each phase */
+  currentContext;
+  constructor(options) {
+    this.hooks = new HooksManager();
+    this.runtime = createExtensionRuntime();
+    this.events = createEventBus();
+    this.cwd = options?.cwd ?? process.cwd();
+  }
+  /** Whether the agent is currently idle (not streaming). */
+  get isIdle() {
+    return this._idle;
+  }
+  /** Set idle state — called by the agent loop. */
+  setIdle(idle) {
+    this._idle = idle;
+  }
+  /** Abort signal for the current runner instance. */
+  get signal() {
+    return this.abortController.signal;
+  }
+  /** Abort the current runner operation. */
+  abort() {
+    this.abortController.abort();
+  }
+  // ---------------------------------------------------------------------------
+  // Error handling
+  // ---------------------------------------------------------------------------
+  /**
+   * Register an error listener.
+   * Returns an unsubscribe function.
+   */
+  onError(listener) {
+    this.errorListeners.add(listener);
+    return () => this.errorListeners.delete(listener);
+  }
+  /**
+   * Emit a structured extension error to all listeners.
+   */
+  emitError(error) {
+    for (const listener of this.errorListeners) {
+      try {
+        listener(error);
+      } catch (err) {
+        console.error("[extension-runner] Error listener failed:", err);
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Lifecycle: invalidate / assertActive
+  // ---------------------------------------------------------------------------
+  /**
+   * Mark all extension contexts as stale.
+   * After calling this, any captured ExtensionAPI or ExtensionContext will throw
+   * on use. Used during runtime replacement or reload.
+   */
+  invalidate(message) {
+    this.runtime.invalidate(message);
+    for (const extension of this.extensions) extension.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);
+  }
+  // ---------------------------------------------------------------------------
+  // 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) {
+      const extension = {
+        path: ext.path,
+        tools: /* @__PURE__ */ new Map(),
+        phases: /* @__PURE__ */ new Set(),
+        cleanup: [],
+        runtime: createExtensionRuntime()
+      };
+      try {
+        const api = this.createExtensionAPI(extension, ext.manifest);
+        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,
+          event: "load",
+          error: message,
+          stack: error instanceof Error ? error.stack : void 0
+        });
+        throw error;
+      }
+    }
+  }
+  /** 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
+  // ---------------------------------------------------------------------------
+  /** Get all registered tools from all extensions. */
+  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)) {
@@ -3345,498 +3910,1112 @@ var ExtensionRunner = class {
         }
       }
     }
-    return Array.from(toolsByName.values());
+    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;
+  }
+  // ---------------------------------------------------------------------------
+  // Phase management
+  // ---------------------------------------------------------------------------
+  getPhase(name) {
+    const reg = this.getRegisteredPhase(name);
+    if (!reg) return void 0;
+    return this.adaptToPhase(reg);
+  }
+  getPhases() {
+    return [...this.collectRegisteredPhases().values()].map(
+      (p) => this.adaptToPhase(p)
+    );
+  }
+  createPhaseRegistry(input = {}) {
+    const registered = this.collectRegisteredPhases();
+    const phases = /* @__PURE__ */ new Map();
+    for (const [name, reg] of registered) {
+      phases.set(name, this.adaptToPhase(reg));
+    }
+    const entryPhaseId = input.entryPhaseId ?? null;
+    return { phases, entryPhaseId };
+  }
+  /** Adapt an extension RegisteredPhase to the core Phase type. */
+  adaptToPhase(reg) {
+    const def = reg.definition;
+    return {
+      name: def.name,
+      description: def.description,
+      tools: def.tools,
+      skills: def.skills,
+      target: def.target,
+      input: def.input,
+      run: def.run,
+      filePath: "",
+      baseDir: "",
+      content: "",
+      ...def.model ? { model: parseModelRef2(def.model) } : {}
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Lifecycle
+  // ---------------------------------------------------------------------------
+  /**
+   * Bind the runner — flushes pending provider registrations and
+   * replaces runtime stubs with real implementations.
+   */
+  bind() {
+    if (this.bound) return;
+    this.bound = true;
+    this.flushPendingProviders();
+  }
+  // ---------------------------------------------------------------------------
+  // 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;
+  }
+  // ---------------------------------------------------------------------------
+  // Internal helpers
+  // ---------------------------------------------------------------------------
+  /**
+   * Create an ExtensionAPI for a specific extension.
+   * Registration methods write to the extension tracking object.
+   * Action methods delegate to the shared runtime.
+   */
+  createExtensionAPI(extension, manifest) {
+    const runner = this;
+    const extContext = {
+      get cwd() {
+        return runner.cwd;
+      },
+      get signal() {
+        return runner.abortController.signal;
+      },
+      isIdle() {
+        return runner._idle;
+      },
+      abort() {
+        runner.abortController.abort();
+      },
+      exec(command, args, options) {
+        return execCommand(command, args, runner.cwd, options);
+      },
+      manifest,
+      getSystemPrompt() {
+        return runner.currentContext?.systemPrompt ?? "";
+      },
+      setSystemPrompt(prompt) {
+        if (runner.currentContext) runner.currentContext.systemPrompt = prompt;
+      },
+      getMessages() {
+        return runner.currentContext?.messages ?? [];
+      },
+      addMessage(role, content) {
+        runner.currentContext?.messages.push({ role, content });
+      },
+      getAvailableTools() {
+        return (runner.currentContext?.tools ?? []).map((t) => ({ name: t.name, description: t.description }));
+      },
+      getAvailableSkills() {
+        return (runner.currentContext?.skills ?? []).map((s) => ({ name: s.name, description: s.description }));
+      },
+      getSkillContent(skillName) {
+        const skill = runner.currentContext?.skills.find((s) => s.name === skillName);
+        return skill?.content ?? "";
+      },
+      getAvailablePhases() {
+        return [...runner.currentContext?.phases?.phases.keys() ?? []];
+      },
+      getPhaseContent(phaseId) {
+        const phase = runner.currentContext?.phases?.phases.get(phaseId);
+        return phase?.content || phase?.description || "";
+      }
+    };
+    return createExtensionAPI(this.hooks, {
+      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,
+      trackCleanup: (cleanup) => extension.cleanup.push(cleanup)
+    }, extension.runtime, this.events);
+  }
+  registerTool(extension, tool) {
+    if (extension.tools.has(tool.name)) {
+      throw new Error(`Duplicate Tool name "${tool.name}" in extension ${extension.path}.`);
+    }
+    for (const ext of this.extensions) {
+      if (ext.tools.has(tool.name)) {
+        const message = `Duplicate Tool name "${tool.name}" from extensions ${ext.path} and ${extension.path}.`;
+        this.emitError({
+          extensionPath: extension.path,
+          event: "register_tool",
+          error: message
+        });
+        throw new Error(message);
+      }
+    }
+    const sourceInfo = createSourceInfo(extension.path);
+    extension.tools.set(tool.name, {
+      definition: tool,
+      sourceInfo
+    });
   }
-  /**
-   * 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;
+  registerPhase(extension, registration) {
+    if (typeof registration.name !== "string" || registration.name.length === 0) {
+      throw new Error(`Phase registration requires a "name" field.`);
     }
-    return void 0;
+    const name = registration.name;
+    const description = validateDescription(registration.description);
+    const errors = validateResourceId(name, "name");
+    if (description.missing) errors.push(...description.warnings);
+    errors.push(...validateSkillReferences(registration.skills));
+    errors.push(...validatePhaseTarget(registration.target));
+    if (errors.length > 0) {
+      throw new Error(`Invalid phase registration "${name}": ${errors.join("; ")}`);
+    }
+    if (description.warnings.length > 0) {
+      warnResourceDiagnostics("phase", `extension ${extension.path}`, description.warnings);
+    }
+    if (this.phases.has(name)) {
+      throw new Error(`Duplicate phase name: ${name}`);
+    }
+    const definition = {
+      name,
+      description: description.description,
+      run: registration.run,
+      ...registration.tools ? { tools: registration.tools.slice() } : {},
+      ...registration.skills ? { skills: registration.skills.slice() } : {},
+      ...registration.target ? { target: registration.target } : {},
+      ...registration.input ? { input: { ...registration.input } } : {},
+      ...registration.model ? { model: registration.model } : {}
+    };
+    const registered = {
+      definition,
+      source: { extensionPath: extension.path }
+    };
+    this.phases.set(name, registered);
+    extension.phases.add(name);
+    this._phaseCache = null;
   }
-  // ---------------------------------------------------------------------------
-  // Phase management
-  // ---------------------------------------------------------------------------
-  getPhase(name) {
-    const reg = this.getRegisteredPhase(name);
-    if (!reg) return void 0;
-    return this.adaptToPhase(reg);
+  registerProvider(config) {
+    if (this.bound) {
+      applyProviderRegistration(config);
+    } else {
+      this.pendingProviders.push({ kind: "register", config });
+    }
   }
-  getPhases() {
-    return [...this.collectRegisteredPhases().values()].map(
-      (p) => this.adaptToPhase(p)
-    );
+  unregisterProvider(name) {
+    if (this.bound) {
+      applyProviderUnregistration(name);
+    } else {
+      this.pendingProviders.push({ kind: "unregister", name });
+    }
   }
-  createPhaseRegistry(input = {}) {
-    const registered = this.collectRegisteredPhases();
-    const phases = /* @__PURE__ */ new Map();
-    for (const [name, reg] of registered) {
-      phases.set(name, this.adaptToPhase(reg));
+  flushPendingProviders() {
+    for (const action of this.pendingProviders) {
+      if (action.kind === "register") {
+        applyProviderRegistration(action.config);
+      } else {
+        applyProviderUnregistration(action.name);
+      }
     }
-    const entryPhaseId = input.entryPhaseId ?? null;
-    return { phases, entryPhaseId };
+    this.pendingProviders.length = 0;
   }
-  /** Adapt an extension RegisteredPhase to the core Phase type. */
-  adaptToPhase(reg) {
-    const def = reg.definition;
+  getRegisteredPhase(name) {
+    return this.collectRegisteredPhases().get(name);
+  }
+  collectRegisteredPhases() {
+    if (this._phaseCache) return this._phaseCache;
+    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/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;
+  }
+  try {
+    const content = readFileSync(manifestPath, "utf8");
+    const pkg = JSON.parse(content);
+    const rowan = pkg.rowan;
+    if (!rowan) return void 0;
     return {
-      name: def.name,
-      description: def.description,
-      tools: def.tools,
-      skills: def.skills,
-      target: def.target,
-      input: def.input,
-      run: def.run,
-      filePath: "",
-      baseDir: "",
-      content: "",
-      ...def.model ? { model: parseModelRef2(def.model) } : {}
+      entry: rowan.extensions?.[0],
+      phase: rowan.phase
     };
+  } catch {
+    return void 0;
   }
-  // ---------------------------------------------------------------------------
-  // 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();
+}
+function jitiAliases() {
+  const moduleUrl = import.meta.url;
+  if (!moduleUrl) {
+    return {};
+  }
+  const agentSourcePath = fileURLToPath(new URL("../index.ts", moduleUrl));
+  if (!existsSync2(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 (!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 {
+    path: resolvedPath,
+    name,
+    factory,
+    manifest
+  };
+}
+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 };
+}
+async function loadExtensionsFromPath(path) {
+  const resolvedPath = resolve4(path);
+  const info = await stat2(resolvedPath);
+  if (!info.isDirectory()) {
+    return loadExtensions([resolvedPath], dirname4(resolvedPath));
   }
-  // ---------------------------------------------------------------------------
-  // Unified hook emission
-  // ---------------------------------------------------------------------------
-  /**
-   * Generic emit — fire-and-forget for any event type.
-   */
-  async emit(eventType, event) {
-    await this.hooks.emit(eventType, event);
+  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);
   }
-  /**
-   * Unified hook emission — returns the first non-undefined result.
-   */
-  async emitHook(type, event) {
-    return this.hooks.emitFirst(type, event);
+  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));
   }
-  // ---------------------------------------------------------------------------
-  // Phase hooks (with inline processing)
-  // ---------------------------------------------------------------------------
-  async emitBeforePhase(phaseId, input) {
-    const result = await this.emitHook("before_phase", {
-      type: "before_phase",
-      phaseId,
-      input
-    });
-    return result ?? {};
+  diagnostics.push(...description.warnings);
+  warnResourceDiagnostics("skill", resolved, diagnostics);
+  if (description.missing) {
+    throw new ResourceMetadataError("invalid_metadata", "description is required");
   }
-  async emitAfterPhase(phaseId, output) {
-    const result = await this.emitHook("after_phase", {
-      type: "after_phase",
-      phaseId,
-      output
-    });
-    return result ?? {};
+  return {
+    name,
+    description: description.description,
+    filePath: resolved,
+    baseDir: dirname5(resolved),
+    content: body,
+    disableModelInvocation: metadata["disable-model-invocation"] === true
+  };
+}
+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;
+    }
   }
-  async emitBeforePrompt(phaseId, input) {
-    const result = await this.emitHook("before_prompt", {
-      type: "before_prompt",
-      phaseId,
-      input
-    });
-    return result?.input ?? input;
+  if (existsSync3(join3(skillsDir, SKILL_MARKER))) {
+    try {
+      return [await loadSkill(skillsDir)];
+    } catch (error) {
+      if (error instanceof ResourceMetadataError) return [];
+      throw error;
+    }
   }
-  async emitBeforeToolCall(tool, args) {
-    const result = await this.emitHook("before_tool_call", {
-      type: "before_tool_call",
-      tool,
-      args
-    });
-    return result ?? { allow: true };
+  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);
+    }
   }
-  async emitAfterToolCall(tool, result) {
-    const hookResult = await this.emitHook("after_tool_call", {
-      type: "after_tool_call",
-      tool,
-      result
-    });
-    return hookResult?.result ?? result;
+  return skills;
+}
+
+// src/runtime/resource-registry.ts
+var ResourceRegistryError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "ResourceRegistryError";
+    this.code = code;
   }
-  // ---------------------------------------------------------------------------
-  // Internal helpers
-  // ---------------------------------------------------------------------------
-  /**
-   * Create an ExtensionAPI for a specific extension.
-   * Registration methods write to the extension tracking object.
-   * Action methods delegate to the shared runtime.
-   */
-  createExtensionAPI(extension, manifest) {
-    const runner = this;
-    const extContext = {
-      get cwd() {
-        return runner.cwd;
-      },
-      get signal() {
-        return runner.abortController.signal;
-      },
-      isIdle() {
-        return runner._idle;
-      },
-      abort() {
-        runner.abortController.abort();
-      },
-      exec(command, args, options) {
-        return execCommand(command, args, runner.cwd, options);
-      },
-      manifest,
-      getSystemPrompt() {
-        return runner.currentContext?.systemPrompt ?? "";
-      },
-      setSystemPrompt(prompt) {
-        if (runner.currentContext) runner.currentContext.systemPrompt = prompt;
-      },
-      getMessages() {
-        return runner.currentContext?.messages ?? [];
-      },
-      addMessage(role, content) {
-        runner.currentContext?.messages.push({ role, content });
-      },
-      getAvailableTools() {
-        return (runner.currentContext?.tools ?? []).map((t) => ({ name: t.name, description: t.description }));
-      },
-      getAvailableSkills() {
-        return (runner.currentContext?.skills ?? []).map((s) => ({ name: s.name, description: s.description }));
-      },
-      getSkillContent(skillName) {
-        const skill = runner.currentContext?.skills.find((s) => s.name === skillName);
-        return skill?.content ?? "";
-      },
-      getAvailablePhases() {
-        return [...runner.currentContext?.phases?.phases.keys() ?? []];
+};
+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: []
+      };
+    }
+    bySource.delete(input.sourceId);
+    return {
+      revision: this.nextRevision(input.kind, input.sourceId),
+      registered: [],
+      skipped: []
+    };
+  }
+  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)
       },
-      getPhaseContent(phaseId) {
-        const phase = runner.currentContext?.phases?.phases.get(phaseId);
-        return phase?.content || phase?.description || "";
+      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)
       }
     };
-    return createExtensionAPI(this.hooks, {
-      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) {
-    if (extension.tools.has(tool.name)) {
-      throw new Error(`Duplicate Tool name "${tool.name}" in extension ${extension.path}.`);
-    }
-    for (const ext of this.extensions) {
-      if (ext.tools.has(tool.name)) {
-        const message = `Duplicate Tool name "${tool.name}" from extensions ${ext.path} and ${extension.path}.`;
-        this.emitError({
-          extensionPath: extension.path,
-          event: "register_tool",
-          error: message
-        });
-        throw new Error(message);
-      }
-    }
-    const sourceInfo = createSourceInfo(extension.path);
-    extension.tools.set(tool.name, {
-      definition: tool,
-      sourceInfo
-    });
+  /** 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;
   }
-  registerPhase(extension, registration) {
-    if (typeof registration.name !== "string" || registration.name.length === 0) {
-      throw new Error(`Phase registration requires a "name" field.`);
-    }
-    const name = registration.name;
-    const description = validateDescription(registration.description);
-    const errors = validateResourceId(name, "name");
-    if (description.missing) errors.push(...description.warnings);
-    errors.push(...validateSkillReferences(registration.skills));
-    errors.push(...validatePhaseTarget(registration.target));
-    if (errors.length > 0) {
-      throw new Error(`Invalid phase registration "${name}": ${errors.join("; ")}`);
-    }
-    if (description.warnings.length > 0) {
-      warnResourceDiagnostics("phase", `extension ${extension.path}`, description.warnings);
+  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);
     }
-    if (this.phases.has(name)) {
-      throw new Error(`Duplicate phase name: ${name}`);
+    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 definition = {
-      name,
-      description: description.description,
-      run: registration.run,
-      ...registration.tools ? { tools: registration.tools.slice() } : {},
-      ...registration.skills ? { skills: registration.skills.slice() } : {},
-      ...registration.target ? { target: registration.target } : {},
-      ...registration.input ? { input: { ...registration.input } } : {},
-      ...registration.model ? { model: registration.model } : {}
-    };
-    const registered = {
-      definition,
-      source: { extensionPath: extension.path }
+    const directoryValues = hasDirectory ? await loadDirectoryValues(kind, input.directory, input.sourceId) : { values: [], skipped: [] };
+    return {
+      values: [...directoryValues.values, ...input.values ?? []],
+      skipped: directoryValues.skipped
     };
-    this.phases.set(name, registered);
-    this._phaseCache = null;
   }
-  registerProvider(config) {
-    if (this.bound) {
-      applyProviderRegistration(config);
-    } else {
-      this.pendingProviders.push({ kind: "register", config });
+  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);
     }
+    bySource.set(sourceId, record);
+    return {
+      revision,
+      registered: values.map((value) => ({ kind, sourceId, name: value.name })),
+      skipped
+    };
   }
-  unregisterProvider(name) {
-    if (this.bound) {
-      applyProviderUnregistration(name);
-    } else {
-      this.pendingProviders.push({ kind: "unregister", name });
+  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);
+      }
     }
+    return values;
   }
-  flushPendingProviders() {
-    for (const action of this.pendingProviders) {
-      if (action.kind === "register") {
-        applyProviderRegistration(action.config);
-      } else {
-        applyProviderUnregistration(action.name);
+  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.pendingProviders.length = 0;
-  }
-  getRegisteredPhase(name) {
-    return this.collectRegisteredPhases().get(name);
+    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;
   }
-  collectRegisteredPhases() {
-    if (this._phaseCache) return this._phaseCache;
-    this._phaseCache = new Map(this.phases);
-    return this._phaseCache;
+  nextRevision(kind, sourceId) {
+    this.revisionSequence += 1;
+    return `${kind}:${sourceId}:${this.revisionSequence}`;
   }
 };
-function createExtensionRunner(options) {
-  return new ExtensionRunner(options);
-}
-
-// src/runtime/extensions.ts
-async function assembleExtensions(config) {
-  if (!config.extensions?.length) return { context: config.context };
-  const runner = createExtensionRunner({ cwd: config.cwd });
-  await runner.loadExtensions([...config.extensions]);
-  runner.bind();
-  const extensionTools = runner.getAllRegisteredTools().map(adaptExtensionTool);
-  const tools = [...config.context.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);
+function assertSourceId(sourceId) {
+  if (typeof sourceId !== "string" || !SOURCE_ID.test(sourceId)) {
+    throw new ResourceRegistryError("invalid_source_id", `Invalid resource source "${String(sourceId)}".`);
   }
-  const extensionPhases = runner.createPhaseRegistry({ entryPhaseId: null });
-  const phases = mergePhases(config.context.phases, extensionPhases);
-  return {
-    context: { ...config.context, tools, ...phases ? { phases } : {} },
-    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: (context) => {
-      runner.currentContext = context;
-    }
-  };
 }
-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);
+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}".`);
+  }
+  const name = value.name;
+  if (!RESOURCE_NAME.test(name)) {
+    throw new ResourceRegistryError("invalid_resource_name", `Invalid ${capitalize(kind)} resource name "${name}".`);
   }
-  return {
-    phases,
-    entryPhaseId: base?.entryPhaseId ?? extension.entryPhaseId
-  };
-}
-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 };
-    }
-  };
-}
-function toLoopResult(result, toolCallId, toolName) {
-  return {
-    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." };
+function capitalize(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
 }
-
-// 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 };
+function isImplicitCoreName(kind, name) {
+  return kind === "tool" && name === "route" || kind === "phase" && name === "default";
 }
-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
+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.` }]
       };
-    } else {
-      if (this.queue.length >= MAX_BUFFERED_EVENTS) this.queue.shift();
-      this.queue.push(event);
     }
-    this.trimText();
-    this.notify();
-  }
-  shift() {
-    return this.queue.shift();
+    return {
+      values: [],
+      skipped: [{
+        kind: "invalid",
+        sourceId,
+        path: root,
+        message: `Resource directory "${root}" could not be read: ${error instanceof Error ? error.message : String(error)}`
+      }]
+    };
   }
-  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);
+  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)}`
+          }]
+        };
+      }
+      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;
+        }
       }
     }
-    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);
+  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)
+      });
     }
-    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);
+  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") }
+      );
     }
-    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;
+    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."
+      );
   }
-  stop() {
-    if (this.stopped) return;
-    this.stopped = true;
-    this.queue.length = 0;
-    this.notify();
+}
+function markerFor(kind) {
+  switch (kind) {
+    case "agent":
+      return "AGENT.md";
+    case "skill":
+      return "SKILL.md";
+    case "phase":
+      return "PHASE.md";
+    case "tool":
+      return "";
   }
-  notify() {
-    const wake = this.wake;
-    this.wake = deferred();
-    this.version += 1;
-    wake.resolve();
+}
+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;
   }
-  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 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 };
+  }
+  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 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;
+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
+      }))
+    };
   }
-  unsubscribe(runId, subscription) {
-    subscription.stop();
-    const current = this.subscriptions.get(runId);
-    current?.delete(subscription);
-    if (current?.size === 0) this.subscriptions.delete(runId);
+  get extensionRunner() {
+    return this.extensions.extensionRunner;
   }
-  publish(event) {
-    for (const subscription of this.subscriptions.get(event.runId) ?? []) {
-      subscription.push(event);
-    }
+  get extensionTools() {
+    return this.extensions.tools();
   }
-  clear(runId, executionId) {
-    for (const subscription of this.subscriptions.get(runId) ?? []) {
-      subscription.clear(executionId);
+  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;
@@ -3853,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");
@@ -3868,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();
@@ -3931,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) {
@@ -3988,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;
@@ -4008,42 +5218,58 @@ 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 executionConfig = {
-        ...config,
-        context: assembly.context,
-        ...assembly.beforeToolCall ? { beforeToolCall: assembly.beforeToolCall } : {},
-        ...assembly.afterToolCall ? { afterToolCall: assembly.afterToolCall } : {}
-      };
-      executionRevision = claim.run.revision;
+      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);
       const executionContext = projectModelContext({
         context: {
-          ...executionConfig.context,
-          phases: normalizePhaseRegistry(executionConfig.context.phases)
+          ...assembly.context,
+          phases: normalizePhaseRegistry(assembly.context.phases)
         },
         messages: claim.history,
         agentId: run.agentId,
         runId: run.id
       });
+      const executionTools = {
+        tools: assembly.context.tools,
+        beforeToolCall: assembly.beforeToolCall ?? config.beforeToolCall,
+        afterToolCall: assembly.afterToolCall ?? config.afterToolCall
+      };
       const result = await executeOnce({
         canonicalMessages: executionContext.messages,
         context: executionContext,
         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,
-        maxAttempts: executionConfig.maxAttempts,
+        maxAttempts: config.maxAttempts,
         checkpoint: claim.run.checkpoint,
         signal: controller.signal,
         beforePhase: assembly.beforePhase,
@@ -4068,9 +5294,10 @@ var AgentRuntime = class _AgentRuntime {
             const task = toolQueue.then(async () => {
               const execution = await this.executeToolBatch({
                 run,
+                agentMetadata: agent.metadata,
                 execution: claim.execution,
                 expectedRevision: executionRevision,
-                config: executionConfig,
+                toolConfig: executionTools,
                 toolCalls: [toolCall],
                 signal: controller.signal
               });
@@ -4084,9 +5311,10 @@ var AgentRuntime = class _AgentRuntime {
             const task = toolQueue.then(async () => {
               const execution = await this.executeToolBatch({
                 run,
+                agentMetadata: agent.metadata,
                 execution: claim.execution,
                 expectedRevision: executionRevision,
-                config: executionConfig,
+                toolConfig: executionTools,
                 toolCalls,
                 signal: controller.signal
               });
@@ -4165,7 +5393,7 @@ var AgentRuntime = class _AgentRuntime {
     return { results, revision };
   }
   async executeReservedTool(input) {
-    const durableTool = input.config.context.tools.find((candidate) => candidate.name === input.toolCall.name);
+    const durableTool = input.toolConfig.tools.find((candidate) => candidate.name === input.toolCall.name);
     const providerToolCallId = input.toolCall.id;
     const toolCallId = input.tool.id;
     let revision = input.expectedRevision;
@@ -4178,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);
@@ -4200,8 +5430,8 @@ var AgentRuntime = class _AgentRuntime {
       }
     };
     try {
-      if (input.config.beforeToolCall) {
-        const decision = await input.config.beforeToolCall({ tool: durableTool, args: toJsonValue(input.toolCall.args), context, signal: input.signal });
+      if (input.toolConfig.beforeToolCall) {
+        const decision = await input.toolConfig.beforeToolCall({ tool: durableTool, args: toJsonValue(input.toolCall.args), context, signal: input.signal });
         if (!decision.allow) {
           const failed = await this.owned.commitToolResult({ runId: input.run.id, execution: input.execution, expectedRevision: revision, toolCallId, state: "failed", result: { ok: false, content: null, error: decision.reason } });
           return { result: protocolFailure(decision.reason), revision: failed.run.revision };
@@ -4218,7 +5448,7 @@ var AgentRuntime = class _AgentRuntime {
     try {
       let result = await durableTool.execute(toJsonValue(input.toolCall.args), context, input.signal);
       assertToolExecutionResult(result);
-      if (input.config.afterToolCall) result = await input.config.afterToolCall({ tool: durableTool, result, context, signal: input.signal });
+      if (input.toolConfig.afterToolCall) result = await input.toolConfig.afterToolCall({ tool: durableTool, result, context, signal: input.signal });
       assertToolExecutionResult(result);
       const committed = await this.owned.commitToolResult({ runId: input.run.id, execution: input.execution, expectedRevision: revision, toolCallId, state: result.ok ? "completed" : "failed", result });
       return {
@@ -4321,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(() => {
@@ -4384,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 {
@@ -4411,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
@@ -5868,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) => ({
@@ -6112,14 +7116,23 @@ function createCoreTools2(input = {}) {
 }
 export {
   AgentRuntime,
+  ExtensionLifetimeError,
   InMemoryConfigProvider,
   InMemoryStore,
+  ResourceRegistry,
+  ResourceRegistryError,
+  RuntimeBootstrapRegistry,
   RuntimeError,
+  RuntimeExtensionLifetime,
   SqliteStore,
   brandConfigToken,
   createCoreTools2 as createCoreTools,
   isRuntimeError,
   loadExtensionsFromPath as loadExtensions,
   loadPhases,
-  loadSkills
+  loadSkills,
+  materializeConfigurationSnapshot,
+  parseAgentDefinition,
+  parseFrontmatter,
+  resolveConfigurationSnapshot
 };