@rowan-agent/agent 0.8.6 → 0.9.0

package/README.md

@@ -11,24 +11,39 @@ import {
   AgentRuntime,
   createCoreTools,
   InMemoryStore,
+  loadPhases,
+  loadSkills,
 } from "@rowan-agent/agent";
 
+const skills = await loadSkills("./.rowan/skills");
+const phases = await loadPhases("./.rowan/phases");
 const runtime = await AgentRuntime.init({
   store: new InMemoryStore(),
 });
 
 const agentId = await runtime.createAgent({
   identity: "example:v1", // Stable config snapshot identity, not the Agent ID
-  model: { provider: "openai", id: "gpt-4o" },
-  stream,
+  model: {
+    provider: "openai",
+    id: "gpt-4o",
+    protocol: "openai-responses",
+    baseUrl: "https://api.openai.com/v1",
+    apiKey: process.env.OPENAI_API_KEY!,
+  },
   definition: {
     name: "workspace-assistant",
     description: "Assist with the current workspace.",
-    content: "You are helpful.",
+    prompt: "You are helpful.",
+    contexts: ["workspace"],
   },
   resources: {
     tools: createCoreTools({ root: process.cwd() }),
-    skills: [],
+    skills,
+    contexts: [{
+      name: "workspace",
+      value: { root: process.cwd() },
+    }],
+    phases,
   },
 });
 
