@rowan-agent/agent 0.9.24 → 0.10.0

package/README.md

@@ -9,7 +9,6 @@ identity, not a process-local Session object.
 ```ts
 import {
   AgentRuntime,
-  createCoreTools,
   InMemoryStore,
   loadPhases,
   loadSkills,
@@ -21,6 +20,21 @@ const runtime = await AgentRuntime.init({
   store: new InMemoryStore(),
 });
 
+await runtime.loadAgents({
+  sourceId: "workspace",
+  values: [{
+    name: "workspace-assistant",
+    description: "Assist with the current workspace.",
+    prompt: "You are helpful.",
+    contexts: ["workspace"],
+  }],
+});
+await runtime.loadSkills({ sourceId: "workspace", values: skills });
+await runtime.loadPhases({
+  sourceId: "workspace",
+  values: [...phases.phases.values()],
+});
+
 const agentId = await runtime.createAgent({
   identity: "example:v1", // Stable config snapshot identity, not the Agent ID
   model: {
@@ -30,21 +44,17 @@ const agentId = await runtime.createAgent({
     baseUrl: "https://api.openai.com/v1",
     apiKey: process.env.OPENAI_API_KEY!,
   },
-  definition: {
-    name: "workspace-assistant",
-    description: "Assist with the current workspace.",
-    prompt: "You are helpful.",
-    contexts: ["workspace"],
-  },
-  resources: {
-    tools: createCoreTools({ root: process.cwd() }),
-    skills,
-    contexts: [{
-      name: "workspace",
-      value: { root: process.cwd() },
-    }],
-    phases,
+  definition: { name: "workspace-assistant" },
+  resourceView: {
+    agents: ["workspace"],
+    tools: [],
+    skills: ["workspace"],
+    phases: ["workspace"],
   },
+  contexts: [{
+    name: "workspace",
+    value: { root: process.cwd() },
+  }],
 });
 
 const run = await runtime.start(agentId, "Summarize the workspace.", {
@@ -93,8 +103,8 @@ lifecycles, and Owner fencing.
 
 ## Tool lifecycle
 
-Tools are supplied as `AgentConfig.resources.tools`, selected by the
-Definition, and persist through:
+Tools are registered under a source, selected by the Definition, and persist
+through:
 
 `pending → running → completed | failed | indeterminate`
 
@@ -150,17 +160,13 @@ await runtime.loadAgents({
     prompt: "You are helpful.",
   }],
 });
-await runtime.loadTools({
-  sourceId: "workspace",
-  values: createCoreTools({ root: process.cwd() }),
-});
 
 const agentId = await runtime.createAgent({
   identity: "workspace:v1",
   definition: { name: "workspace-assistant" },
   resourceView: {
     agents: ["workspace"],
-    tools: ["workspace"],
+    tools: [],
     skills: [],
     phases: [],
   },
@@ -176,8 +182,11 @@ const agentId = await runtime.createAgent({
 
 Each `load*()` call replaces one source atomically; use `directory` or inline
 `values`. `resourceView` controls visibility, so same-name resources can live
-in isolated sources but collide when selected together. The built-in `route`
-Tool and `default` Phase are always available and cannot be overridden.
+in isolated sources but collide when selected together. The Runtime supplies the
+core `read`/`bash`/`edit`/`write`/`route` Tools itself, and its `rowan.core`
+source — like an Extension's `rowan.extensions` — is implicit in every view, so
+a Definition can select a built-in Phase without naming that source. Core names
+cannot be claimed by another source.
 
 Extensions are Runtime-global. Load them only during `AgentRuntime.init()` via
 `bootstrap`; after initialization they are frozen until the Runtime closes.
@@ -185,34 +194,22 @@ Definition name lists narrow the selected Tools, Skills, and Phases: omission
 inherits all candidates, `[]` selects none, and missing names are skipped. The
 same rule applies to `definition.contexts`.
 
-### Resources and Definition
+### Registration, Definition, and View
 
-`resources` and `definition` have different jobs:
+Registration, selection, and visibility have different jobs:
 
-- `resources` supplies the concrete candidates available to one Agent. Its
-  Tools contain executable `execute()` functions; Skills and Phases contain
-  their loaded content; Contexts contain JSON-safe values.
-- `definition` declares which candidates this Agent uses. `tools`, `skills`,
+- A **source** supplies resources. Tools carry their executable `execute()`,
+  Skills and Phases carry their loaded content, and a Definition carries its
+  prompt. Register them with `runtime.loadAgents/loadSkills/loadPhases/loadTools`.
+- The **Definition** declares what one Agent uses. `tools`, `skills`,
   `contexts`, and `phases` are name-based selectors; they cannot create a
-  resource that is absent from `resources`.
-
-For a single-process embedding, provide concrete resources directly and omit
-the selectors when the Agent should use everything:
-
-```ts
-const agentId = await runtime.createAgent({
-  identity: "workspace:v1",
-  definition: {
-    name: "workspace-assistant",
-    description: "Assist with the current workspace.",
-    prompt: "You are helpful.",
-  },
-  resources: { tools, skills, contexts, phases },
-  model,
-});
-```
+  resource that no selected source holds.
+- The **Resource View** decides which sources the Agent can see at all, by
+  stable source ID.
 
-Use selectors when several Agents share a candidate pool:
+Contexts are the exception: `contexts` and `additionalContexts` ship with the
+configuration request, because they carry host values rather than registered
+resources. Use selectors when several Agents share a candidate pool:
 
 ```ts
 definition: {
@@ -225,10 +222,6 @@ definition: {
 }
 ```
 
-For process-boundary persistence, use the Resource Registry form shown above:
-`resourceView` stores stable source IDs instead of executable resource
-closures, and the Runtime resolves those sources into an immutable
-Configuration Snapshot. This lets a restarted Runtime resolve the same
-resource revisions while keeping each Run pinned to the snapshot that created
-it. Direct `resources` are simpler for embedding; `resourceView` is the
-declarative form for shared, reloadable, and restart-resolvable resources.
+Each Run resolves its view once into an immutable Configuration Snapshot and
+stays pinned to it: replacing a source afterwards cannot change an active or
+input-waiting Run, and a restarted Runtime re-resolves the same source IDs.

package/dist/index.d.ts

@@ -1521,10 +1521,9 @@ type ConfigurationSnapshot = Readonly<{
 }>;
 /** Resolve one Definition request into one immutable, source-qualified snapshot. */
 declare function resolveConfigurationSnapshot(registry: ResourceRegistry, input: AgentConfiguration): ConfigurationSnapshot;
-/** Materialize the immutable resolver output at the legacy execution seam.
- * The conversion is intentionally one-way: callers cannot feed concrete
- * candidate bags back through the public configuration request. */
-declare function materializeConfigurationSnapshot(snapshot: ConfigurationSnapshot): AgentConfig;
+/** Whether one stored configuration is already a resolved snapshot. A snapshot
+ * is used as it stands; a request is resolved against the current sources. */
+declare function isConfigurationSnapshot(config: AgentConfiguration | ConfigurationSnapshot): config is ConfigurationSnapshot;
 
 type UserInput = string | Readonly<{
     content: UserContent;
@@ -1597,16 +1596,6 @@ type AfterToolCall = (input: Readonly<{
     context: ToolInvocationContext;
     signal: AbortSignal;
 }>) => ToolExecutionResult$1 | Promise<ToolExecutionResult$1>;
-type AgentResources = Readonly<{
-    tools: readonly Tool[];
-    skills: readonly Skill[];
-    phases?: PhaseRegistry;
-    contexts?: readonly ContextCandidate[];
-    /** Source-qualified snapshot metadata retained for restart/recovery checks. */
-    resourceView?: ResourceView;
-    resourceRefs?: readonly ResourceRef[];
-    resourceRevisions?: Readonly<Record<ResourceKind, readonly string[]>>;
-}>;
 type InvocationSource = "auto" | "implicit" | "external";
 type InvocationCatalogEntry = Readonly<{
     kind: "phase" | "skill";
@@ -1618,25 +1607,6 @@ type InvocationCatalogEntry = Readonly<{
     disableImplicitInvocation: boolean;
     filePath: string;
 }>;
-type AgentConfig = Readonly<{
-    identity: string;
-    definition: AgentDefinition;
-    resources: AgentResources;
-    /** Host-owned Contexts rendered in the System Prompt with the selected Contexts. */
-    additionalContexts?: readonly ContextCandidate[];
-    cwd?: string;
-    maxAttempts?: number;
-    beforeToolCall?: BeforeToolCall;
-    afterToolCall?: AfterToolCall;
-} & ({
-    model: ModelConfig;
-    stream?: never;
-} | {
-    model: ModelRef;
-    stream: StreamFn;
-})>;
-/** Definition-reference request accepted at the public Runtime seam. */
-type AgentConfigRequest = AgentConfig | AgentConfiguration;
 type AgentRecord = Readonly<{
     id: AgentId;
     metadata?: Metadata;
@@ -1816,7 +1786,7 @@ type RunBoundary = Readonly<{
 }>;
 type ConfigResolution = Readonly<{
     kind: "available";
-    config: AgentConfigRequest;
+    config: AgentConfiguration | ConfigurationSnapshot;
 } | {
     kind: "deferred";
     retryAfterMs?: number;
@@ -1834,7 +1804,7 @@ interface ConfigProvider {
     put(input: {
         agentId: AgentId;
         agentMetadata?: Metadata;
-        config: AgentConfigRequest;
+        config: AgentConfiguration | ConfigurationSnapshot;
         operationId: string;
         signal: AbortSignal;
     }): Promise<ConfigPutResult>;
@@ -2031,12 +2001,12 @@ interface AgentRuntime$1 {
         kind: ResourceKind;
         sourceId: string;
     }>): Promise<LoadResult>;
-    createAgent(config: AgentConfigRequest, options?: {
+    createAgent(config: AgentConfiguration, options?: {
         idempotencyKey?: string;
         metadata?: Metadata;
         historySeed?: HistorySeed;
     }): Promise<AgentId>;
-    updateAgentConfig(agentId: AgentId, config: AgentConfigRequest, options: {
+    updateAgentConfig(agentId: AgentId, config: AgentConfiguration, options: {
         idempotencyKey: string;
     }): Promise<void>;
     deleteAgent(input: AgentDeletionRequest): Promise<void>;
@@ -2122,12 +2092,12 @@ declare class AgentRuntime implements AgentRuntime$1 {
         kind: ResourceKind;
         sourceId: string;
     }>): Promise<LoadResult>;
-    createAgent(config: AgentConfigRequest, options?: {
+    createAgent(config: AgentConfiguration, options?: {
         idempotencyKey?: string;
         metadata?: Metadata;
         historySeed?: HistorySeed;
     }): Promise<AgentId>;
-    updateAgentConfig(agentId: AgentId, config: AgentConfigRequest, options: {
+    updateAgentConfig(agentId: AgentId, config: AgentConfiguration, options: {
         idempotencyKey: string;
     }): Promise<void>;
     deleteAgent(input: AgentDeletionRequest): Promise<void>;
@@ -2211,7 +2181,9 @@ declare class AgentRuntime implements AgentRuntime$1 {
         signal?: AbortSignal;
     }): Promise<RunBoundary>;
     private assertOpen;
-    private materializeConfig;
+    /** Resolve one stored configuration to the snapshot this execution uses. A
+     * stored snapshot is already source-qualified and is used as it stands. */
+    private resolveConfig;
     private startHeartbeat;
 }
 
@@ -2627,7 +2599,7 @@ declare class InMemoryConfigProvider implements ConfigProvider {
     put(input: {
         agentId: AgentId;
         agentMetadata?: Metadata;
-        config: AgentConfigRequest;
+        config: AgentConfiguration | ConfigurationSnapshot;
         operationId: string;
         signal: AbortSignal;
     }): Promise<ConfigPutResult>;
@@ -2810,4 +2782,4 @@ declare function parseFrontmatter<T = Record<string, unknown>>(raw: string): Fro
 
 declare function createCoreTools(input?: CoreToolContext): Tool[];
 
-export { type AfterToolCall, type AgentConfig, type AgentConfigRequest, type AgentConfiguration, type AgentDefinition, type AgentId, type AgentListCursor, type AgentRecord, type AgentResources, type AgentRun, AgentRuntime, type AgentRuntimeOptions, type AgentSummary, type AnyRuntimeError, type AssistantContent, type AssistantMessage, type BeforeToolCall, COMPACT_PHASE_ID, type ConfigProvider, type ConfigPutResult, type ConfigResolution, type ConfigToken, type ConfigurationSnapshot, type ContextCandidate, type ContextCompactionRecord, type ContextStatus, type CoreToolContext, DEFAULT_PHASE_ID, type DefinitionLayer, type DurableConsumer, type DurableRunEvent, type DurableStore, type DurableToolResult, type EventCursor, type EventId, type ExecutionCheckpoint, type ExecutionId, type ExecutionToken, type ExtensionAPI, type ExtensionActivationError, type ExtensionActivationResult, type ExtensionContribution, type ExtensionDisposer, type ExtensionFactory, type ExtensionFactoryResult, ExtensionLifetimeError, type ExtensionLifetimeErrorCode, type ExtensionLoadInput, type FrontmatterResult, type HistorySeed, type HookEvent, type HookEventType, type HookHandler, InMemoryConfigProvider, InMemoryStore, type InputRequest, type InputRequestId, type InputRequiredCommit, type InvocationCatalogEntry, type InvocationSource, type JsonObject, type JsonPrimitive, type JsonValue, type LoadExtensionsResult, type LoadInput, type LoadResult, type LoadedExtension, type Message, type MessageBase, type MessageCommitted, type MessageContent, type MessageDelta, type MessageId, type MessageRevised, type MessageRevisionResult, type Metadata, type OpaqueId, type Outcome, type OwnerLease, type OwnerToken, type Page, type Phase, type PhaseContext, type PhaseContribution, type PhaseExecution, type PhaseExecutionIdentity, type PhaseInput, type PhaseInteraction, PhaseInteractionBoundary, PhaseInteractionCancelledError, type PhaseInteractionDriver, type PhaseInteractionKind, type PhaseInteractionState, type PhaseInteractionStatus, type PhaseInvocation, type PhaseMessageManager, type PhaseOutput, type PhaseRegistry, type PhaseRegistrySelection, type PhaseSettingsBadge, type PhaseSettingsContext, type PhaseSettingsControl, type PhaseSettingsDefinition, type PhaseSettingsItem, type PhaseSettingsOption, type PhaseSettingsProvider, type PhaseSettingsSection, type PhaseState, type PhaseStatus, type PhaseStatusState, type ResolvedResourceView, type ResourceDiagnostic, type ResourceKind, type ResourceRef, ResourceRegistry, ResourceRegistryError, type ResourceRegistryErrorCode, type ResourceSourceId, type ResourceView, type RetentionResult, type RunBoundary, type RunClaim, type RunEvent, type RunFailure, type RunId, type RunListCursor, type RunRecord, type RunSnapshot, type RunState, type RunStateChanged, type RunSummary, RuntimeBootstrapRegistry, RuntimeError, type RuntimeErrorCode, type RuntimeErrorDetails, RuntimeExtensionLifetime, STOP_PHASE_ID, type Skill, SqliteStore, type TextContent, type ThinkingContent, type ThinkingDelta, type Tool, type ToolCallId, type ToolCallSnapshot, type ToolCallState, type ToolContribution, type ToolDefinition, type ToolExecutionResult$1 as ToolExecutionResult, type ToolInvocationContext, type ToolMessage, type ToolMessageContent, type ToolProgress, type ToolResultContent, type ToolStateChanged, type ToolUseContent, type UserContent, type UserInput, type UserMessage, brandConfigToken, createCompactPhase, createCorePhases, createCoreTools, createDefaultPhase, createStopPhase, isRuntimeError, loadExtensionsFromPath as loadExtensions, loadPhase, loadPhaseSettings, loadPhases, loadSkill, loadSkills, materializeConfigurationSnapshot, parseAgentDefinition, parseFrontmatter, resolveConfigurationSnapshot };
+export { type AfterToolCall, type AgentConfiguration, type AgentDefinition, type AgentId, type AgentListCursor, type AgentRecord, type AgentRun, AgentRuntime, type AgentRuntimeOptions, type AgentSummary, type AnyRuntimeError, type AssistantContent, type AssistantMessage, type BeforeToolCall, COMPACT_PHASE_ID, type ConfigProvider, type ConfigPutResult, type ConfigResolution, type ConfigToken, type ConfigurationSnapshot, type ContextCandidate, type ContextCompactionRecord, type ContextStatus, type CoreToolContext, DEFAULT_PHASE_ID, type DefinitionLayer, type DurableConsumer, type DurableRunEvent, type DurableStore, type DurableToolResult, type EventCursor, type EventId, type ExecutionCheckpoint, type ExecutionId, type ExecutionToken, type ExtensionAPI, type ExtensionActivationError, type ExtensionActivationResult, type ExtensionContribution, type ExtensionDisposer, type ExtensionFactory, type ExtensionFactoryResult, ExtensionLifetimeError, type ExtensionLifetimeErrorCode, type ExtensionLoadInput, type FrontmatterResult, type HistorySeed, type HookEvent, type HookEventType, type HookHandler, InMemoryConfigProvider, InMemoryStore, type InputRequest, type InputRequestId, type InputRequiredCommit, type InvocationCatalogEntry, type InvocationSource, type JsonObject, type JsonPrimitive, type JsonValue, type LoadExtensionsResult, type LoadInput, type LoadResult, type LoadedExtension, type Message, type MessageBase, type MessageCommitted, type MessageContent, type MessageDelta, type MessageId, type MessageRevised, type MessageRevisionResult, type Metadata, type OpaqueId, type Outcome, type OwnerLease, type OwnerToken, type Page, type Phase, type PhaseContext, type PhaseContribution, type PhaseExecution, type PhaseExecutionIdentity, type PhaseInput, type PhaseInteraction, PhaseInteractionBoundary, PhaseInteractionCancelledError, type PhaseInteractionDriver, type PhaseInteractionKind, type PhaseInteractionState, type PhaseInteractionStatus, type PhaseInvocation, type PhaseMessageManager, type PhaseOutput, type PhaseRegistry, type PhaseRegistrySelection, type PhaseSettingsBadge, type PhaseSettingsContext, type PhaseSettingsControl, type PhaseSettingsDefinition, type PhaseSettingsItem, type PhaseSettingsOption, type PhaseSettingsProvider, type PhaseSettingsSection, type PhaseState, type PhaseStatus, type PhaseStatusState, type ResolvedResourceView, type ResourceDiagnostic, type ResourceKind, type ResourceRef, ResourceRegistry, ResourceRegistryError, type ResourceRegistryErrorCode, type ResourceSourceId, type ResourceView, type RetentionResult, type RunBoundary, type RunClaim, type RunEvent, type RunFailure, type RunId, type RunListCursor, type RunRecord, type RunSnapshot, type RunState, type RunStateChanged, type RunSummary, RuntimeBootstrapRegistry, RuntimeError, type RuntimeErrorCode, type RuntimeErrorDetails, RuntimeExtensionLifetime, STOP_PHASE_ID, type Skill, SqliteStore, type TextContent, type ThinkingContent, type ThinkingDelta, type Tool, type ToolCallId, type ToolCallSnapshot, type ToolCallState, type ToolContribution, type ToolDefinition, type ToolExecutionResult$1 as ToolExecutionResult, type ToolInvocationContext, type ToolMessage, type ToolMessageContent, type ToolProgress, type ToolResultContent, type ToolStateChanged, type ToolUseContent, type UserContent, type UserInput, type UserMessage, brandConfigToken, createCompactPhase, createCorePhases, createCoreTools, createDefaultPhase, createStopPhase, isConfigurationSnapshot, isRuntimeError, loadExtensionsFromPath as loadExtensions, loadPhase, loadPhaseSettings, loadPhases, loadSkill, loadSkills, parseAgentDefinition, parseFrontmatter, resolveConfigurationSnapshot };

package/dist/index.js

@@ -3463,9 +3463,6 @@ function thinkingLevelFromMessages(messages) {
   }
   return void 0;
 }
-function isAgentConfiguration(config) {
-  return !("resources" in config);
-}
 var METADATA_LIMIT = 64 * 1024;
 var IDENTITY_LIMIT = 256;
 function isRecord3(value) {
@@ -3521,35 +3518,7 @@ function isToolResult(value) {
   if (JSON.stringify(Object.keys(value).sort()) !== JSON.stringify(expected)) return false;
   return value.ok || typeof value.error === "string";
 }
-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");
-  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`);
-  }
-  for (const context of config.additionalContexts ?? []) {
-    if (typeof context.name !== "string" || context.name.trim() === "") {
-      throw new TypeError("Additional Context candidate name must be non-empty");
-    }
-    assertJsonValue(context.value, `Additional Context candidate "${context.name}" value`);
-  }
-}
-function assertAgentConfigRequest(config) {
-  if (!isAgentConfiguration(config)) {
-    assertAgentConfig(config);
-    return;
-  }
+function assertAgentConfiguration(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.definition || typeof config.definition.name !== "string" || config.definition.name.trim() === "") {
@@ -3579,11 +3548,110 @@ function assertAgentConfigRequest(config) {
 function assertToolExecutionResult(value) {
   if (!isToolResult(value)) throw new TypeError("Tool result must be JSON-safe and contain no Runtime identity");
 }
-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 (!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)) };
+
+// src/runtime/configuration-snapshot.ts
+function resolveConfigurationSnapshot(registry, input) {
+  validateMaxAttempts(input.maxAttempts);
+  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 selectedContexts = selectNamedResources(input.contexts ?? [], base.contexts, "Context");
+  const additionalContexts = deduplicateContexts(input.additionalContexts ?? [], selectedContexts);
+  const definition = applyDefinitionLayer(base, layer);
+  const tools = selectNamedResources(resolved.tools, definition.tools, "Tool");
+  const skills = mergeSkills(
+    selectNamedResources(resolved.skills, definition.skills, "Skill"),
+    definition.bundledSkills
+  );
+  const phases = resolvePhases(resolved.phases, definition.phases);
+  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: selectedContexts,
+    additionalContexts,
+    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 isConfigurationSnapshot(config) {
+  return "resources" in config;
+}
+function applyDefinitionLayer(base, layer) {
+  if (!layer) return { ...base };
+  return {
+    ...base,
+    ...layer.description === void 0 ? {} : { description: layer.description },
+    ...layer.prompt === void 0 ? {} : { prompt: layer.prompt },
+    ...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 deduplicateContexts(additional, existing = []) {
+  const contexts = [];
+  const seen = new Set(existing.map(({ name }) => name));
+  for (const context of additional) {
+    if (seen.has(context.name)) continue;
+    seen.add(context.name);
+    contexts.push(context);
+  }
+  return contexts;
+}
+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.`);
+  }
+  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.`);
+  }
+  return {
+    entryPhaseId: layer.entryPhaseId,
+    phaseIds: layer.phaseIds.filter((name) => parentNames.has(name))
+  };
+}
+function resolvePhases(candidates, selection) {
+  const coreNames = /* @__PURE__ */ new Set([DEFAULT_PHASE_ID, STOP_PHASE_ID, COMPACT_PHASE_ID]);
+  const core = candidates.filter((phase) => phase.core || coreNames.has(phase.name));
+  const authored = candidates.filter((phase) => !coreNames.has(phase.name) && !phase.core);
+  const selected = [...core, ...selectNamedResources(authored, selection?.phaseIds, "Phase")];
+  const entryPhaseId = selection?.entryPhaseId ?? null;
+  if (entryPhaseId !== null && entryPhaseId !== DEFAULT_PHASE_ID && !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/idempotency.ts
@@ -3669,58 +3737,54 @@ function validateConfigResolution(agentId, value) {
 }
 function snapshotConfig(config) {
   validateMaxAttempts(config.maxAttempts);
-  if (isAgentConfiguration(config)) return snapshotConfiguration(config);
+  return isConfigurationSnapshot(config) ? snapshotConfigurationSnapshot(config) : snapshotConfiguration(config);
+}
+function snapshotConfigurationSnapshot(snapshot) {
   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.bundledSkills ? {
-      bundledSkills: Object.freeze(config.definition.bundledSkills.map((skill) => Object.freeze({ ...skill })))
+    ...snapshot.definition,
+    ...snapshot.definition.tools ? { tools: Object.freeze([...snapshot.definition.tools]) } : {},
+    ...snapshot.definition.skills ? { skills: Object.freeze([...snapshot.definition.skills]) } : {},
+    ...snapshot.definition.bundledSkills ? {
+      bundledSkills: Object.freeze(snapshot.definition.bundledSkills.map((skill) => Object.freeze({ ...skill })))
     } : {},
-    ...config.definition.phases ? {
+    ...snapshot.definition.phases ? {
       phases: Object.freeze({
-        entryPhaseId: config.definition.phases.entryPhaseId,
-        phaseIds: Object.freeze([...config.definition.phases.phaseIds])
+        entryPhaseId: snapshot.definition.phases.entryPhaseId,
+        phaseIds: Object.freeze([...snapshot.definition.phases.phaseIds])
       })
     } : {},
-    ...config.definition.contexts ? { contexts: Object.freeze([...config.definition.contexts]) } : {}
+    ...snapshot.definition.contexts ? { contexts: Object.freeze([...snapshot.definition.contexts]) } : {}
   });
   const resources = Object.freeze({
-    ...config.resources,
-    tools: Object.freeze([...config.resources.tools]),
-    skills: Object.freeze([...config.resources.skills]),
-    ...config.resources.phases ? { phases: snapshotPhaseRegistry(config.resources.phases) } : {},
-    ...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)
-      })))
-    } : {}
+    ...snapshot.resources,
+    tools: Object.freeze([...snapshot.resources.tools]),
+    skills: Object.freeze([...snapshot.resources.skills]),
+    ...snapshot.resources.phases ? { phases: snapshotPhaseRegistry(snapshot.resources.phases) } : {},
+    revisions: Object.freeze(Object.fromEntries(
+      Object.entries(snapshot.resources.revisions).map(([kind, revisions]) => [kind, Object.freeze([...revisions])])
+    )),
+    refs: Object.freeze(Object.fromEntries(
+      Object.entries(snapshot.resources.refs).map(([kind, refs]) => [kind, Object.freeze(refs.map((ref) => Object.freeze({ ...ref })))])
+    ))
   });
   return Object.freeze({
-    ...config,
+    ...snapshot,
     definition,
     resources,
-    ...config.additionalContexts ? {
-      additionalContexts: Object.freeze(config.additionalContexts.map((context) => Object.freeze({
-        name: context.name,
-        value: snapshotJsonValue(context.value)
-      })))
-    } : {}
+    contexts: Object.freeze(snapshot.contexts.map((context) => Object.freeze({
+      name: context.name,
+      value: snapshotJsonValue(context.value)
+    }))),
+    additionalContexts: Object.freeze(snapshot.additionalContexts.map((context) => Object.freeze({
+      name: context.name,
+      value: snapshotJsonValue(context.value)
+    }))),
+    resourceView: Object.freeze({
+      agents: Object.freeze([...snapshot.resourceView.agents]),
+      tools: Object.freeze([...snapshot.resourceView.tools]),
+      skills: Object.freeze([...snapshot.resourceView.skills]),
+      phases: Object.freeze([...snapshot.resourceView.phases])
+    })
   });
 }
 function snapshotPhaseRegistry(registry) {
@@ -3833,7 +3897,7 @@ var ConfigCommandService = class {
   configs;
   storeIncarnation;
   async createAgent(input) {
-    assertAgentConfigRequest(input.config);
+    assertAgentConfiguration(input.config);
     assertIdentity(input.config.identity);
     const reserved = await this.store.reserveAgent({
       idempotencyKey: input.idempotencyKey,
@@ -3856,7 +3920,7 @@ var ConfigCommandService = class {
     return reserved.id;
   }
   async updateAgentConfig(input) {
-    assertAgentConfigRequest(input.config);
+    assertAgentConfiguration(input.config);
     assertIdentity(input.config.identity);
     const agent = await this.findAgent(input.agentId);
     const operationId = this.operationId("update_agent_config", input.agentId, input.idempotencyKey);
@@ -3887,7 +3951,7 @@ var ConfigCommandService = class {
    * 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);
+    assertAgentConfiguration(input.config);
     const result = await this.put({
       agentId: input.agent.id,
       agentMetadata: input.agent.metadata,
@@ -4140,26 +4204,17 @@ function jsonText(value) {
 }
 
 // src/runtime/extensions.ts
-function assembleRegisteredExtensions(config, runner, options = {}) {
-  const extensionTools = runner.getAllRegisteredTools().map(adaptExtensionTool);
+function assembleRegisteredExtensions(snapshot, runner, options = {}) {
   const coreTools = createRuntimeCoreTools({
-    root: config.cwd,
+    root: snapshot.cwd,
     ...options.toolArchiveDir ? { archiveDir: options.toolArchiveDir } : {}
   });
   const coreNames = new Set(coreTools.map((tool) => tool.name));
   const tools = [
-    ...config.resources.tools.filter((tool) => !coreNames.has(tool.name)),
+    ...snapshot.resources.tools.filter((tool) => !coreNames.has(tool.name)),
     ...coreTools
   ];
-  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);
-  }
-  const extensionPhases = runner.createPhaseRegistry({ entryPhaseId: null });
-  const phases = mergePhases(config.resources.phases, extensionPhases);
-  const context = resolveDefinitionContext(config, { tools, phases });
+  const context = resolveDefinitionContext(snapshot, tools);
   return {
     context,
     beforePhase: (phaseId, input) => runner.emitBeforePhase(phaseId, input),
@@ -4180,83 +4235,41 @@ function assembleRegisteredExtensions(config, runner, options = {}) {
     }
   };
 }
-function resolveDefinitionContext(config, assembled = {}) {
-  const candidateTools = assembled.tools ?? config.resources.tools;
-  const coreTools = candidateTools.filter((tool) => tool.core);
-  const authoredTools = candidateTools.filter((tool) => !tool.core);
+function resolveDefinitionContext(snapshot, assembled) {
+  const coreTools = assembled.filter((tool) => tool.core);
+  const authoredTools = assembled.filter((tool) => !tool.core);
   const tools = [
-    ...selectNamedResources(authoredTools, config.definition.tools, "Tool"),
+    ...selectNamedResources(authoredTools, snapshot.definition.tools, "Tool"),
     ...coreTools
   ];
   const skills = mergeSkills(
-    selectNamedResources(config.resources.skills, config.definition.skills, "Skill"),
-    config.definition.bundledSkills
+    selectNamedResources(snapshot.resources.skills, snapshot.definition.skills, "Skill"),
+    snapshot.definition.bundledSkills
   );
   const contexts = [
-    ...selectNamedResources(
-      config.resources.contexts ?? [],
-      config.definition.contexts,
-      "Context"
-    ),
-    ...config.additionalContexts ?? []
+    ...selectNamedResources(snapshot.contexts, snapshot.definition.contexts, "Context"),
+    ...snapshot.additionalContexts
   ];
-  const candidateRegistry = assembled.phases ?? config.resources.phases;
-  const phaseCandidates = [...candidateRegistry?.phases.values() ?? []];
+  const phaseCandidates = [...snapshot.resources.phases?.phases.values() ?? []];
   const coreNames = /* @__PURE__ */ new Set([DEFAULT_PHASE_ID, STOP_PHASE_ID, COMPACT_PHASE_ID]);
   const selectedPhases = [
     ...phaseCandidates.filter((phase) => phase.core || coreNames.has(phase.name)),
     ...selectNamedResources(
       phaseCandidates.filter((phase) => !phase.core && !coreNames.has(phase.name)),
-      config.definition.phases?.phaseIds,
+      snapshot.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 requestedEntry = snapshot.definition.phases ? snapshot.definition.phases.entryPhaseId : snapshot.resources.phases?.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".`);
-  }
   return {
-    systemPrompt: [config.definition.prompt, buildContextDescription(contexts)].filter((section) => section.length > 0).join("\n\n"),
+    systemPrompt: [snapshot.definition.prompt, buildContextDescription(contexts)].filter((section) => section.length > 0).join("\n\n"),
     tools,
     skills,
     phases: { phases, entryPhaseId }
   };
 }
-function mergePhases(base, extension) {
-  const core = createCorePhases();
-  const coreNames = new Set(core.map(({ name }) => name));
-  const phases = new Map(core.map((phase) => [phase.name, phase]));
-  for (const [name, phase] of base?.phases ?? []) {
-    if (coreNames.has(name)) {
-      if (!phase.core) throw new TypeError(`Configured Phase collides with Rowan built-in Phase "${name}".`);
-      continue;
-    }
-    phases.set(name, phase);
-  }
-  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 ?? DEFAULT_PHASE_ID
-  };
-}
-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,
@@ -5677,7 +5690,7 @@ var RuntimeBootstrapRegistry = class extends ResourceRegistry {
     })();
     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("tool", this.extensionSourceId, this.extensions.tools().map(adaptExtensionTool));
     await this.replaceImplicit("phase", this.extensionSourceId, [...this.extensions.phases()]);
     return {
       ...result,
@@ -5704,7 +5717,7 @@ var RuntimeBootstrapRegistry = class extends ResourceRegistry {
     await this.extensions.close();
   }
 };
-function adaptExtensionTool2(input) {
+function adaptExtensionTool(input) {
   const definition = input.definition;
   return {
     name: definition.name,
@@ -5718,132 +5731,6 @@ function adaptExtensionTool2(input) {
   };
 }
 
-// src/runtime/configuration-snapshot.ts
-function resolveConfigurationSnapshot(registry, input) {
-  validateMaxAttempts(input.maxAttempts);
-  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 selectedContexts = selectNamedResources(input.contexts ?? [], base.contexts, "Context");
-  const additionalContexts = deduplicateContexts(input.additionalContexts ?? [], selectedContexts);
-  const definition = applyDefinitionLayer(base, layer);
-  const tools = selectNamedResources(resolved.tools, definition.tools, "Tool");
-  const skills = mergeSkills(
-    selectNamedResources(resolved.skills, definition.skills, "Skill"),
-    definition.bundledSkills
-  );
-  const phases = resolvePhases(resolved.phases, definition.phases);
-  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: selectedContexts,
-    additionalContexts,
-    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.additionalContexts.length > 0 ? { additionalContexts: snapshot.additionalContexts } : {},
-    ...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.prompt === void 0 ? {} : { prompt: layer.prompt },
-    ...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 deduplicateContexts(additional, existing = []) {
-  const contexts = [];
-  const seen = new Set(existing.map(({ name }) => name));
-  for (const context of additional) {
-    if (seen.has(context.name)) continue;
-    seen.add(context.name);
-    contexts.push(context);
-  }
-  return contexts;
-}
-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.`);
-  }
-  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.`);
-  }
-  return {
-    entryPhaseId: layer.entryPhaseId,
-    phaseIds: layer.phaseIds.filter((name) => parentNames.has(name))
-  };
-}
-function resolvePhases(candidates, selection) {
-  const coreNames = /* @__PURE__ */ new Set([DEFAULT_PHASE_ID, STOP_PHASE_ID, COMPACT_PHASE_ID]);
-  const core = candidates.filter((phase) => phase.core || coreNames.has(phase.name));
-  const authored = candidates.filter((phase) => !coreNames.has(phase.name) && !phase.core);
-  const selected = [...core, ...selectNamedResources(authored, selection?.phaseIds, "Phase")];
-  const entryPhaseId = selection?.entryPhaseId ?? null;
-  if (entryPhaseId !== null && entryPhaseId !== DEFAULT_PHASE_ID && !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;
 var DEFAULT_POLL_MS = 25;
@@ -6045,7 +5932,7 @@ var AgentRuntime = class _AgentRuntime {
         reason: resolution.kind === "deferred" ? "Configuration is deferred." : resolution.reason
       });
     }
-    const config = isAgentConfiguration(resolution.config) ? this.materializeConfig(resolution.config) : resolution.config;
+    const config = this.resolveConfig(resolution.config);
     const assembly = assembleRegisteredExtensions(config, this.resources.extensionRunner, {
       toolArchiveDir: this.archiveDirFor(agentId)
     });
@@ -6206,9 +6093,9 @@ var AgentRuntime = class _AgentRuntime {
         return;
       }
       let resolvedConfig = resolution.config;
-      if (isAgentConfiguration(resolvedConfig)) {
+      if (!isConfigurationSnapshot(resolvedConfig)) {
         try {
-          const snapshot = this.materializeConfig(resolvedConfig);
+          const snapshot = this.resolveConfig(resolvedConfig);
           token = await this.commands.storeSnapshot({
             agent,
             config: snapshot,
@@ -6220,7 +6107,7 @@ var AgentRuntime = class _AgentRuntime {
           return;
         }
       }
-      const config = resolvedConfig;
+      const config = this.resolveConfig(resolvedConfig);
       const controlKind = controlRunKind(run);
       if (!controlKind && !this.autoCompactionRuns.has(run.id)) {
         const contextWindow = await resolveContextWindowForConfig(config);
@@ -6283,8 +6170,8 @@ var AgentRuntime = class _AgentRuntime {
       let executionContext = buildExecutionContext(modelMessages);
       const executionTools = {
         tools: assembly.context.tools,
-        beforeToolCall: assembly.beforeToolCall ?? config.beforeToolCall,
-        afterToolCall: assembly.afterToolCall ?? config.afterToolCall
+        beforeToolCall: assembly.beforeToolCall,
+        afterToolCall: assembly.afterToolCall
       };
       const executeModel = (context) => executeOnce({
         canonicalMessages: context.messages,
@@ -6492,7 +6379,7 @@ var AgentRuntime = class _AgentRuntime {
     if (!agent.currentConfigToken) return 128e3;
     const resolution = await this.commands.resolve({ agent, token: agent.currentConfigToken });
     if (resolution.kind !== "available") return 128e3;
-    const config = isAgentConfiguration(resolution.config) ? this.materializeConfig(resolution.config) : resolution.config;
+    const config = this.resolveConfig(resolution.config);
     return resolveContextWindowForConfig(config);
   }
   async executeTool(input) {
@@ -6715,9 +6602,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));
+  /** Resolve one stored configuration to the snapshot this execution uses. A
+   * stored snapshot is already source-qualified and is used as it stands. */
+  resolveConfig(config) {
+    return isConfigurationSnapshot(config) ? config : resolveConfigurationSnapshot(this.resources, config);
   }
   startHeartbeat() {
     this.heartbeat = setInterval(() => {
@@ -9036,6 +8924,7 @@ export {
   createCoreTools2 as createCoreTools,
   createDefaultPhase,
   createStopPhase,
+  isConfigurationSnapshot,
   isRuntimeError,
   loadExtensionsFromPath as loadExtensions,
   loadPhase,
@@ -9043,7 +8932,6 @@ export {
   loadPhases,
   loadSkill,
   loadSkills,
-  materializeConfigurationSnapshot,
   parseAgentDefinition,
   parseFrontmatter,
   resolveConfigurationSnapshot

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rowan-agent/agent",
-  "version": "0.9.24",
+  "version": "0.10.0",
   "license": "MIT",
   "repository": {
     "type": "git",