@rowan-agent/agent 0.5.0 → 0.5.2

package/README.md

@@ -264,6 +264,8 @@ Per iteration:
   5. Transition, continue, or stop
 ```
 
+**`entryPhaseId`** specifies which phase the loop enters first. When phases are loaded from `.rowan/phases/`, the first discovered phase becomes the entry. When none are configured, the Agent normalises to `"default"`. This field is an internal routing hint for the phase loop — it is **not** exposed to the LLM, since the agent does not need to know which phase is the entry point to make routing decisions.
+
 ### Example Phase Flow
 
 ```
@@ -377,7 +379,7 @@ interface PhaseContext {
   messages: AgentMessage[];
   tools: Tool[];
   skills: Skill[];
-  state: PhaseState;             // { current, available, iterations, payload }
+  state: PhaseState;             // { current, available, entryPhaseId, iterations, payload }
 }
 
 type PhaseOutput = {

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as _rowan_agent_models from '@rowan-agent/models';
-import { LlmRequest, LlmResponse, LlmModelRef, LlmModelUsage, AgentMessage, Skill as Skill$1, ToolResult, Outcome, ContentBlock, ToolCall, ProviderConfig, StreamFn, AgentEventListener, Protocol, ModelCost, AgentEvent, LlmMessage } from '@rowan-agent/models';
+import { LlmRequest, LlmResponse, LlmModelRef, LlmModelUsage, AgentMessage, ContentBlock, ToolCall, ToolResult, Outcome, ProviderConfig, Skill as Skill$1, StreamFn, AgentEventListener, Protocol, ModelCost, AgentEvent, LlmMessage } from '@rowan-agent/models';
 export { AgentEvent, AgentEventListener, AgentMessage, LlmModelRef, Outcome, Skill, StreamFn, ToolResult, createDispatchStream, registerBuiltInApiProviders } from '@rowan-agent/models';
 import Type from 'typebox';
 
@@ -23,87 +23,6 @@ type ModelTranscript = {
     response: LlmResponse;
 };
 
-type LoopMetrics = {
-    /** Number of phase iterations executed. */
-    iterations: number;
-    /** Phase transition history. */
-    phaseTransitions: Array<{
-        from: string;
-        to: string;
-        ts: string;
-    }>;
-    /** Number of times compaction was triggered. */
-    compactionCount: number;
-    /** Number of retry attempts due to transient errors. */
-    retryCount: number;
-    /** Loop start timestamp. */
-    startedAt: string;
-    /** Loop start time as epoch ms (for duration calculation). */
-    startedAtMs: number;
-    /** Loop end timestamp (set on completion). */
-    endedAt?: string;
-    /** Total wall-clock duration in ms. */
-    durationMs?: number;
-};
-type SessionState = {
-    currentPhase: string;
-    attempt: number;
-    metrics: LoopMetrics;
-    status: "idle" | "running" | "completed" | "aborted" | "failed";
-};
-
-type ToolContext = Pick<AgentContext, "skills"> & {
-    toolCallId: string;
-};
-type ToolExecutionMode = "sequential" | "parallel";
-type Tool<TArgs = unknown> = {
-    name: string;
-    description: string;
-    parameters: Type.TSchema;
-    /** One-line snippet shown in the system prompt tool list. */
-    promptSnippet?: string;
-    /** Additional guidelines appended to the system prompt when this tool is active. */
-    promptGuidelines?: string[];
-    /** Whether this tool can run concurrently with others. Default: "parallel". */
-    executionMode?: ToolExecutionMode;
-    execute(args: TArgs, context: ToolContext, signal?: AbortSignal): Promise<ToolResult>;
-};
-/** Context snapshot passed into the low-level agent loop. */
-type AgentContext = {
-    /** System prompt included with the request. */
-    systemPrompt: string;
-    /** Transcript visible to the model. */
-    messages: AgentMessage[];
-    /** Tools available for this run. */
-    tools: Tool[];
-    /** Skills available for this run. */
-    skills: Skill$1[];
-    /** Custom phases for this run. Agent normalizes this with the built-in default phase. */
-    phases?: PhaseRegistry;
-};
-type BeforeToolCall = (input: {
-    tool: Tool;
-    args: unknown;
-}) => Promise<{
-    allow: true;
-} | {
-    allow: false;
-    reason: string;
-}>;
-type AfterToolCall = (input: {
-    tool: Tool;
-    result: ToolResult;
-}) => Promise<ToolResult>;
-type RunResult = {
-    sessionId: string;
-    messages: AgentMessage[];
-    outcome: Outcome;
-    metrics: LoopMetrics;
-};
-type Unsubscribe = () => void;
-declare function createMessage(role: AgentMessage["role"], content: AgentMessage["content"], metadata?: Record<string, unknown>): AgentMessage;
-declare function messageContentText(content: AgentMessage["content"]): string;
-
 type ModelInvokeOutput = {
     text: string;
     contentBlocks: ContentBlock[];
@@ -127,89 +46,6 @@ type PhaseExecution = {
     executeTool(context: AgentContext, toolCall: ToolCall): Promise<ToolResult>;
 };
 
-/** Unified phase output — model decides routing via route. */
-type PhaseOutput = {
-    message: string;
-    /** Route to next phase, or "continue" to re-execute current phase, or "stop" to end */
-    route: string;
-    /** Phase name that produced this output */
-    phase?: string;
-    /** Tool calls from the model invocation (used by framework for route extraction) */
-    toolCalls?: Array<{
-        id: string;
-        name: string;
-        args: unknown;
-    }>;
-    /** Route reason extracted from route tool call (for hooks to inspect) */
-    routeReason?: string;
-    /** Structured data from this phase, passed to the next phase */
-    payload?: unknown;
-};
-/** Phase machine state — tracks position and inter-phase data */
-interface PhaseState {
-    current: string;
-    available: string[];
-    iterations: number;
-    payload?: unknown;
-}
-/** Everything a phase needs to execute */
-interface PhaseContext {
-    systemPrompt: string;
-    messages: AgentMessage[];
-    /** Phase-filtered tools */
-    tools: Tool[];
-    /** Phase-filtered skills */
-    skills: Skill$1[];
-    /** Phase machine state */
-    state: PhaseState;
-    /** Additional guideline bullets appended to the system prompt */
-    promptGuidelines?: string[];
-    /** Text to append after the system prompt */
-    appendSystemPrompt?: string;
-}
-/**
- * Loaded Phase object
- */
-interface Phase {
-    /** Unique identifier */
-    id: string;
-    /** Display name */
-    name: string;
-    /** Description */
-    description: string;
-    /** Restricted tools (undefined = all tools available) */
-    tools?: string[];
-    /** Restricted skills (undefined = all skills available) */
-    skills?: string[];
-    /** Forced next phase */
-    target?: string;
-    /** Expected input fields (key → description) */
-    input?: Record<string, string>;
-    /** If true, phase gets a fresh context when executed in parallel */
-    isolated?: boolean;
-    /** Path to PHASE.md file */
-    filePath: string;
-    /** Phase directory path */
-    baseDir: string;
-    /** PHASE.md body content */
-    content: string;
-    /** Model override for this phase (resolved from frontmatter) */
-    model?: LlmModelRef;
-    /** ExtensionAPI factory function (default export pattern) */
-    factory?: (api: ExtensionAPI) => Promise<void>;
-    /** Legacy run function */
-    run?: (context: PhaseContext, execution: PhaseExecution) => Promise<PhaseOutput | void>;
-}
-/**
- * Phase registry containing all loaded phases
- */
-interface PhaseRegistry {
-    /** Map of phase id to Phase object */
-    phases: Map<string, Phase>;
-    /** Entry phase id (null until Agent applies its default phase) */
-    entryPhaseId: string | null;
-}
-
 /**
  * Extension types — simplified for the new hook-based system.
  */
@@ -1307,10 +1143,202 @@ declare class ExtensionRunner {
 }
 declare function createExtensionRunner(options?: ExtensionRunnerOptions): ExtensionRunner;
 
+type LoopMetrics = {
+    /** Number of phase iterations executed. */
+    iterations: number;
+    /** Phase transition history. */
+    phaseTransitions: Array<{
+        from: string;
+        to: string;
+        ts: string;
+    }>;
+    /** Number of times compaction was triggered. */
+    compactionCount: number;
+    /** Number of retry attempts due to transient errors. */
+    retryCount: number;
+    /** Loop start timestamp. */
+    startedAt: string;
+    /** Loop start time as epoch ms (for duration calculation). */
+    startedAtMs: number;
+    /** Loop end timestamp (set on completion). */
+    endedAt?: string;
+    /** Total wall-clock duration in ms. */
+    durationMs?: number;
+};
+type SessionState = {
+    currentPhase: string;
+    attempt: number;
+    metrics: LoopMetrics;
+    status: "idle" | "running" | "completed" | "aborted" | "failed";
+};
+
+type ToolContext = Pick<AgentContext, "skills"> & {
+    toolCallId: string;
+};
+type ToolExecutionMode = "sequential" | "parallel";
+type Tool<TArgs = unknown> = {
+    name: string;
+    description: string;
+    parameters: Type.TSchema;
+    /** One-line snippet shown in the system prompt tool list. */
+    promptSnippet?: string;
+    /** Additional guidelines appended to the system prompt when this tool is active. */
+    promptGuidelines?: string[];
+    /** Whether this tool can run concurrently with others. Default: "parallel". */
+    executionMode?: ToolExecutionMode;
+    execute(args: TArgs, context: ToolContext, signal?: AbortSignal): Promise<ToolResult>;
+};
+/** Context snapshot passed into the low-level agent loop. */
+type AgentContext = {
+    /** System prompt included with the request. */
+    systemPrompt: string;
+    /** Transcript visible to the model. */
+    messages: AgentMessage[];
+    /** Tools available for this run. */
+    tools: Tool[];
+    /** Skills available for this run. */
+    skills: Skill$1[];
+    /** Custom phases for this run. Agent normalizes this with the built-in default phase. */
+    phases?: PhaseRegistry;
+};
+type BeforeToolCall = (input: {
+    tool: Tool;
+    args: unknown;
+}) => Promise<{
+    allow: true;
+} | {
+    allow: false;
+    reason: string;
+}>;
+type AfterToolCall = (input: {
+    tool: Tool;
+    result: ToolResult;
+}) => Promise<ToolResult>;
+type RunResult = {
+    sessionId: string;
+    messages: AgentMessage[];
+    outcome: Outcome;
+    metrics: LoopMetrics;
+};
+type Unsubscribe = () => void;
+declare function createMessage(role: AgentMessage["role"], content: AgentMessage["content"], metadata?: Record<string, unknown>): AgentMessage;
+declare function messageContentText(content: AgentMessage["content"]): string;
+
+/** Unified phase output — model decides routing via route. */
+type PhaseOutput = {
+    message: string;
+    /** Route to next phase, or "continue" to re-execute current phase, or "stop" to end */
+    route: string;
+    /** Phase name that produced this output */
+    phase?: string;
+    /** Tool calls from the model invocation (used by framework for route extraction) */
+    toolCalls?: Array<{
+        id: string;
+        name: string;
+        args: unknown;
+    }>;
+    /** Route reason extracted from route tool call (for hooks to inspect) */
+    routeReason?: string;
+    /** Structured data from this phase, passed to the next phase */
+    payload?: unknown;
+};
+/** Phase machine state — tracks position and inter-phase data */
+interface PhaseState {
+    current: string;
+    available: string[];
+    iterations: number;
+    payload?: unknown;
+}
+/** Everything a phase needs to execute */
+interface PhaseContext {
+    systemPrompt: string;
+    messages: AgentMessage[];
+    /** Phase-filtered tools */
+    tools: Tool[];
+    /** Phase-filtered skills */
+    skills: Skill$1[];
+    /** Phase machine state */
+    state: PhaseState;
+    /** Additional guideline bullets appended to the system prompt */
+    promptGuidelines?: string[];
+    /** Text to append after the system prompt */
+    appendSystemPrompt?: string;
+}
+/**
+ * Loaded Phase object
+ */
+interface Phase {
+    /** Unique identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Description */
+    description: string;
+    /** Restricted tools (undefined = all tools available) */
+    tools?: string[];
+    /** Restricted skills (undefined = all skills available) */
+    skills?: string[];
+    /** Forced next phase */
+    target?: string;
+    /** Expected input fields (key → description) */
+    input?: Record<string, string>;
+    /** If true, phase gets a fresh context when executed in parallel */
+    isolated?: boolean;
+    /** Path to PHASE.md file */
+    filePath: string;
+    /** Phase directory path */
+    baseDir: string;
+    /** PHASE.md body content */
+    content: string;
+    /** Model override for this phase (resolved from frontmatter) */
+    model?: LlmModelRef;
+    /** ExtensionAPI factory function (default export pattern) */
+    factory?: (api: ExtensionAPI) => Promise<void>;
+    /** Legacy run function */
+    run?: (context: PhaseContext, execution: PhaseExecution) => Promise<PhaseOutput | void>;
+}
+/**
+ * Phase registry containing all loaded phases
+ */
+interface PhaseRegistry {
+    /** Map of phase id to Phase object */
+    phases: Map<string, Phase>;
+    /** Entry phase id (null until Agent applies its default phase) */
+    entryPhaseId: string | null;
+}
+
+type WorkspacePaths = {
+    cwd: string;
+    rowanDir: string;
+};
+type ResolveWorkspaceOptions = {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    homeDir?: string;
+    rowanDir?: string;
+};
+declare function resolveWorkspacePaths(options?: ResolveWorkspaceOptions): WorkspacePaths;
+declare function resolveInWorkspace(path: string, rootOrPaths: string | Pick<WorkspacePaths, "cwd">): string;
+
+type PhaseLoadTarget = string | Pick<WorkspacePaths, "rowanDir">;
+/**
+ * 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>;
+declare function loadPhases(targetPath: PhaseLoadTarget): Promise<PhaseRegistry>;
+/**
+ * Re-read all file-based phases from disk and update the registry in place.
+ * Extension-registered phases (with empty filePath) are preserved as-is.
+ */
+declare function reloadPhases(registry: PhaseRegistry): Promise<void>;
+
 type AgentOptions = {
     context: AgentContext;
     model: LlmModelRef;
     stream: StreamFn;
+    cwd?: string;
     extensions?: LoadedExtension[];
     sessionId?: string;
     maxAttempts?: number;
@@ -1342,8 +1370,9 @@ declare class Agent {
     private activeRun?;
     private extensionRunner?;
     private loadedExtensions?;
+    private loadedExtensionsCwd?;
     static loadSkills(targetPath: string): Promise<AgentContext["skills"]>;
-    static loadPhases(targetPath: string): Promise<PhaseRegistry>;
+    static loadPhases(targetPath: Parameters<typeof loadPhases>[0]): Promise<PhaseRegistry>;
     static loadExtensions(targetPath: string): Promise<LoadExtensionsResult>;
     constructor(options: AgentOptions);
     subscribe(listener: AgentEventListener): Unsubscribe;
@@ -1614,19 +1643,6 @@ type CoreToolContext = {
 };
 declare function createCoreTools(input?: CoreToolContext): Tool[];
 
-type WorkspacePaths = {
-    cwd: string;
-    rowanDir: string;
-};
-type ResolveWorkspaceOptions = {
-    cwd?: string;
-    env?: NodeJS.ProcessEnv;
-    homeDir?: string;
-    rowanDir?: string;
-};
-declare function resolveWorkspacePaths(options?: ResolveWorkspaceOptions): WorkspacePaths;
-declare function resolveInWorkspace(path: string, rootOrPaths: string | Pick<WorkspacePaths, "cwd">): string;
-
 type ModelConfigFromFile = {
     id: string;
     name?: string;
@@ -1693,6 +1709,19 @@ declare class AgentEventStream extends EventStream<AgentEvent, AgentMessage[]> {
     constructor();
 }
 
+/** Error thrown when the model returns an empty response (no text, no tool calls). */
+declare class EmptyResponseError extends Error {
+    readonly code = "empty_response";
+    constructor(message?: string);
+}
+/** Error thrown when a routed phase needs a route tool call but the model did not emit one. */
+declare class MissingRouteToolCallError extends Error {
+    readonly code = "missing_route_tool_call";
+    readonly phase: string;
+    readonly toolCallNames: string[];
+    constructor(phase: string, toolCallNames: string[]);
+}
+
 interface SystemPromptOptions {
     /** Base system prompt. */
     systemPrompt: string;
@@ -1746,4 +1775,4 @@ declare function buildModelRequest(input: ModelRequestInput, options?: {
     model?: LlmModelRef;
 }): LlmRequest;
 
-export { type AbortEvent, type AfterPhaseEvent, type AfterPhaseHookResult, type AfterPhaseResult, type AfterToolCallEvent, type AfterToolCallResult, Agent, type AgentConfigFile, type AgentContext, type AgentEndEvent, AgentEventStream, type AgentOptions, type AgentStartEvent, type AgentStatus, type BeforePhaseEvent, type BeforePhaseHookResult, type BeforePhaseResult, type BeforePromptEvent, type BeforePromptResult, type BeforeToolCallEvent, type BeforeToolCallResult, type EventBus, EventStream, type ExecOptions, type ExecResult, type ExecutionTurn, type Extension, type ExtensionAPI, type ExtensionContext, type ExtensionError, type ExtensionErrorListener, type ExtensionFactory, type ExtensionManifest, type ExtensionPackageManifest, ExtensionRunner, type ExtensionRunnerOptions, type ExtensionRuntime, type ExtensionUtils, HookError, type HookEvent, type HookEventType, type HookHandler, type HookResultMap, HooksManager, type LoadExtensionsResult, type LoadedExtension, LocalJsonlSessionManager, type LoopMetrics, type MessageEndEvent, type MessageStartEvent, type MessageUpdateEvent, type ModelConfigFromFile, type ModelTranscript, type Phase, type PhaseContext, type PhaseDefinition, type PhaseExecution, type PhaseOutput, type PhaseRegistration, type PhaseRegistry, type PhaseRun, type PhaseState, type ProviderConfigFromFile, type QueueUpdateEvent, type RegisteredPhase, type RegisteredTool, type RunOptions, type RunResult, type SavePointEvent, type Session, type SessionListItem, type SettledEvent, type SourceInfo, type Tool, type ToolDefinition, type ToolExecutionEndEvent, type ToolExecutionResult, type ToolExecutionStartEvent, type ToolExecutionUpdateEvent, type TurnEndEvent, type TurnStartEvent, type WorkspacePaths, appendUserTurn, buildModelRequest, buildSystemPrompt, conversationMessages, createCoreTools, createEventBus, createExtension, createExtensionAPI, createExtensionRunner, createExtensionRuntime, createId, createMessage, createSession, createSourceInfo, createTimestamp, getGlobalHooks, interpolateEnvVars, latestUserInput, loadConfigFile, messageContentText, parseModelRef, registerConfigModels, resetGlobalHooks, resolveDefaultModel, resolveInWorkspace, resolveWorkspacePaths, serializeSkills };
+export { type AbortEvent, type AfterPhaseEvent, type AfterPhaseHookResult, type AfterPhaseResult, type AfterToolCallEvent, type AfterToolCallResult, Agent, type AgentConfigFile, type AgentContext, type AgentEndEvent, AgentEventStream, type AgentOptions, type AgentStartEvent, type AgentStatus, type BeforePhaseEvent, type BeforePhaseHookResult, type BeforePhaseResult, type BeforePromptEvent, type BeforePromptResult, type BeforeToolCallEvent, type BeforeToolCallResult, EmptyResponseError, type EventBus, EventStream, type ExecOptions, type ExecResult, type ExecutionTurn, type Extension, type ExtensionAPI, type ExtensionContext, type ExtensionError, type ExtensionErrorListener, type ExtensionFactory, type ExtensionManifest, type ExtensionPackageManifest, ExtensionRunner, type ExtensionRunnerOptions, type ExtensionRuntime, type ExtensionUtils, HookError, type HookEvent, type HookEventType, type HookHandler, type HookResultMap, HooksManager, type LoadExtensionsResult, type LoadedExtension, LocalJsonlSessionManager, type LoopMetrics, type MessageEndEvent, type MessageStartEvent, type MessageUpdateEvent, MissingRouteToolCallError, type ModelConfigFromFile, type ModelTranscript, type Phase, type PhaseContext, type PhaseDefinition, type PhaseExecution, type PhaseOutput, type PhaseRegistration, type PhaseRegistry, type PhaseRun, type PhaseState, type ProviderConfigFromFile, type QueueUpdateEvent, type RegisteredPhase, type RegisteredTool, type RunOptions, type RunResult, type SavePointEvent, type Session, type SessionListItem, type SettledEvent, type SourceInfo, type Tool, type ToolDefinition, type ToolExecutionEndEvent, type ToolExecutionResult, type ToolExecutionStartEvent, type ToolExecutionUpdateEvent, type TurnEndEvent, type TurnStartEvent, type WorkspacePaths, appendUserTurn, buildModelRequest, buildSystemPrompt, conversationMessages, createCoreTools, createEventBus, createExtension, createExtensionAPI, createExtensionRunner, createExtensionRuntime, createId, createMessage, createSession, createSourceInfo, createTimestamp, getGlobalHooks, interpolateEnvVars, latestUserInput, loadConfigFile, loadPhase, loadPhases, messageContentText, parseModelRef, registerConfigModels, reloadPhases, resetGlobalHooks, resolveDefaultModel, resolveInWorkspace, resolveWorkspacePaths, serializeSkills };

package/dist/index.js

@@ -21,6 +21,19 @@ var EmptyResponseError = class extends Error {
     this.name = "EmptyResponseError";
   }
 };
+var MissingRouteToolCallError = class extends Error {
+  code = "missing_route_tool_call";
+  phase;
+  toolCallNames;
+  constructor(phase, toolCallNames) {
+    super(
+      `Phase "${phase}" requires a route tool call, but the model did not emit one.`
+    );
+    this.name = "MissingRouteToolCallError";
+    this.phase = phase;
+    this.toolCallNames = toolCallNames;
+  }
+};
 var LoopGuard = {
   /** Returns abort result if signal is aborted */
   checkAbort(signal) {
@@ -81,6 +94,9 @@ var createOutcome = {
       id: createId("out"),
       message
     };
+    if (output.payload !== void 0) {
+      outcome.payload = output.payload;
+    }
     if (toolResults.length > 0) {
       outcome.toolResults = toolResults;
     }
@@ -747,9 +763,12 @@ function readPhaseContent(phase) {
     baseDir: phase.baseDir
   });
 }
+function resolvePhaseLoadTarget(targetPath) {
+  return typeof targetPath === "string" ? targetPath : join2(targetPath.rowanDir, "phases");
+}
 async function loadPhases(targetPath) {
   const phases = /* @__PURE__ */ new Map();
-  const phasesDir = resolve(targetPath);
+  const phasesDir = resolve(resolvePhaseLoadTarget(targetPath));
   if (existsSync2(phasesDir) && statSync(phasesDir).isFile()) {
     const phase = await loadPhase(phasesDir);
     phases.set(phase.id, phase);
@@ -799,6 +818,19 @@ async function loadPhaseCode(codePath) {
   }
   throw new Error(`Phase code at "${codePath}" must export a default function or a run() function.`);
 }
+async function reloadPhases(registry) {
+  for (const [id, phase] of registry.phases) {
+    if (!phase.filePath) {
+      continue;
+    }
+    try {
+      const fresh = await loadPhase(phase.filePath);
+      registry.phases.set(id, fresh);
+    } catch (error) {
+      console.warn(`Failed to reload phase "${id}":`, error);
+    }
+  }
+}
 
 // src/harness/phases/default.ts
 var DEFAULT_PHASE_ID = "default";
@@ -1956,6 +1988,14 @@ async function runPhaseLoop(config, state, registry) {
         output = extAfter.output;
       }
     }
+    const routeToolAvailable = phaseContext.tools.some((tool) => tool.name === PhaseRouteTool);
+    const routeRequired = !phase.target && !phase.run && !phase.factory && routeToolAvailable && registry.phases.size > 1;
+    if (routeRequired && !routeDecision) {
+      throw new MissingRouteToolCallError(
+        currentPhaseId,
+        output.toolCalls?.map((toolCall) => toolCall.name) ?? []
+      );
+    }
     if (output.route === "continue") {
       isContinuing = true;
       continue;
@@ -3378,6 +3418,7 @@ var Agent = class {
   activeRun;
   extensionRunner;
   loadedExtensions;
+  loadedExtensionsCwd;
   static loadSkills(targetPath) {
     return loadSkills(targetPath);
   }
@@ -3388,14 +3429,14 @@ var Agent = class {
     return loadExtensionsFromPath(targetPath);
   }
   constructor(options) {
-    const context = cloneAgentContext(options.context);
+    const context = prepareAgentContext(options.context);
     this.options = {
       ...options,
       context
     };
     this.state = {
       ...this.options.sessionId ? { sessionId: this.options.sessionId } : {},
-      context: cloneAgentContext(context),
+      context: prepareAgentContext(context),
       model: this.options.model,
       tools: this.options.context.tools ?? [],
       isRunning: false
@@ -3529,28 +3570,30 @@ var Agent = class {
     this.state.isRunning = false;
     this.activeRun = void 0;
   }
-  async loadExtensions(extensions) {
+  async loadExtensions(extensions, cwd) {
     if (extensions.length === 0) {
       this.extensionRunner?.invalidate();
       this.extensionRunner = void 0;
       this.loadedExtensions = extensions;
+      this.loadedExtensionsCwd = cwd;
       return;
     }
-    if (this.extensionRunner && this.loadedExtensions === extensions) {
+    if (this.extensionRunner && this.loadedExtensions === extensions && this.loadedExtensionsCwd === cwd) {
       return;
     }
-    const runner = createExtensionRunner();
+    const runner = createExtensionRunner({ cwd });
     await runner.loadExtensions(extensions);
     runner.bind();
     this.extensionRunner?.invalidate();
     this.extensionRunner = runner;
     this.loadedExtensions = extensions;
+    this.loadedExtensionsCwd = cwd;
   }
   async run(config) {
-    const extensions = config?.extensions ?? this.options.extensions ?? [];
-    await this.loadExtensions(extensions);
     const resolved = this.resolveRunConfig(config);
-    const runContext = cloneAgentContext(resolved.context, this.extensionRunner);
+    const extensions = resolved.extensions ?? [];
+    await this.loadExtensions(extensions, resolved.cwd);
+    const runContext = prepareAgentContext(resolved.context, this.extensionRunner);
     const sessionId = resolved.sessionId ?? this.state.sessionId;
     this.options = resolved;
     if (sessionId) {
@@ -3601,11 +3644,11 @@ var Agent = class {
         onModelTranscript: resolved.onModelTranscript
       });
       const nextContext = {
-        ...cloneAgentContext(resolved.context),
+        ...prepareAgentContext(resolved.context),
         messages: snapshotMessages(result.messages)
       };
       this.state.sessionId = result.sessionId;
-      this.state.context = cloneAgentContext(nextContext, this.extensionRunner);
+      this.state.context = prepareAgentContext(nextContext, this.extensionRunner);
       this.state.currentResult = result;
       this.options = {
         ...resolved,
@@ -3648,8 +3691,8 @@ ${additionalInstructions}` : content;
    * @returns Formatted phase content string, or empty string if not found
    */
   async phase(name) {
-    await this.loadExtensions(this.options.extensions ?? []);
-    const registry = cloneAgentContext(this.options.context, this.extensionRunner).phases?.phases;
+    await this.loadExtensions(this.options.extensions ?? [], this.options.cwd);
+    const registry = prepareAgentContext(this.options.context, this.extensionRunner).phases?.phases;
     const phase = registry?.get(name) ?? [...registry?.values() ?? []].find((candidate) => candidate.name === name);
     return phase ? readPhaseContent(phase) : "";
   }
@@ -3661,19 +3704,22 @@ ${additionalInstructions}` : content;
     await this.flushEvents().catch(() => void 0);
   }
   resolveRunConfig(config) {
-    const context = cloneAgentContext(config?.context ?? this.createContextSnapshot());
-    return {
+    const merged = {
       ...this.options,
-      ...config,
+      ...config
+    };
+    const context = prepareAgentContext(config?.context ?? this.createContextSnapshot());
+    return {
+      ...merged,
       context,
       sessionId: config?.sessionId ?? this.state.sessionId ?? this.options.sessionId
     };
   }
   createContextSnapshot() {
-    return cloneAgentContext(this.options.context);
+    return prepareAgentContext(this.options.context);
   }
 };
-function cloneAgentContext(context, extensionRunner) {
+function prepareAgentContext(context, extensionRunner) {
   const phases = /* @__PURE__ */ new Map();
   phases.set(DEFAULT_PHASE_ID, createDefaultPhase());
   for (const [id, phase] of context.phases?.phases ?? []) {
@@ -4222,10 +4268,12 @@ import {
 export {
   Agent,
   AgentEventStream,
+  EmptyResponseError,
   EventStream,
   ExtensionRunner,
   HooksManager,
   LocalJsonlSessionManager,
+  MissingRouteToolCallError,
   appendUserTurn,
   buildModelRequest,
   buildSystemPrompt,
@@ -4246,10 +4294,13 @@ export {
   interpolateEnvVars,
   latestUserInput,
   loadConfigFile,
+  loadPhase,
+  loadPhases,
   messageContentText,
   parseModelRef,
   registerBuiltInApiProviders,
   registerConfigModels,
+  reloadPhases,
   resetGlobalHooks,
   resolveDefaultModel,
   resolveInWorkspace,

package/package.json

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