@@ -126,7 +141,7 @@ await runtime.loadAgents({
   values: [{
     name: "workspace-assistant",
     description: "Assist with the current workspace.",
-    content: "You are helpful.",
+    prompt: "You are helpful.",
   }],
 });
 await runtime.loadTools({
@@ -143,8 +158,13 @@ const agentId = await runtime.createAgent({
     skills: [],
     phases: [],
   },
-  model: { provider: "openai", id: "gpt-4o" },
-  stream,
+  model: {
+    provider: "openai",
+    id: "gpt-4o",
+    protocol: "openai-responses",
+    baseUrl: "https://api.openai.com/v1",
+    apiKey: process.env.OPENAI_API_KEY!,
+  },
 });
 ```
 
@@ -156,4 +176,53 @@ Tool and `default` Phase are always available and cannot be overridden.
 Extensions are Runtime-global. Load them only during `AgentRuntime.init()` via
 `bootstrap`; after initialization they are frozen until the Runtime closes.
 Definition name lists narrow the selected Tools, Skills, and Phases: omission
-inherits all candidates, `[]` selects none, and missing names are skipped.
+inherits all candidates, `[]` selects none, and missing names are skipped. The
+same rule applies to `definition.contexts`.
+
+### Resources and Definition
+
+`resources` and `definition` 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`,
+  `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,
+});
+```
+
+Use selectors when several Agents share a candidate pool:
+
+```ts
+definition: {
+  name: "read-only-assistant",
+  description: "Inspect the workspace without changing it.",
+  prompt: "You are helpful.",
+  tools: ["read"],
+  contexts: ["workspace"],
+  phases: { entryPhaseId: "review", phaseIds: ["review"] },
+}
+```
+
+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.

package/dist/index.d.ts

@@ -83,23 +83,6 @@ interface SourceInfo {
     baseDir?: string;
     displayName?: string;
 }
-/** Phase run function type for extensions */
-type PhaseRun = (context: PhaseContext, execution: PhaseExecution) => Promise<PhaseOutput | void>;
-/** Phase definition shape used by extensions */
-type PhaseDefinition = {
-    name: string;
-    description: string;
-    run?: PhaseRun;
-    tools?: string[];
-    skills?: string[];
-    target?: string;
-    input?: Record<string, string>;
-    model?: string;
-};
-type PhaseRegistration = Omit<PhaseDefinition, 'run'> & {
-    /** Optional execution override — takes over model invocation */
-    run?: PhaseRun;
-};
 /**
  * Tool definition for registering LLM-callable tools via `api.registerTool()`.
  *
@@ -214,12 +197,6 @@ interface LoadedExtension {
 interface ExtensionManifest {
     entry?: string;
     name?: string;
-    phase?: {
-        name?: string;
-        description?: string;
-        tools?: string[];
-        skills?: string[];
-    };
 }
 
 /**
@@ -438,8 +415,8 @@ interface ExtensionAPI {
     off<K extends HookEventType>(eventType: K, handler: HookHandler<K>): void;
     /** Register a custom LLM-callable tool. */
     registerTool(tool: ToolDefinition): void;
-    /** Register a custom phase. */
-    registerPhase(registration: PhaseRegistration): void;
+    /** Register a Phase directory bundle. */
+    registerPhase(path: string): Promise<void>;
     /** Register a model provider. */
     registerProvider(config: _rowan_agent_models.ProviderConfig): void;
     /** Unregister a model provider. */
@@ -552,8 +529,8 @@ interface Phase {
     description: string;
     /** Restricted tools (undefined = all tools available) */
     tools?: string[];
-    /** Restricted skills (undefined = all skills available) */
-    skills?: string[];
+    /** Skills bundled directly inside this phase directory. Inline phases may omit this (equivalent to []). */
+    skills?: Skill[];
     /** Forced next phase */
     target?: string;
     /** Expected input fields (key → description) */
@@ -627,11 +604,11 @@ type PhaseRegistrySelection = Readonly<{
 type AgentDefinition = Readonly<{
     name: string;
     description: string;
-    content: string;
+    prompt: string;
     tools?: readonly string[];
     skills?: readonly string[];
     phases?: PhaseRegistrySelection;
-    context?: readonly string[];
+    contexts?: readonly string[];
     model?: ModelRef;
 }>;
 /** Parse one Markdown definition using the same frontmatter vocabulary as Phase resources. */
@@ -1176,6 +1153,7 @@ declare class ExtensionRunner {
     private createExtensionAPI;
     private registerTool;
     private registerPhase;
+    private loadRegisteredPhase;
     private registerProvider;
     private unregisterProvider;
     private flushPendingProviders;
@@ -1233,7 +1211,7 @@ declare class RuntimeBootstrapRegistry extends ResourceRegistry {
 
 type DefinitionLayer = Readonly<{
     description?: string;
-    content?: string;
+    prompt?: string;
     model?: ModelRef;
     tools?: readonly string[];
     skills?: readonly string[];
@@ -2222,8 +2200,15 @@ declare class RuntimeError<Code extends RuntimeErrorCode = RuntimeErrorCode> ext
 }
 declare function isRuntimeError(value: unknown): value is AnyRuntimeError;
 
+declare function loadSkill(path: string): Promise<Skill>;
 declare function loadSkills(targetPath: string): Promise<Skill[]>;
 
+/**
+ * Load a single phase from a PHASE.md file or phase directory.
+ *
+ * If a directory is provided, the loader reads its PHASE.md.
+ */
+declare function loadPhase(targetPath: string): Promise<Phase>;
 /**
  * Load all phases from the target directory.
  *
@@ -2269,4 +2254,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, type ConfigProvider, type ConfigPutResult, type ConfigResolution, type ConfigToken, type ConfigurationSnapshot, type ContextCandidate, type CoreToolContext, 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 HookEvent, type HookEventType, type HookHandler, InMemoryConfigProvider, InMemoryStore, type InputRequest, type InputRequestId, type InputRequiredCommit, 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 Metadata, type OpaqueId, type Outcome, type OwnerLease, type OwnerToken, type Page, type Phase, type PhaseContext, type PhaseContribution, type PhaseExecutionIdentity, type PhaseInvocation, type PhaseOutput, type PhaseRegistry, type PhaseRegistrySelection, type PhaseState, type ResolvedResourceView, type ResourceDiagnostic, type ResourceKind, type ResourceRef, ResourceRegistry, ResourceRegistryError, type ResourceRegistryErrorCode, type ResourceSourceId, type ResourceView, 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, type Skill, SqliteStore, type TextContent, type ThinkingContent, type Tool, type ToolCallId, type ToolCallSnapshot, type ToolCallState, type ToolContribution, type ToolDefinition, type ToolExecutionResult, type ToolInvocationContext, type ToolMessage, type ToolMessageContent, type ToolProgress, type ToolResultContent, type ToolStateChanged, type ToolUseContent, type UserContent, type UserInput, type UserMessage, brandConfigToken, createCoreTools, isRuntimeError, loadExtensionsFromPath as loadExtensions, loadPhases, loadSkills, materializeConfigurationSnapshot, parseAgentDefinition, parseFrontmatter, resolveConfigurationSnapshot };
+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, type ConfigProvider, type ConfigPutResult, type ConfigResolution, type ConfigToken, type ConfigurationSnapshot, type ContextCandidate, type CoreToolContext, 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 HookEvent, type HookEventType, type HookHandler, InMemoryConfigProvider, InMemoryStore, type InputRequest, type InputRequestId, type InputRequiredCommit, 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 Metadata, type OpaqueId, type Outcome, type OwnerLease, type OwnerToken, type Page, type Phase, type PhaseContext, type PhaseContribution, type PhaseExecutionIdentity, type PhaseInvocation, type PhaseOutput, type PhaseRegistry, type PhaseRegistrySelection, type PhaseState, type ResolvedResourceView, type ResourceDiagnostic, type ResourceKind, type ResourceRef, ResourceRegistry, ResourceRegistryError, type ResourceRegistryErrorCode, type ResourceSourceId, type ResourceView, 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, type Skill, SqliteStore, type TextContent, type ThinkingContent, type Tool, type ToolCallId, type ToolCallSnapshot, type ToolCallState, type ToolContribution, type ToolDefinition, type ToolExecutionResult, type ToolInvocationContext, type ToolMessage, type ToolMessageContent, type ToolProgress, type ToolResultContent, type ToolStateChanged, type ToolUseContent, type UserContent, type UserInput, type UserMessage, brandConfigToken, createCoreTools, isRuntimeError, loadExtensionsFromPath as loadExtensions, loadPhase, loadPhases, loadSkill, loadSkills, materializeConfigurationSnapshot, parseAgentDefinition, parseFrontmatter, resolveConfigurationSnapshot };

package/dist/index.js

@@ -164,9 +164,6 @@ function buildPhaseEntry(p) {
   if (p.tools && p.tools.length > 0) {
     entry.available_tools = p.tools.join(", ");
   }
-  if (p.skills && p.skills.length > 0) {
-    entry.available_skills = p.skills.join(", ");
-  }
   if (p.input && Object.keys(p.input).length > 0) {
     entry.required_input = Object.entries(p.input).map(([key, desc]) => `- ${key}: ${desc}`).join("\n");
   }
@@ -985,9 +982,9 @@ function createExtensionAPI(hooks, options, runtime, eventBus) {
       assertActive();
       options?.registerTool?.(tool);
     },
-    registerPhase: (registration) => {
+    registerPhase: async (registration) => {
       assertActive();
-      options?.registerPhase?.(registration);
+      await options?.registerPhase?.(registration);
     },
     registerProvider: (config) => {
       assertActive();
@@ -1037,21 +1034,23 @@ function createExtensionAPI(hooks, options, runtime, eventBus) {
 }
 
 // src/harness/phases/loader.ts
-import { existsSync, statSync } from "fs";
-import { readdir } from "fs/promises";
-import { dirname as dirname3, join, resolve as resolve3 } from "path";
+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";
 
 // src/harness/definitions.ts
 import { parseModelRef } from "@rowan-agent/models";
 function assertAgentDefinition(value) {
   if (!isRecord(value)) throw new TypeError("config.definition is invalid");
+  if ("content" in value) throw new TypeError("definition.content is not supported; use definition.prompt");
+  if ("context" in value) throw new TypeError("definition.context is not supported; use definition.contexts");
   requiredString(value.name, "definition.name");
   requiredString(value.description, "definition.description");
-  requiredString(value.content, "definition.content");
+  requiredString(value.prompt, "definition.prompt");
   optionalStringList(value.tools, "definition.tools");
   optionalStringList(value.skills, "definition.skills");
   optionalPhaseRegistrySelection(value.phases, "definition.phases");
-  optionalStringList(value.context, "definition.context");
+  optionalStringList(value.contexts, "definition.contexts");
   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) {
@@ -1064,17 +1063,19 @@ function parseAgentDefinition(raw) {
   const { frontmatter, body } = parseFrontmatter(raw);
   return normalizeAgentDefinition(frontmatter, body);
 }
-function normalizeAgentDefinition(frontmatter, content, options = {}) {
+function normalizeAgentDefinition(frontmatter, prompt, options = {}) {
+  if (frontmatter.content !== void 0) throw new TypeError("content is not supported; use prompt and the document body");
+  if (frontmatter.context !== void 0) throw new TypeError("context is not supported; use contexts");
   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 normalizedPrompt = requiredString(prompt, "prompt");
   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");
+  const contexts = optionalStringList(frontmatter.contexts, "contexts");
   if (frontmatter.entryPhase !== void 0) {
     throw new TypeError("entryPhase is not supported; use phases.entryPhaseId");
   }
@@ -1082,11 +1083,11 @@ function normalizeAgentDefinition(frontmatter, content, options = {}) {
   return {
     name,
     description,
-    content: normalizedContent,
+    prompt: normalizedPrompt,
     ...tools ? { tools } : {},
     ...skills ? { skills } : {},
     ...phases ? { phases } : {},
-    ...context ? { context } : {},
+    ...contexts ? { contexts } : {},
     ...model ? { model } : {}
   };
 }
@@ -1122,9 +1123,8 @@ function optionalStringList(value, field) {
 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;
+  const entryPhaseId = value.entryPhaseId ?? null;
   if (entryPhaseId !== null && (typeof entryPhaseId !== "string" || entryPhaseId.trim() === "")) {
     throw new TypeError(`${field}.entryPhaseId must be a non-empty string or null`);
   }
@@ -1199,19 +1199,6 @@ function validateDescription(value) {
   }
   return { description: value, warnings: [], missing: false };
 }
-function validateSkillReferences(value) {
-  if (value === void 0) return [];
-  if (!Array.isArray(value)) return ["skills must be an array"];
-  const errors = [];
-  for (const [index, skillId] of value.entries()) {
-    if (typeof skillId !== "string") {
-      errors.push(`skills[${index}] must be a string`);
-      continue;
-    }
-    errors.push(...validateResourceId(skillId, `skills[${index}]`));
-  }
-  return errors;
-}
 function validatePhaseTarget(value) {
   if (value === void 0) return [];
   if (typeof value !== "string") return ["target must be a string"];
@@ -1224,11 +1211,91 @@ function warnResourceDiagnostics(kind, filePath, diagnostics) {
   }
 }
 
+// src/harness/skills.ts
+import { existsSync, statSync } from "fs";
+import { readdir } from "fs/promises";
+import { dirname as dirname3, join, resolve as resolve3 } from "path";
+var SKILL_MARKER = "SKILL.md";
+function resolveSkillPath(input) {
+  const resolved = resolve3(input);
+  return existsSync(resolved) && statSync(resolved).isDirectory() ? join(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: dirname3(resolved),
+    content: body,
+    disableModelInvocation: metadata["disable-model-invocation"] === true
+  };
+}
+async function loadSkills(targetPath) {
+  const skillsDir = resolve3(targetPath);
+  if (existsSync(skillsDir) && statSync(skillsDir).isFile()) {
+    try {
+      return [await loadSkill(skillsDir)];
+    } catch (error) {
+      if (error instanceof ResourceMetadataError) return [];
+      throw error;
+    }
+  }
+  if (existsSync(join(skillsDir, SKILL_MARKER))) {
+    try {
+      return [await loadSkill(skillsDir)];
+    } catch (error) {
+      if (error instanceof ResourceMetadataError) return [];
+      throw error;
+    }
+  }
+  const entries = await readdir(skillsDir, { withFileTypes: true });
+  const skills = [];
+  for (const entry of [...entries].sort((a, b) => a.name.localeCompare(b.name))) {
+    if (!entry.isDirectory()) continue;
+    const skillFile = join(skillsDir, entry.name, SKILL_MARKER);
+    if (!existsSync(skillFile)) continue;
+    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/harness/phases/loader.ts
 var PHASE_MARKER = "PHASE.md";
+var SKILL_MARKER2 = "SKILL.md";
+var RESOURCE_MARKERS = /* @__PURE__ */ new Set([PHASE_MARKER, SKILL_MARKER2]);
 function resolvePhasePath(input) {
-  const resolved = resolve3(input);
-  return existsSync(resolved) && statSync(resolved).isDirectory() ? join(resolved, PHASE_MARKER) : resolved;
+  const resolved = resolve4(input);
+  return existsSync2(resolved) && statSync2(resolved).isDirectory() ? join2(resolved, PHASE_MARKER) : resolved;
 }
 async function loadPhase(targetPath) {
   const resolved = resolvePhasePath(targetPath);
@@ -1246,7 +1313,9 @@ async function loadPhase(targetPath) {
   const frontmatterName = typeof metadata.name === "string" ? metadata.name : void 0;
   let definition;
   try {
-    definition = normalizeAgentDefinition(metadata, body, { fallbackName: directoryName });
+    const phaseMetadata = { ...metadata };
+    delete phaseMetadata.skills;
+    definition = normalizeAgentDefinition(phaseMetadata, body, { fallbackName: directoryName });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     warnResourceDiagnostics("phase", resolved, [message]);
@@ -1259,21 +1328,21 @@ async function loadPhase(targetPath) {
     diagnostics.push(...validateResourceName(frontmatterName, directoryName));
   }
   diagnostics.push(...description.warnings);
-  diagnostics.push(...validateSkillReferences(metadata.skills));
   diagnostics.push(...validatePhaseTarget(metadata.target));
   warnResourceDiagnostics("phase", resolved, diagnostics);
-  const baseDir = dirname3(resolved);
+  const baseDir = dirname4(resolved);
+  const skills = await loadPhaseSkills(baseDir);
   const phase = {
     name,
     description: description.description,
     tools: definition.tools ? [...definition.tools] : void 0,
-    skills: definition.skills ? [...definition.skills] : void 0,
+    skills,
     target: metadata.target,
     input: metadata.input,
     isolated: metadata.isolated,
     filePath: resolved,
     baseDir,
-    content: definition.content,
+    content: definition.prompt,
     model: definition.model
   };
   const codePath = await discoverPhaseCode(baseDir);
@@ -1287,6 +1356,54 @@ async function loadPhase(targetPath) {
   }
   return phase;
 }
+async function loadPhaseSkills(baseDir) {
+  const entries = await readdir2(baseDir, { withFileTypes: true });
+  const skills = [];
+  for (const entry of [...entries].sort((a, b) => a.name.localeCompare(b.name))) {
+    const entryPath = join2(baseDir, entry.name);
+    if (!entry.isDirectory()) {
+      if (RESOURCE_MARKERS.has(entry.name) && entry.name !== PHASE_MARKER) {
+        throw invalidPhaseBundle(`resource marker ${entry.name} is not valid at the phase root`);
+      }
+      continue;
+    }
+    const markers = await findResourceMarkers(entryPath);
+    const directSkillPath = join2(entryPath, SKILL_MARKER2);
+    const hasDirectSkill = markers.includes(directSkillPath);
+    if (!hasDirectSkill) {
+      if (markers.length > 0) {
+        throw invalidPhaseBundle(`resource marker ${markers[0]} is not a direct child Skill`);
+      }
+      continue;
+    }
+    const nestedMarkers = markers.filter((marker) => marker !== directSkillPath);
+    if (nestedMarkers.length > 0) {
+      throw invalidPhaseBundle(`resource marker ${nestedMarkers[0]} is nested below a Skill bundle`);
+    }
+    const skill = await loadSkill(directSkillPath);
+    if (skills.some((candidate) => candidate.name === skill.name)) {
+      throw invalidPhaseBundle(`duplicate bundled Skill name "${skill.name}"`);
+    }
+    skills.push(skill);
+  }
+  return skills;
+}
+async function findResourceMarkers(directory) {
+  const entries = await readdir2(directory, { withFileTypes: true });
+  const markers = [];
+  for (const entry of entries) {
+    const entryPath = join2(directory, entry.name);
+    if (entry.isDirectory()) {
+      markers.push(...await findResourceMarkers(entryPath));
+    } else if (RESOURCE_MARKERS.has(entry.name)) {
+      markers.push(entryPath);
+    }
+  }
+  return markers;
+}
+function invalidPhaseBundle(message) {
+  return new ResourceMetadataError("invalid_metadata", message);
+}
 function readPhaseContent(phase) {
   return formatResourceOutput({
     type: "phase",
@@ -1298,8 +1415,8 @@ function readPhaseContent(phase) {
 }
 async function loadPhases(targetPath) {
   const phases = /* @__PURE__ */ new Map();
-  const phasesDir = resolve3(targetPath);
-  if (existsSync(phasesDir) && statSync(phasesDir).isFile()) {
+  const phasesDir = resolve4(targetPath);
+  if (existsSync2(phasesDir) && statSync2(phasesDir).isFile()) {
     try {
       const phase = await loadPhase(phasesDir);
       phases.set(phase.name, phase);
@@ -1308,7 +1425,7 @@ async function loadPhases(targetPath) {
     }
     return { phases, entryPhaseId: null };
   }
-  if (existsSync(join(phasesDir, PHASE_MARKER))) {
+  if (existsSync2(join2(phasesDir, PHASE_MARKER))) {
     try {
       const phase = await loadPhase(phasesDir);
       phases.set(phase.name, phase);
@@ -1317,11 +1434,11 @@ async function loadPhases(targetPath) {
     }
     return { phases, entryPhaseId: null };
   }
-  const entries = await readdir(phasesDir, { withFileTypes: true });
+  const entries = await readdir2(phasesDir, { withFileTypes: true });
   for (const entry of [...entries].sort((a, b) => a.name.localeCompare(b.name))) {
     if (!entry.isDirectory()) continue;
-    const phaseFile = join(phasesDir, entry.name, PHASE_MARKER);
-    if (!existsSync(phaseFile)) continue;
+    const phaseFile = join2(phasesDir, entry.name, PHASE_MARKER);
+    if (!existsSync2(phaseFile)) continue;
     try {
       const phase = await loadPhase(phaseFile);
       phases.set(phase.name, phase);
@@ -1335,8 +1452,8 @@ async function loadPhases(targetPath) {
 async function discoverPhaseCode(baseDir) {
   const candidates = ["index.ts", "index.js"];
   for (const candidate of candidates) {
-    const fullPath = join(baseDir, candidate);
-    if (existsSync(fullPath)) {
+    const fullPath = join2(baseDir, candidate);
+    if (existsSync2(fullPath)) {
       return fullPath;
     }
   }
@@ -1368,6 +1485,7 @@ function createDefaultPhase() {
     description: "Executes concrete task operations and produces artifacts.",
     filePath: "",
     baseDir: "",
+    skills: [],
     content: "Execute tasks using current context.\nNo planning. No evaluation.\nRoute to next phase or stop when done."
   };
 }
@@ -1925,7 +2043,7 @@ async function runPhaseLoop(config, state, registry) {
     const toolExecutionManager = createToolExecutionManager();
     const execution = createPhaseExecution(config, state, phase, messageManager, toolExecutionManager, registry);
     const phaseTools = selectPhaseTools(allTools, phase.tools);
-    const phaseSkills = selectNamedResources(config.context.skills, phase.skills, "Skill");
+    const phaseSkills = phase.name === DEFAULT_PHASE_ID ? config.context.skills : phase.skills ?? [];
     let phaseContext = {
       systemPrompt: config.context.systemPrompt,
       messages: messageManager.visible(),
@@ -2204,7 +2322,7 @@ async function withRetry(fn, options = {}) {
       }
       const delayMs = getRetryDelay(attempt, baseDelayMs, maxDelayMs);
       options.onRetry?.(attempt, error, delayMs);
-      await new Promise((resolve7) => setTimeout(resolve7, delayMs));
+      await new Promise((resolve8) => setTimeout(resolve8, delayMs));
       if (options.signal?.aborted) {
         throw lastError;
       }
@@ -2216,7 +2334,7 @@ async function executePhase(ctx) {
   const { phase, config, execution, registry, context } = ctx;
   if (phase.factory) {
     const api = createExtensionAPI(void 0, {
-      registerPhase: () => {
+      registerPhase: async () => {
       },
       registerProvider: () => {
       },
@@ -2238,7 +2356,7 @@ async function executePhase(ctx) {
           config.context.messages.push(createMessage(role, content));
         },
         getAvailableTools: () => config.context.tools.map((t) => ({ name: t.name, description: t.description })),
-        getAvailableSkills: () => config.context.skills.map((s) => ({ name: s.name, description: s.description })),
+        getAvailableSkills: () => context.skills.map((s) => ({ name: s.name, description: s.description })),
         getPhaseContent: (id) => registry.phases.get(id)?.content ?? "",
         getAvailablePhases: () => Array.from(registry.phases.keys())
       },
@@ -2416,7 +2534,7 @@ async function executeParallelPhase(config, state, registry, phase, payload, con
   const messages = [...context];
   const allTools = buildToolsWithRouting(config, availablePhases);
   const phaseTools = selectPhaseTools(allTools, phase.tools);
-  const phaseSkills = selectNamedResources(config.context.skills, phase.skills, "Skill");
+  const phaseSkills = phase.name === DEFAULT_PHASE_ID ? config.context.skills : phase.skills ?? [];
   const systemPrompt = config.context.systemPrompt;
   const phaseContext = {
     systemPrompt,
@@ -2784,6 +2902,9 @@ function assertAgentConfigRequest(config) {
   if (!config.definition || typeof config.definition.name !== "string" || config.definition.name.trim() === "") {
     throw new TypeError("config.definition.name must be non-empty");
   }
+  if (config.definition.layer && "content" in config.definition.layer) {
+    throw new TypeError("definition.layer.content is not supported; use definition.layer.prompt");
+  }
   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");
@@ -2901,12 +3022,13 @@ function snapshotConfig(config) {
         phaseIds: Object.freeze([...config.definition.phases.phaseIds])
       })
     } : {},
-    ...config.definition.context ? { context: Object.freeze([...config.definition.context]) } : {}
+    ...config.definition.contexts ? { contexts: Object.freeze([...config.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]),
@@ -2930,6 +3052,20 @@ function snapshotConfig(config) {
   });
   return Object.freeze({ ...config, definition, resources });
 }
+function snapshotPhaseRegistry(registry) {
+  const phases = /* @__PURE__ */ new Map();
+  for (const [name, phase] of registry.phases) phases.set(name, snapshotPhase(phase));
+  return { phases, entryPhaseId: registry.entryPhaseId };
+}
+function snapshotPhase(phase) {
+  return Object.freeze({
+    ...phase,
+    ...phase.tools ? { tools: Object.freeze([...phase.tools]) } : {},
+    skills: Object.freeze((phase.skills ?? []).map((skill) => Object.freeze({ ...skill }))),
+    ...phase.input ? { input: Object.freeze({ ...phase.input }) } : {},
+    ...phase.model ? { model: Object.freeze({ ...phase.model }) } : {}
+  });
+}
 function snapshotConfiguration(config) {
   const layer = config.definition.layer;
   const definition = Object.freeze({
@@ -3365,7 +3501,7 @@ function resolveDefinitionContext(config, assembled = {}) {
   );
   const contexts = selectNamedResources(
     config.resources.contexts ?? [],
-    config.definition.context,
+    config.definition.contexts,
     "Context"
   );
   const candidateRegistry = assembled.phases ?? config.resources.phases;
@@ -3381,7 +3517,7 @@ function resolveDefinitionContext(config, assembled = {}) {
     console.warn(`Phase entry "${requestedEntry}" is not available; Rowan will use "default".`);
   }
   return {
-    systemPrompt: [config.definition.content, buildContextDescription(contexts)].filter((section) => section.length > 0).join("\n\n"),
+    systemPrompt: [config.definition.prompt, buildContextDescription(contexts)].filter((section) => section.length > 0).join("\n\n"),
     tools,
     skills,
     phases: { phases, entryPhaseId }
@@ -3429,11 +3565,11 @@ function fromLoopResult(result) {
 var MAX_BUFFERED_EVENTS = 128;
 var MAX_BUFFERED_TEXT = 64 * 1024;
 function deferred() {
-  let resolve7;
+  let resolve8;
   const promise = new Promise((done) => {
-    resolve7 = done;
+    resolve8 = done;
   });
-  return { promise, resolve: resolve7 };
+  return { promise, resolve: resolve8 };
 }
 var TransientRunEventSubscription = class {
   queue = [];
@@ -3619,6 +3755,7 @@ var HooksManager = class {
 
 // src/extensions/runner.ts
 import { execFile } from "child_process";
+import { dirname as dirname5, resolve as resolve5 } from "path";
 import {
   registerModel,
   unregisterProviderModels,
@@ -3650,9 +3787,6 @@ function createExtensionRuntime() {
   };
 }
 
-// src/extensions/runner.ts
-import { parseModelRef as parseModelRef2 } from "@rowan-agent/models";
-
 // src/extensions/event-bus.ts
 function createEventBus() {
   const listeners = /* @__PURE__ */ new Map();
@@ -3696,7 +3830,7 @@ function createEventBus() {
 
 // src/extensions/runner.ts
 async function execCommand(command, args, cwd, options) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     const child = execFile(
       command,
       args,
@@ -3711,7 +3845,7 @@ async function execCommand(command, args, cwd, options) {
           reject(new Error("Command was aborted"));
           return;
         }
-        resolve7({
+        resolve8({
           exitCode: typeof error?.code === "number" ? error.code : error ? 1 : 0,
           stdout: stdout ?? "",
           stderr: stderr ?? ""
@@ -3948,17 +4082,10 @@ var ExtensionRunner = class {
   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) } : {}
+      ...def,
+      ...def.tools ? { tools: [...def.tools] } : {},
+      skills: def.skills ? [...def.skills] : [],
+      ...def.input ? { input: { ...def.input } } : {}
     };
   }
   // ---------------------------------------------------------------------------
@@ -4120,36 +4247,20 @@ var ExtensionRunner = class {
     });
   }
   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);
+    if (typeof registration !== "string" || registration.length === 0) {
+      throw new Error(`Phase registration requires a directory path.`);
     }
+    return this.loadRegisteredPhase(extension, registration);
+  }
+  async loadRegisteredPhase(extension, registration) {
+    const extensionBase = extension.path.startsWith("<") ? this.cwd : dirname5(extension.path);
+    const phase = await loadPhase(resolve5(extensionBase, registration));
+    const name = phase.name;
     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,
+      definition: phase,
       source: { extensionPath: extension.path }
     };
     this.phases.set(name, registered);
@@ -4208,10 +4319,10 @@ function createExtensionRunner(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 { 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 dirname4, extname as extname2, join as join2, resolve as resolve4 } from "path";
+import { basename as basename3, dirname as dirname6, extname as extname2, join as join3, resolve as resolve6 } from "path";
 import { createJiti } from "jiti";
 function isExtensionFile(path) {
   const extension = extname2(path).toLowerCase();
@@ -4221,8 +4332,8 @@ function isSyntheticPath(path) {
   return path.startsWith("<") && path.endsWith(">");
 }
 function readManifestSync(dir) {
-  const manifestPath = join2(dir, "package.json");
-  if (!existsSync2(manifestPath)) {
+  const manifestPath = join3(dir, "package.json");
+  if (!existsSync3(manifestPath)) {
     return void 0;
   }
   try {
@@ -4231,8 +4342,7 @@ function readManifestSync(dir) {
     const rowan = pkg.rowan;
     if (!rowan) return void 0;
     return {
-      entry: rowan.extensions?.[0],
-      phase: rowan.phase
+      entry: rowan.extensions?.[0]
     };
   } catch {
     return void 0;
@@ -4244,7 +4354,7 @@ function jitiAliases() {
     return {};
   }
   const agentSourcePath = fileURLToPath(new URL("../index.ts", moduleUrl));
-  if (!existsSync2(agentSourcePath)) {
+  if (!existsSync3(agentSourcePath)) {
     return {};
   }
   return { "@rowan-agent/agent": agentSourcePath };
@@ -4265,28 +4375,28 @@ async function loadExtensionModule(extensionPath) {
   return typeof module === "function" ? module : void 0;
 }
 async function readPackageManifest(path) {
-  if (!existsSync2(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(join2(dir, "package.json"));
+  const manifest = await readPackageManifest(join3(dir, "package.json"));
   const declared = manifest?.rowan?.extensions;
   if (declared && declared.length > 0) {
-    return declared.map((entry) => resolve4(dir, entry));
+    return declared.map((entry) => resolve6(dir, entry));
   }
   for (const name of ["index.ts", "index.js"]) {
-    const entry = join2(dir, name);
-    if (existsSync2(entry)) {
+    const entry = join3(dir, name);
+    if (existsSync3(entry)) {
       return [entry];
     }
   }
   return void 0;
 }
 async function discoverExtensionsInDir(dir) {
-  const entries = await readdir2(dir, { withFileTypes: true }).catch((error) => {
+  const entries = await readdir3(dir, { withFileTypes: true }).catch((error) => {
     if (error.code === "ENOENT") {
       return [];
     }
@@ -4294,7 +4404,7 @@ async function discoverExtensionsInDir(dir) {
   });
   const paths = [];
   for (const entry of [...entries].sort((a, b) => a.name.localeCompare(b.name))) {
-    const entryPath = join2(dir, entry.name);
+    const entryPath = join3(dir, entry.name);
     if ((entry.isFile() || entry.isSymbolicLink()) && isExtensionFile(entry.name)) {
       paths.push(entryPath);
       continue;
@@ -4312,10 +4422,10 @@ async function discoverExtensionsInDir(dir) {
   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 resolvedCwd = resolve6(cwd);
+  const resolvedPath = isSyntheticPath(extensionPath) ? extensionPath : resolve6(resolvedCwd, extensionPath);
+  const name = isSyntheticPath(extensionPath) ? extensionPath : basename3(dirname6(resolvedPath)) || "unknown";
+  const manifestDir = isSyntheticPath(extensionPath) ? resolvedCwd : dirname6(resolvedPath);
   const manifest = readManifestSync(manifestDir);
   return {
     path: resolvedPath,
@@ -4327,9 +4437,9 @@ function loadExtensionFromFactory(factory, cwd, extensionPath = "<inline>") {
 async function loadExtensions(paths, cwd) {
   const extensions = [];
   const errors = [];
-  const resolvedCwd = resolve4(cwd);
+  const resolvedCwd = resolve6(cwd);
   for (const path of paths) {
-    const resolvedPath = resolve4(resolvedCwd, path);
+    const resolvedPath = resolve6(resolvedCwd, path);
     try {
       const factory = await loadExtensionModule(resolvedPath);
       if (!factory) {
@@ -4350,10 +4460,10 @@ async function loadExtensions(paths, cwd) {
   return { extensions, errors };
 }
 async function loadExtensionsFromPath(path) {
-  const resolvedPath = resolve4(path);
+  const resolvedPath = resolve6(path);
   const info = await stat2(resolvedPath);
   if (!info.isDirectory()) {
-    return loadExtensions([resolvedPath], dirname4(resolvedPath));
+    return loadExtensions([resolvedPath], dirname6(resolvedPath));
   }
   const entries = await resolveExtensionEntries(resolvedPath) ?? await discoverExtensionsInDir(resolvedPath);
   return loadExtensions(entries, resolvedPath);
@@ -4361,87 +4471,7 @@ async function loadExtensionsFromPath(path) {
 
 // src/runtime/resource-registry.ts
 import { stat as stat3, readdir as readdir4 } from "fs/promises";
-import { join as join4, resolve as resolve6 } from "path";
-
-// src/harness/skills.ts
-import { existsSync as existsSync3, statSync as statSync2 } from "fs";
-import { readdir as readdir3 } from "fs/promises";
-import { dirname as dirname5, join as join3, resolve as resolve5 } from "path";
-var SKILL_MARKER = "SKILL.md";
-function resolveSkillPath(input) {
-  const resolved = resolve5(input);
-  return existsSync3(resolved) && statSync2(resolved).isDirectory() ? join3(resolved, SKILL_MARKER) : resolved;
-}
-async function loadSkill(path) {
-  const resolved = resolveSkillPath(path);
-  let loaded;
-  try {
-    loaded = await loadMarkdown(resolved);
-  } catch (error) {
-    if (!(error instanceof FrontmatterParseError)) throw error;
-    warnResourceDiagnostics("skill", resolved, [`frontmatter could not be parsed: ${error.message}`]);
-    throw new ResourceMetadataError("parse_failed", error.message);
-  }
-  const { frontmatter, body } = loaded;
-  const metadata = frontmatter;
-  const id = inferResourceName(resolved, SKILL_MARKER);
-  const frontmatterName = typeof metadata.name === "string" ? metadata.name : void 0;
-  const name = frontmatterName || id;
-  const description = validateDescription(metadata.description);
-  const diagnostics = validateResourceId(id);
-  if (frontmatterName && frontmatterName !== id) {
-    diagnostics.push(...validateResourceName(frontmatterName, id));
-  }
-  diagnostics.push(...description.warnings);
-  warnResourceDiagnostics("skill", resolved, diagnostics);
-  if (description.missing) {
-    throw new ResourceMetadataError("invalid_metadata", "description is required");
-  }
-  return {
-    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;
-    }
-  }
-  if (existsSync3(join3(skillsDir, SKILL_MARKER))) {
-    try {
-      return [await loadSkill(skillsDir)];
-    } catch (error) {
-      if (error instanceof ResourceMetadataError) return [];
-      throw error;
-    }
-  }
-  const entries = await readdir3(skillsDir, { withFileTypes: true });
-  const skills = [];
-  for (const entry of [...entries].sort((a, b) => a.name.localeCompare(b.name))) {
-    if (!entry.isDirectory()) continue;
-    const skillFile = join3(skillsDir, entry.name, SKILL_MARKER);
-    if (!existsSync3(skillFile)) continue;
-    try {
-      const skill = await loadSkill(skillFile);
-      skills.push(skill);
-    } catch (error) {
-      if (error instanceof ResourceMetadataError) continue;
-      console.warn(`Failed to load skill "${entry.name}":`, error);
-    }
-  }
-  return skills;
-}
-
-// src/runtime/resource-registry.ts
+import { join as join4, resolve as resolve7 } from "path";
 var ResourceRegistryError = class extends Error {
   code;
   constructor(code, message) {
@@ -4568,6 +4598,7 @@ var ResourceRegistry = class {
     assertSourceId(sourceId);
     const names = /* @__PURE__ */ new Set();
     for (const value of values) {
+      if (kind === "agent") assertAgentDefinition(value);
       assertNamedResource(value, kind, sourceId);
       if (isImplicitCoreName(kind, value.name) && sourceId !== "rowan.core") {
         throw new ResourceRegistryError(
@@ -4584,11 +4615,12 @@ var ResourceRegistry = class {
       names.add(value.name);
     }
     const revision = this.nextRevision(kind, sourceId);
+    const snapshottedValues = values.map((value) => snapshotResourceValue(kind, value));
     const record = {
       kind,
       sourceId,
       revision,
-      values: Object.freeze([...values])
+      values: Object.freeze(snapshottedValues)
     };
     let bySource = this.sources.get(kind);
     if (!bySource) {
@@ -4658,6 +4690,18 @@ var ResourceRegistry = class {
     return `${kind}:${sourceId}:${this.revisionSequence}`;
   }
 };
+function snapshotResourceValue(kind, value) {
+  if (kind !== "phase") return value;
+  const phase = value;
+  const snapshot = {
+    ...phase,
+    ...phase.tools ? { tools: Object.freeze([...phase.tools]) } : {},
+    skills: Object.freeze((phase.skills ?? []).map((skill) => Object.freeze({ ...skill }))),
+    ...phase.input ? { input: Object.freeze({ ...phase.input }) } : {},
+    ...phase.model ? { model: Object.freeze({ ...phase.model }) } : {}
+  };
+  return Object.freeze(snapshot);
+}
 function assertSourceId(sourceId) {
   if (typeof sourceId !== "string" || !SOURCE_ID.test(sourceId)) {
     throw new ResourceRegistryError("invalid_source_id", `Invalid resource source "${String(sourceId)}".`);
@@ -4679,7 +4723,7 @@ function isImplicitCoreName(kind, name) {
   return kind === "tool" && name === "route" || kind === "phase" && name === "default";
 }
 async function loadDirectoryValues(kind, directory, sourceId) {
-  const root = resolve6(directory);
+  const root = resolve7(directory);
   let rootInfo;
   try {
     rootInfo = await stat3(root);
@@ -4922,7 +4966,7 @@ function resolveConfigurationSnapshot(registry, input) {
   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");
+  const contexts = selectNamedResources(input.contexts ?? [], base.contexts, "Context");
   return {
     identity: input.identity,
     definition,
@@ -4973,7 +5017,7 @@ function applyDefinitionLayer(base, layer) {
   return {
     ...base,
     ...layer.description === void 0 ? {} : { description: layer.description },
-    ...layer.content === void 0 ? {} : { content: layer.content },
+    ...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") },
@@ -5001,9 +5045,8 @@ function intersectPhaseSelection(parent, layer) {
 }
 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)) {
+  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 };
   }
@@ -5618,7 +5661,7 @@ function boundaryFromSnapshot(snapshot) {
   }
 }
 function delay(ms) {
-  return new Promise((resolve7) => setTimeout(resolve7, ms));
+  return new Promise((resolve8) => setTimeout(resolve8, ms));
 }
 function normalizePhaseRegistry(registry) {
   if (registry?.phases.has(DEFAULT_PHASE_ID) && registry.phases.get(DEFAULT_PHASE_ID)?.filePath !== "") {
@@ -5645,13 +5688,13 @@ function toJsonValue(value) {
   return value;
 }
 function deferred2() {
-  let resolve7;
+  let resolve8;
   let reject;
   const promise = new Promise((res, rej) => {
-    resolve7 = (value) => res(value);
+    resolve8 = (value) => res(value);
     reject = rej;
   });
-  return { promise, resolve: resolve7, reject };
+  return { promise, resolve: resolve8, reject };
 }
 
 // src/runtime/durable-store.ts
@@ -7129,7 +7172,9 @@ export {
   createCoreTools2 as createCoreTools,
   isRuntimeError,
   loadExtensionsFromPath as loadExtensions,
+  loadPhase,
   loadPhases,
+  loadSkill,
   loadSkills,
   materializeConfigurationSnapshot,
   parseAgentDefinition,

package/package.json

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