@rowan-agent/agent 0.15.5 → 0.16.0

package/dist/index.d.ts

@@ -206,6 +206,40 @@ type PhaseMessageManager = {
     discard(messageId: string): void;
 };
 
+type ScopeRef = {
+    kind: "global";
+} | {
+    kind: "team";
+    teamId: string;
+} | {
+    kind: "project";
+    teamId: string;
+    projectId: string;
+};
+interface ExtensionStateStore {
+    get(key: string): Promise<JsonValue | undefined>;
+    set(key: string, value: JsonValue): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+interface ExtensionHost {
+    getConfig(extensionId: string, scope?: ScopeRef): Promise<JsonObject | null> | JsonObject | null;
+    onConfigChanged?(listener: (extensionId: string, scope: ScopeRef) => void): (() => void) | void;
+    getAgentState(extensionId: string, agentId: string, key: string): Promise<JsonValue | undefined> | JsonValue | undefined;
+    setAgentState(extensionId: string, agentId: string, key: string, value: JsonValue): Promise<void> | void;
+    deleteAgentState(extensionId: string, agentId: string, key: string): Promise<void> | void;
+}
+type ExtensionToolContribution = {
+    kind: "tool";
+    name: string;
+    description: string;
+};
+type ExtensionCapabilityContribution = ExtensionToolContribution;
+type ExtensionCapability = {
+    extensionId: string;
+    kind: "tool";
+    name: string;
+    description: string;
+};
 interface SourceInfo {
     source: string;
     baseDir?: string;
@@ -318,6 +352,7 @@ type LoadExtensionsResult = {
  * Runner.loadExtensions() calls the factory and creates the full Extension object.
  */
 interface LoadedExtension {
+    id?: string;
     path: string;
     name: string;
     factory: ExtensionFactory;
@@ -325,6 +360,7 @@ interface LoadedExtension {
 }
 /** Extension manifest from package.json `rowan` field. */
 interface ExtensionManifest {
+    id?: string;
     entry?: string;
     name?: string;
 }
@@ -471,6 +507,20 @@ interface ExtensionAPI {
     on<K extends HookEventType>(eventType: K, handler: HookHandler<K>): void;
     /** Unsubscribe from a hook event. */
     off<K extends HookEventType>(eventType: K, handler: HookHandler<K>): void;
+    /** Extension configuration — read own layered config or listen for changes. */
+    config: {
+        /** Get the extension's own effective configuration block. */
+        get(scope?: ScopeRef): Promise<JsonObject | null>;
+        /** Listen for configuration changes for a scope. */
+        changed(handler: (scope: ScopeRef) => void): void;
+    };
+    /** Extension state — scoped to run (in-memory) or agent (durable). */
+    state: {
+        /** Run-scoped in-memory state; dropped when the Run ends. */
+        run(runId: string): ExtensionStateStore;
+        /** Agent-scoped durable state; persisted with the Agent record. */
+        agent(agentId: string): ExtensionStateStore;
+    };
     /** Tool capabilities — register and unregister custom tools. */
     tool: {
         /** Register a custom LLM-callable tool. */
@@ -478,6 +528,11 @@ interface ExtensionAPI {
         /** Unregister a previously registered tool by name. */
         unregister(toolName: string): void;
     };
+    /** Capability contributions — advertise tools or features to the host. */
+    capabilities: {
+        /** Contribute a capability to the host. Returns a disposer to remove the contribution. */
+        contribute(contribution: ExtensionCapabilityContribution): () => void;
+    };
     /** Register a model provider. */
     registerProvider(config: _rowan_agent_models.ProviderConfig): void;
     /** Unregister a model provider. */
@@ -524,6 +579,23 @@ type ExtensionDisposer = () => void | Promise<void>;
 type ExtensionFactoryResult = void | ExtensionDisposer;
 type ExtensionFactory = (api: ExtensionAPI) => ExtensionFactoryResult | Promise<ExtensionFactoryResult>;
 
+declare class InMemoryExtensionHost implements ExtensionHost {
+    private readonly configs;
+    private readonly agentState;
+    private readonly listeners;
+    constructor(options?: {
+        configs?: Record<string, Record<string, JsonObject>>;
+        agentState?: Record<string, Record<string, Record<string, JsonValue>>>;
+    });
+    setConfig(extensionId: string, config: JsonObject | null, scope?: ScopeRef): void;
+    getConfig(extensionId: string, scope?: ScopeRef): JsonObject | null;
+    onConfigChanged(listener: (extensionId: string, scope: ScopeRef) => void): () => void;
+    notifyConfigChanged(extensionId: string, scope?: ScopeRef): void;
+    getAgentState(extensionId: string, agentId: string, key: string): JsonValue | undefined;
+    setAgentState(extensionId: string, agentId: string, key: string, value: JsonValue): void;
+    deleteAgentState(extensionId: string, agentId: string, key: string): void;
+}
+
 /**
  * Extension runner — manages extension loading and hook execution.
  *
@@ -538,6 +610,7 @@ type ExtensionFactory = (api: ExtensionAPI) => ExtensionFactoryResult | Promise<
 type ExtensionRunnerOptions = {
     entryPhaseId?: string | null;
     cwd?: string;
+    host?: ExtensionHost;
 };
 /**
  * Manages extensions and provides hooks for the agent loop.
@@ -573,15 +646,20 @@ declare class ExtensionRunner {
     readonly hooks: HooksManager;
     readonly runtime: ExtensionRuntime;
     readonly events: EventBus;
+    readonly host: ExtensionHost;
     private readonly cwd;
     private readonly abortController;
     private _idle;
     private readonly extensions;
+    private readonly runState;
+    private readonly configChangeListeners;
+    private readonly hostUnsubscribers;
     private readonly phases;
     private _phaseCache;
     private readonly pendingProviders;
     private bound;
     private readonly errorListeners;
+    private readonly capabilityListeners;
     /** Current agent context — set by the agent before each phase */
     currentContext?: AgentContext;
     constructor(options?: ExtensionRunnerOptions);
@@ -628,12 +706,25 @@ declare class ExtensionRunner {
     loadExtensions(extensions: LoadedExtension[]): Promise<void>;
     /** Dispose all active Extensions in reverse activation order. */
     close(): Promise<void>;
+    get extensionHost(): ExtensionHost;
+    notifyConfigChanged(extensionId: string, scope: ScopeRef): void;
+    getRunState(runId: string, extensionId: string, key: string): JsonValue | undefined;
+    setRunState(runId: string, extensionId: string, key: string, value: JsonValue): void;
+    deleteRunState(runId: string, extensionId: string, key: string): void;
+    dropRunState(runId: string): void;
     /** Get all registered tools from all extensions. */
     getAllRegisteredTools(): RegisteredTool[];
     /**
      * Get a tool definition by name. Returns undefined if not found.
      */
     getToolDefinition(toolName: string): RegisteredTool["definition"] | undefined;
+    /** Get all contributed capabilities across all extensions. */
+    getCapabilities(): readonly ExtensionCapability[];
+    /**
+     * Subscribe to capability changes (contributions added, removed, or extensions disposed).
+     * Returns an unsubscribe function.
+     */
+    onCapabilitiesChanged(listener: (capabilities: readonly ExtensionCapability[]) => void): () => void;
     getPhase(name: string): Phase | undefined;
     getPhases(): Phase[];
     createPhaseRegistry(input?: {
@@ -665,18 +756,33 @@ declare class ExtensionRunner {
         output?: PhaseOutput;
     }>;
     emitBeforePrompt(phaseId: string, input: PhaseContext): Promise<PhaseContext>;
+    emitRunStart(event: {
+        runId: string;
+        agentId: string;
+        metadata: Readonly<Record<string, unknown>>;
+        turn: JsonObject;
+    }): Promise<void>;
+    emitRunEnd(event: {
+        runId: string;
+        agentId: string;
+        outcome: unknown;
+    }): Promise<void>;
     emitBeforeToolCall(tool: Tool, args: unknown, context?: {
         runId?: string;
         agentId?: string;
         toolCallId?: string;
         metadata?: Readonly<Record<string, unknown>>;
         answer?: unknown;
+        scope?: ScopeRef;
+        turn?: JsonObject;
     }): Promise<BeforeToolCallResult>;
     emitAfterToolCall(tool: Tool, result: ToolResult, context?: {
         runId?: string;
         agentId?: string;
         toolCallId?: string;
         metadata?: Readonly<Record<string, unknown>>;
+        scope?: ScopeRef;
+        turn?: JsonObject;
     }): Promise<ToolResult>;
     /**
      * Create an ExtensionAPI for a specific extension.
@@ -686,6 +792,8 @@ declare class ExtensionRunner {
     private createExtensionAPI;
     private registerTool;
     private unregisterTool;
+    private contributeCapability;
+    private notifyCapabilitiesChanged;
     private registerPhase;
     private registerPhaseDefinition;
     private unregisterPhase;
@@ -724,11 +832,14 @@ declare class RuntimeExtensionLifetime {
     private closed;
     constructor(options?: {
         cwd?: string;
+        host?: ExtensionHost;
     });
     activate(extensions: readonly LoadedExtension[]): Promise<ExtensionActivationResult>;
     tools(): readonly RegisteredTool[];
     phases(): readonly Phase[];
     get extensionRunner(): ExtensionRunner;
+    get extensionHost(): ExtensionHost;
+    dropRunState(runId: string): void;
     close(): Promise<void>;
 }
 /** Bootstrap-only Registry facade; its Extension method disappears after init. */
@@ -736,6 +847,7 @@ declare class RuntimeBootstrapRegistry extends ResourceRegistry {
     private readonly extensions;
     private readonly extensionSourceId;
     constructor(extensions?: RuntimeExtensionLifetime);
+    get extensionHost(): ExtensionHost;
     /** Install Rowan-owned implicit resources before any host source is read. */
     ensureCoreResources(): Promise<void>;
     loadExtensions(input: readonly LoadedExtension[] | ExtensionLoadInput): Promise<ExtensionActivationResult>;
@@ -830,6 +942,8 @@ type ToolCallContext = Readonly<{
     agentMetadata?: Metadata;
     runMetadata?: Metadata;
     toolCallId: ToolCallId;
+    scope?: ScopeRef;
+    turn?: JsonObject;
     reportProgress(progress: JsonValue): void;
 }>;
 type ToolInvocationContext = ToolCallContext & Readonly<{
@@ -1244,6 +1358,7 @@ type AgentRuntimeOptions = Readonly<{
     configs?: ConfigProvider;
     concurrency?: number;
     bootstrap?: (registry: RuntimeBootstrapRegistry) => void | Promise<void>;
+    host?: ExtensionHost;
 }>;
 type DurableConsumer = Readonly<{
     caughtUp: Promise<void>;
@@ -1268,6 +1383,7 @@ interface AgentRun {
     cancel(reason?: string): Promise<RunBoundary>;
 }
 interface AgentRuntime$1 {
+    readonly host: ExtensionHost;
     loadAgents(input: LoadInput<AgentDefinition>): Promise<LoadResult>;
     loadSkills(input: LoadInput<Skill>): Promise<LoadResult>;
     loadPhases(input: LoadInput<Phase>): Promise<LoadResult>;
@@ -1335,6 +1451,8 @@ interface AgentRuntime$1 {
             signal: AbortSignal;
         }>): void | Promise<void>;
     }): Promise<DurableConsumer>;
+    listCapabilities(): readonly ExtensionCapability[];
+    onCapabilitiesChanged(listener: (capabilities: readonly ExtensionCapability[]) => void): () => void;
     close(): Promise<void>;
 }
 type ConsumerRegistration = Readonly<{
@@ -2039,6 +2157,8 @@ interface BeforeToolCallEvent {
     readonly toolCallId?: string;
     readonly metadata?: Readonly<Record<string, unknown>>;
     readonly answer?: unknown;
+    readonly scope?: ScopeRef;
+    readonly turn?: JsonObject;
 }
 interface AfterToolCallEvent {
     type: "after_tool_call";
@@ -2048,8 +2168,23 @@ interface AfterToolCallEvent {
     readonly agentId?: string;
     readonly toolCallId?: string;
     readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly scope?: ScopeRef;
+    readonly turn?: JsonObject;
+}
+interface RunStartEvent {
+    type: "run_start";
+    runId: string;
+    agentId: string;
+    metadata: Readonly<Record<string, unknown>>;
+    turn: JsonObject;
+}
+interface RunEndEvent {
+    type: "run_end";
+    runId: string;
+    agentId: string;
+    outcome: unknown;
 }
-type HookEvent = BeforePhaseEvent | AfterPhaseEvent | BeforePromptEvent | BeforeToolCallEvent | AfterToolCallEvent;
+type HookEvent = BeforePhaseEvent | AfterPhaseEvent | BeforePromptEvent | BeforeToolCallEvent | AfterToolCallEvent | RunStartEvent | RunEndEvent;
 interface BeforePhaseResult {
     abort?: Outcome$1;
     skip?: {
@@ -2080,6 +2215,8 @@ interface HookResultMap {
     before_prompt: BeforePromptResult | undefined;
     before_tool_call: BeforeToolCallResult | undefined;
     after_tool_call: AfterToolCallResult | undefined;
+    run_start: void;
+    run_end: void;
 }
 type HookEventType = HookEvent["type"];
 type HookHandler<K extends HookEventType> = (event: Extract<HookEvent, {
@@ -2157,12 +2294,15 @@ declare class AgentRuntime implements AgentRuntime$1 {
     private readonly autoCompactionRuns;
     private readonly consumers;
     private readonly transientEvents;
+    readonly host: ExtensionHost;
     private readonly resources;
+    private readonly startedRuns;
     private heartbeat?;
     private pumping;
     private closed;
     private constructor();
     static init(options: AgentRuntimeOptions): Promise<AgentRuntime>;
+    private handleRunEnd;
     loadAgents(input: LoadInput<AgentDefinition>): Promise<LoadResult>;
     loadSkills(input: LoadInput<Skill>): Promise<LoadResult>;
     loadPhases(input: LoadInput<Phase>): Promise<LoadResult>;
@@ -2235,6 +2375,8 @@ declare class AgentRuntime implements AgentRuntime$1 {
             signal: AbortSignal;
         }>): void | Promise<void>;
     }): Promise<DurableConsumer>;
+    listCapabilities(): readonly ExtensionCapability[];
+    onCapabilitiesChanged(listener: (capabilities: readonly ExtensionCapability[]) => void): () => void;
     close(): Promise<void>;
     snapshot(runId: RunId): Promise<RunSnapshot>;
     history(agentId: AgentId): Promise<readonly Message[]>;
@@ -2990,4 +3132,4 @@ declare function parseFrontmatter<T = Record<string, unknown>>(raw: string): Fro
 
 declare function createCoreTools(input?: CoreToolContext): Tool$1[];
 
-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 EntryPhaseSpec, 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 InteractionRecord, 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 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 RunInteraction, RunInteractionBoundary, RunInteractionCancelledError, type RunInteractionDriver, type RunInteractionKind, type RunInteractionRequest, type RunInteractionState, type RunInteractionStatus, 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$1 as Tool, type ToolCallContext, 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, createCompactPhase, createCorePhases, createCoreTools, createDefaultPhase, createStopPhase, isConfigurationSnapshot, isRuntimeError, loadExtensionsFromPath as loadExtensions, loadPhase, loadPhaseSettings, loadPhases, loadSkill, loadSkills, 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 EntryPhaseSpec, type EventCursor, type EventId, type ExecutionCheckpoint, type ExecutionId, type ExecutionToken, type ExtensionAPI, type ExtensionActivationError, type ExtensionActivationResult, type ExtensionCapability, type ExtensionCapabilityContribution, type ExtensionContribution, type ExtensionDisposer, type ExtensionFactory, type ExtensionFactoryResult, type ExtensionHost, ExtensionLifetimeError, type ExtensionLifetimeErrorCode, type ExtensionLoadInput, type ExtensionStateStore, type ExtensionToolContribution, type FrontmatterResult, type HistorySeed, type HookEvent, type HookEventType, type HookHandler, InMemoryConfigProvider, InMemoryExtensionHost, InMemoryStore, type InteractionRecord, 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 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 RunEndEvent, type RunEvent, type RunFailure, type RunId, type RunInteraction, RunInteractionBoundary, RunInteractionCancelledError, type RunInteractionDriver, type RunInteractionKind, type RunInteractionRequest, type RunInteractionState, type RunInteractionStatus, type RunListCursor, type RunRecord, type RunSnapshot, type RunStartEvent, type RunState, type RunStateChanged, type RunSummary, RuntimeBootstrapRegistry, RuntimeError, type RuntimeErrorCode, type RuntimeErrorDetails, RuntimeExtensionLifetime, STOP_PHASE_ID, type ScopeRef, type Skill, SqliteStore, type TextContent, type ThinkingContent, type ThinkingDelta, type Tool$1 as Tool, type ToolCallContext, 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, createCompactPhase, createCorePhases, createCoreTools, createDefaultPhase, createStopPhase, isConfigurationSnapshot, isRuntimeError, loadExtensionsFromPath as loadExtensions, loadPhase, loadPhaseSettings, loadPhases, loadSkill, loadSkills, parseAgentDefinition, parseFrontmatter, resolveConfigurationSnapshot };

package/dist/index.js

@@ -1247,6 +1247,56 @@ function createExtensionAPI(hooks, options, runtime, eventBus) {
       assertActive();
       hooks?.off(eventType, handler);
     },
+    config: {
+      get: async (scope) => {
+        assertActive();
+        return await options?.config?.get(scope) ?? null;
+      },
+      changed: (handler) => {
+        assertActive();
+        options?.config?.changed(handler);
+      }
+    },
+    state: {
+      run: (runId) => {
+        assertActive();
+        const store = options?.state?.run(runId);
+        return {
+          get: async (key) => {
+            assertActive();
+            return store?.get(key);
+          },
+          set: async (key, value) => {
+            assertActive();
+            assertJsonValue(value);
+            return store?.set(key, value);
+          },
+          delete: async (key) => {
+            assertActive();
+            return store?.delete(key);
+          }
+        };
+      },
+      agent: (agentId) => {
+        assertActive();
+        const store = options?.state?.agent(agentId);
+        return {
+          get: async (key) => {
+            assertActive();
+            return store?.get(key);
+          },
+          set: async (key, value) => {
+            assertActive();
+            assertJsonValue(value);
+            return store?.set(key, value);
+          },
+          delete: async (key) => {
+            assertActive();
+            return store?.delete(key);
+          }
+        };
+      }
+    },
     tool: {
       register: (tool) => {
         assertActive();
@@ -1257,6 +1307,25 @@ function createExtensionAPI(hooks, options, runtime, eventBus) {
         options?.unregisterTool?.(toolName);
       }
     },
+    capabilities: {
+      contribute: (contribution) => {
+        assertActive();
+        if (!contribution || typeof contribution !== "object") {
+          throw new TypeError("Capability contribution must be an object.");
+        }
+        if (contribution.kind !== "tool") {
+          throw new TypeError(`Unsupported capability contribution kind: "${contribution.kind}".`);
+        }
+        if (typeof contribution.name !== "string" || contribution.name.trim() === "") {
+          throw new TypeError("Capability contribution requires a non-empty name.");
+        }
+        if (typeof contribution.description !== "string") {
+          throw new TypeError("Capability contribution requires a description string.");
+        }
+        return options?.contributeCapability ? options.contributeCapability(contribution) : () => {
+        };
+      }
+    },
     registerProvider: (config) => {
       assertActive();
       options?.registerProvider?.(config);
@@ -4518,7 +4587,9 @@ function assembleRegisteredExtensions(snapshot, runner, options = {}) {
         agentId: input.context.agentId,
         toolCallId: input.context.toolCallId,
         metadata: input.context.runMetadata,
-        answer: input.answer
+        answer: input.answer,
+        scope: input.context.scope,
+        turn: input.context.turn
       });
       if (decision.interaction !== void 0) {
         return { interaction: decision.interaction };
@@ -4534,7 +4605,9 @@ function assembleRegisteredExtensions(snapshot, runner, options = {}) {
           runId: input.context.runId,
           agentId: input.context.agentId,
           toolCallId: input.context.toolCallId,
-          metadata: input.context.runMetadata
+          metadata: input.context.runMetadata,
+          scope: input.context.scope,
+          turn: input.context.turn
         }
       );
       return fromLoopResult(result);
@@ -4792,6 +4865,126 @@ var HooksManager = class {
   }
 };
 
+// src/extensions/host.ts
+var InMemoryExtensionHost = class {
+  configs = /* @__PURE__ */ new Map();
+  agentState = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  constructor(options = {}) {
+    if (options.configs) {
+      for (const [scopeKey, extMap] of Object.entries(options.configs)) {
+        const map = /* @__PURE__ */ new Map();
+        for (const [extId, cfg] of Object.entries(extMap)) {
+          assertJsonValue(cfg);
+          map.set(extId, structuredClone(cfg));
+        }
+        this.configs.set(scopeKey, map);
+      }
+    }
+    if (options.agentState) {
+      for (const [agentId, extMap] of Object.entries(options.agentState)) {
+        const agentMap = /* @__PURE__ */ new Map();
+        for (const [extId, stateMap] of Object.entries(extMap)) {
+          const map = /* @__PURE__ */ new Map();
+          for (const [key, val] of Object.entries(stateMap)) {
+            assertJsonValue(val);
+            map.set(key, structuredClone(val));
+          }
+          agentMap.set(extId, map);
+        }
+        this.agentState.set(agentId, agentMap);
+      }
+    }
+  }
+  setConfig(extensionId, config, scope = { kind: "global" }) {
+    const scopeKey = scopeToKey(scope);
+    if (!this.configs.has(scopeKey)) {
+      this.configs.set(scopeKey, /* @__PURE__ */ new Map());
+    }
+    const scopeConfigs = this.configs.get(scopeKey);
+    if (config === null) {
+      scopeConfigs.delete(extensionId);
+    } else {
+      assertJsonValue(config);
+      scopeConfigs.set(extensionId, structuredClone(config));
+    }
+    this.notifyConfigChanged(extensionId, scope);
+  }
+  getConfig(extensionId, scope = { kind: "global" }) {
+    const globalConfig = this.configs.get("global")?.get(extensionId);
+    let merged = globalConfig ? { ...globalConfig } : null;
+    if (scope.kind === "team" || scope.kind === "project") {
+      const teamConfig = this.configs.get(`team:${scope.teamId}`)?.get(extensionId);
+      if (teamConfig) {
+        merged = { ...merged ?? {}, ...teamConfig };
+      }
+    }
+    if (scope.kind === "project") {
+      const projectConfig = this.configs.get(`project:${scope.teamId}:${scope.projectId}`)?.get(extensionId);
+      if (projectConfig) {
+        merged = { ...merged ?? {}, ...projectConfig };
+      }
+    }
+    return merged ? structuredClone(merged) : null;
+  }
+  onConfigChanged(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  notifyConfigChanged(extensionId, scope = { kind: "global" }) {
+    for (const listener of this.listeners) {
+      try {
+        listener(extensionId, scope);
+      } catch {
+      }
+    }
+  }
+  getAgentState(extensionId, agentId, key) {
+    const val = this.agentState.get(agentId)?.get(extensionId)?.get(key);
+    return val !== void 0 ? structuredClone(val) : void 0;
+  }
+  setAgentState(extensionId, agentId, key, value) {
+    assertJsonValue(value);
+    let agentMap = this.agentState.get(agentId);
+    if (!agentMap) {
+      agentMap = /* @__PURE__ */ new Map();
+      this.agentState.set(agentId, agentMap);
+    }
+    let extMap = agentMap.get(extensionId);
+    if (!extMap) {
+      extMap = /* @__PURE__ */ new Map();
+      agentMap.set(extensionId, extMap);
+    }
+    extMap.set(key, structuredClone(value));
+  }
+  deleteAgentState(extensionId, agentId, key) {
+    this.agentState.get(agentId)?.get(extensionId)?.delete(key);
+  }
+};
+function scopeToKey(scope) {
+  switch (scope.kind) {
+    case "global":
+      return "global";
+    case "team":
+      return `team:${scope.teamId}`;
+    case "project":
+      return `project:${scope.teamId}:${scope.projectId}`;
+  }
+}
+function resolveScopeFromMetadata(metadata) {
+  if (metadata) {
+    const teamId = typeof metadata.teamId === "string" ? metadata.teamId : void 0;
+    const projectId = typeof metadata.projectId === "string" ? metadata.projectId : void 0;
+    if (teamId && projectId) {
+      return { kind: "project", teamId, projectId };
+    }
+    if (teamId) {
+      return { kind: "team", teamId };
+    }
+  }
+  return { kind: "global" };
+}
+
 // src/extensions/runner.ts
 import { execFile } from "child_process";
 import { dirname as dirname5, resolve as resolve5 } from "path";
@@ -4934,11 +5127,17 @@ var ExtensionRunner = class {
   hooks;
   runtime;
   events;
+  host;
   cwd;
   abortController = new AbortController();
   _idle = true;
   // Per-extension tracking
   extensions = [];
+  // Run state: runId -> extensionId -> key -> value
+  runState = /* @__PURE__ */ new Map();
+  // Config change listeners: extensionId -> Set of handlers
+  configChangeListeners = /* @__PURE__ */ new Map();
+  hostUnsubscribers = [];
   // Phase management
   phases = /* @__PURE__ */ new Map();
   _phaseCache = null;
@@ -4947,6 +5146,8 @@ var ExtensionRunner = class {
   bound = false;
   // Error listeners
   errorListeners = /* @__PURE__ */ new Set();
+  // Capability change listeners
+  capabilityListeners = /* @__PURE__ */ new Set();
   /** Current agent context — set by the agent before each phase */
   currentContext;
   constructor(options) {
@@ -4954,6 +5155,15 @@ var ExtensionRunner = class {
     this.runtime = createExtensionRuntime();
     this.events = createEventBus();
     this.cwd = options?.cwd ?? process.cwd();
+    this.host = options?.host ?? new InMemoryExtensionHost();
+    if (this.host.onConfigChanged) {
+      const unsub = this.host.onConfigChanged((extensionId, scope) => {
+        this.notifyConfigChanged(extensionId, scope);
+      });
+      if (typeof unsub === "function") {
+        this.hostUnsubscribers.push(unsub);
+      }
+    }
   }
   /** Whether the agent is currently idle (not streaming). */
   get isIdle() {
@@ -5034,10 +5244,13 @@ var ExtensionRunner = class {
    */
   async loadExtensions(extensions) {
     for (const ext of extensions) {
+      const extensionId = ext.id ?? ext.manifest?.id ?? ext.name;
       const extension = {
+        id: extensionId,
         path: ext.path,
         tools: /* @__PURE__ */ new Map(),
         phases: /* @__PURE__ */ new Set(),
+        capabilities: /* @__PURE__ */ new Map(),
         cleanup: [],
         runtime: createExtensionRuntime()
       };
@@ -5047,6 +5260,9 @@ var ExtensionRunner = class {
         if (typeof disposer === "function") extension.disposer = disposer;
         this.extensions.push(extension);
         this._phaseCache = null;
+        if (extension.capabilities.size > 0) {
+          this.notifyCapabilitiesChanged();
+        }
       } catch (error) {
         await this.rollbackExtension(extension);
         const message = error instanceof Error ? error.message : String(error);
@@ -5063,14 +5279,67 @@ var ExtensionRunner = class {
   /** Dispose all active Extensions in reverse activation order. */
   async close() {
     this.abortController.abort();
+    for (const unsub of this.hostUnsubscribers) {
+      try {
+        unsub();
+      } catch {
+      }
+    }
+    this.hostUnsubscribers.length = 0;
+    this.configChangeListeners.clear();
+    this.runState.clear();
     for (const extension of [...this.extensions].reverse()) {
       await this.disposeExtension(extension, "This Extension Runtime has been closed.");
     }
     this.extensions.length = 0;
+    this.capabilityListeners.clear();
     this.phases.clear();
     this._phaseCache = null;
     this.runtime.invalidate("This Extension Runtime has been closed.");
   }
+  get extensionHost() {
+    return this.host;
+  }
+  notifyConfigChanged(extensionId, scope) {
+    const listeners = this.configChangeListeners.get(extensionId);
+    if (!listeners) return;
+    for (const listener of listeners) {
+      try {
+        listener(scope);
+      } catch (error) {
+        this.emitError({
+          extensionPath: "<runtime>",
+          event: "config_changed",
+          error: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : void 0
+        });
+      }
+    }
+  }
+  getRunState(runId, extensionId, key) {
+    const val = this.runState.get(runId)?.get(extensionId)?.get(key);
+    return val !== void 0 ? structuredClone(val) : void 0;
+  }
+  setRunState(runId, extensionId, key, value) {
+    assertJsonValue(value);
+    let runMap = this.runState.get(runId);
+    if (!runMap) {
+      runMap = /* @__PURE__ */ new Map();
+      this.runState.set(runId, runMap);
+    }
+    let extMap = runMap.get(extensionId);
+    if (!extMap) {
+      extMap = /* @__PURE__ */ new Map();
+      runMap.set(extensionId, extMap);
+    }
+    extMap.set(key, structuredClone(value));
+  }
+  deleteRunState(runId, extensionId, key) {
+    this.runState.get(runId)?.get(extensionId)?.delete(key);
+  }
+  dropRunState(runId) {
+    this.runState.delete(runId);
+  }
   // ---------------------------------------------------------------------------
   // Tool management
   // ---------------------------------------------------------------------------
@@ -5097,6 +5366,32 @@ var ExtensionRunner = class {
     return void 0;
   }
   // ---------------------------------------------------------------------------
+  // Capability management
+  // ---------------------------------------------------------------------------
+  /** Get all contributed capabilities across all extensions. */
+  getCapabilities() {
+    const result = [];
+    for (const ext of this.extensions) {
+      for (const contrib of ext.capabilities.values()) {
+        result.push({
+          extensionId: ext.id,
+          kind: contrib.kind,
+          name: contrib.name,
+          description: contrib.description
+        });
+      }
+    }
+    return Object.freeze(result);
+  }
+  /**
+   * Subscribe to capability changes (contributions added, removed, or extensions disposed).
+   * Returns an unsubscribe function.
+   */
+  onCapabilitiesChanged(listener) {
+    this.capabilityListeners.add(listener);
+    return () => this.capabilityListeners.delete(listener);
+  }
+  // ---------------------------------------------------------------------------
   // Phase management
   // ---------------------------------------------------------------------------
   getPhase(name) {
@@ -5182,7 +5477,39 @@ var ExtensionRunner = class {
     });
     return result?.input ?? input;
   }
+  async emitRunStart(event) {
+    try {
+      await this.hooks.emit("run_start", {
+        type: "run_start",
+        ...event
+      });
+    } catch (error) {
+      this.emitError({
+        extensionPath: "<runtime>",
+        event: "run_start",
+        error: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : void 0
+      });
+    }
+  }
+  async emitRunEnd(event) {
+    try {
+      await this.hooks.emit("run_end", {
+        type: "run_end",
+        ...event
+      });
+    } catch (error) {
+      this.emitError({
+        extensionPath: "<runtime>",
+        event: "run_end",
+        error: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : void 0
+      });
+    }
+  }
   async emitBeforeToolCall(tool, args, context) {
+    const scope = context?.scope ?? resolveScopeFromMetadata(context?.metadata);
+    const turn = context?.turn ?? {};
     const result = await this.emitHook("before_tool_call", {
       type: "before_tool_call",
       tool,
@@ -5191,11 +5518,15 @@ var ExtensionRunner = class {
       ...context?.agentId !== void 0 ? { agentId: context.agentId } : {},
       ...context?.toolCallId !== void 0 ? { toolCallId: context.toolCallId } : {},
       ...context?.metadata !== void 0 ? { metadata: context.metadata } : {},
-      ...context?.answer !== void 0 ? { answer: context.answer } : {}
+      ...context?.answer !== void 0 ? { answer: context.answer } : {},
+      scope,
+      turn
     });
     return result ?? { allow: true };
   }
   async emitAfterToolCall(tool, result, context) {
+    const scope = context?.scope ?? resolveScopeFromMetadata(context?.metadata);
+    const turn = context?.turn ?? {};
     const hookResult = await this.emitHook("after_tool_call", {
       type: "after_tool_call",
       tool,
@@ -5203,7 +5534,9 @@ var ExtensionRunner = class {
       ...context?.runId !== void 0 ? { runId: context.runId } : {},
       ...context?.agentId !== void 0 ? { agentId: context.agentId } : {},
       ...context?.toolCallId !== void 0 ? { toolCallId: context.toolCallId } : {},
-      ...context?.metadata !== void 0 ? { metadata: context.metadata } : {}
+      ...context?.metadata !== void 0 ? { metadata: context.metadata } : {},
+      scope,
+      turn
     });
     return hookResult?.result ?? result;
   }
@@ -5271,9 +5604,43 @@ var ExtensionRunner = class {
       unregisterProvider: (name) => this.unregisterProvider(name),
       registerTool: (tool) => this.registerTool(extension, tool),
       unregisterTool: (toolName) => this.unregisterTool(extension, toolName),
+      contributeCapability: (contribution) => this.contributeCapability(extension, contribution),
       context: extContext,
       manifest,
-      trackCleanup: (cleanup) => extension.cleanup.push(cleanup)
+      trackCleanup: (cleanup) => extension.cleanup.push(cleanup),
+      config: {
+        get: async (scope) => {
+          const effectiveScope = scope ?? { kind: "global" };
+          const res = await runner.host.getConfig(extension.id, effectiveScope);
+          return res ?? null;
+        },
+        changed: (handler) => {
+          let listeners = runner.configChangeListeners.get(extension.id);
+          if (!listeners) {
+            listeners = /* @__PURE__ */ new Set();
+            runner.configChangeListeners.set(extension.id, listeners);
+          }
+          listeners.add(handler);
+          extension.cleanup.push(() => {
+            listeners?.delete(handler);
+            if (listeners && listeners.size === 0) {
+              runner.configChangeListeners.delete(extension.id);
+            }
+          });
+        }
+      },
+      state: {
+        run: (runId) => ({
+          get: async (key) => runner.getRunState(runId, extension.id, key),
+          set: async (key, value) => runner.setRunState(runId, extension.id, key, value),
+          delete: async (key) => runner.deleteRunState(runId, extension.id, key)
+        }),
+        agent: (agentId) => ({
+          get: async (key) => runner.host.getAgentState(extension.id, agentId, key),
+          set: async (key, value) => runner.host.setAgentState(extension.id, agentId, key, value),
+          delete: async (key) => runner.host.deleteAgentState(extension.id, agentId, key)
+        })
+      }
     }, extension.runtime, this.events);
   }
   registerTool(extension, tool) {
@@ -5302,6 +5669,46 @@ var ExtensionRunner = class {
       extension.tools.delete(toolName);
     }
   }
+  contributeCapability(extension, contribution) {
+    const key = `${contribution.kind}:${contribution.name}`;
+    const entry = {
+      kind: contribution.kind,
+      name: contribution.name,
+      description: contribution.description
+    };
+    extension.capabilities.set(key, entry);
+    if (this.extensions.includes(extension)) {
+      this.notifyCapabilitiesChanged();
+    }
+    let disposed = false;
+    const dispose = () => {
+      if (disposed) return;
+      disposed = true;
+      if (extension.capabilities.get(key) === entry) {
+        extension.capabilities.delete(key);
+        if (this.extensions.includes(extension)) {
+          this.notifyCapabilitiesChanged();
+        }
+      }
+    };
+    extension.cleanup.push(dispose);
+    return dispose;
+  }
+  notifyCapabilitiesChanged() {
+    const capabilities = this.getCapabilities();
+    for (const listener of this.capabilityListeners) {
+      try {
+        listener(capabilities);
+      } catch (error) {
+        this.emitError({
+          extensionPath: "<runtime>",
+          event: "capabilities_changed",
+          error: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : void 0
+        });
+      }
+    }
+  }
   async registerPhase(extension, registration) {
     if (typeof registration === "string") {
       if (registration.length === 0) {
@@ -5388,6 +5795,8 @@ var ExtensionRunner = class {
   async disposeExtension(extension, message) {
     extension.runtime.invalidate(message);
     for (const name of extension.phases) this.phases.delete(name);
+    const hadCapabilities = extension.capabilities.size > 0;
+    extension.capabilities.clear();
     for (const cleanup of [...extension.cleanup].reverse()) {
       await Promise.resolve().then(() => cleanup()).catch(() => void 0);
     }
@@ -5395,6 +5804,9 @@ var ExtensionRunner = class {
       await Promise.resolve().then(() => extension.disposer()).catch(() => void 0);
     }
     this._phaseCache = null;
+    if (hadCapabilities) {
+      this.notifyCapabilitiesChanged();
+    }
   }
 };
 function createExtensionRunner(options) {
@@ -5425,6 +5837,8 @@ function readManifestSync(dir) {
     const rowan = pkg.rowan;
     if (!rowan) return void 0;
     return {
+      id: rowan.id ?? pkg.name,
+      name: pkg.name,
       entry: rowan.extensions?.[0]
     };
   } catch {
@@ -5507,13 +5921,15 @@ async function discoverExtensionsInDir(dir) {
   }
   return paths;
 }
-function loadExtensionFromFactory(factory, cwd, extensionPath = "<inline>") {
+function loadExtensionFromFactory(factory, cwd, extensionPath = "<inline>", options = {}) {
   const resolvedCwd = resolve6(cwd);
   const resolvedPath = isSyntheticPath(extensionPath) ? extensionPath : resolve6(resolvedCwd, extensionPath);
-  const name = isSyntheticPath(extensionPath) ? extensionPath : basename3(dirname6(resolvedPath)) || "unknown";
+  const name = options.name ?? (isSyntheticPath(extensionPath) ? extensionPath : basename3(dirname6(resolvedPath)) || "unknown");
   const manifestDir = isSyntheticPath(extensionPath) ? resolvedCwd : dirname6(resolvedPath);
   const manifest = readManifestSync(manifestDir);
+  const id = options.id ?? manifest?.id ?? name;
   return {
+    id,
     path: resolvedPath,
     name,
     factory,
@@ -5983,6 +6399,12 @@ var RuntimeExtensionLifetime = class {
   get extensionRunner() {
     return this.runner;
   }
+  get extensionHost() {
+    return this.runner.extensionHost;
+  }
+  dropRunState(runId) {
+    this.runner.dropRunState(runId);
+  }
   async close() {
     if (this.closed) return;
     this.closed = true;
@@ -5996,6 +6418,9 @@ var RuntimeBootstrapRegistry = class extends ResourceRegistry {
   }
   extensions;
   extensionSourceId = "rowan.extensions";
+  get extensionHost() {
+    return this.extensions.extensionHost;
+  }
   /** Install Rowan-owned implicit resources before any host source is read. */
   async ensureCoreResources() {
     await this.replaceImplicit("tool", "rowan.core", [createRouteTool([])]);
@@ -6134,11 +6559,14 @@ var AgentRuntime = class _AgentRuntime {
   autoCompactionRuns = /* @__PURE__ */ new Set();
   consumers = /* @__PURE__ */ new Map();
   transientEvents = new TransientRunEventHub();
+  host;
   resources;
+  startedRuns = /* @__PURE__ */ new Set();
   heartbeat;
   pumping = false;
   closed = false;
   constructor(options, owned, resources) {
+    this.host = options.host;
     this.owned = owned;
     this.commands = new ConfigCommandService(owned, options.configs, String(owned.lease.token).split(":")[0]);
     this.storeIncarnation = String(owned.lease.token).split(":")[0];
@@ -6148,10 +6576,12 @@ var AgentRuntime = class _AgentRuntime {
   static async init(options) {
     if (!options.store) throw new TypeError("AgentRuntime requires a DurableStore");
     const configs = options.configs ?? new InMemoryConfigProvider();
+    const host = options.host ?? new InMemoryExtensionHost();
     const concurrency = options.concurrency ?? DEFAULT_CONCURRENCY;
     if (!Number.isInteger(concurrency) || concurrency <= 0) throw new TypeError("concurrency must be a positive integer");
     const owned = await options.store.openOwner({ ownerId: createId("owner"), leaseMs: OWNER_LEASE_MS });
-    const runtime = new _AgentRuntime({ ...options, configs, concurrency }, owned, new RuntimeBootstrapRegistry());
+    const extensions = new RuntimeExtensionLifetime({ host });
+    const runtime = new _AgentRuntime({ ...options, configs, concurrency, host }, owned, new RuntimeBootstrapRegistry(extensions));
     try {
       await runtime.resources.ensureCoreResources();
       await options.bootstrap?.(runtime.resources);
@@ -6164,6 +6594,20 @@ var AgentRuntime = class _AgentRuntime {
       throw error;
     }
   }
+  async handleRunEnd(runId, agentId, outcome) {
+    if (this.startedRuns.has(runId)) {
+      this.startedRuns.delete(runId);
+      try {
+        await this.resources.extensionRunner.emitRunEnd({
+          runId,
+          agentId,
+          outcome
+        });
+      } catch {
+      }
+    }
+    this.resources.extensionRunner.dropRunState(runId);
+  }
   async loadAgents(input) {
     this.assertOpen();
     return this.resources.loadAgents(input);
@@ -6374,6 +6818,14 @@ var AgentRuntime = class _AgentRuntime {
     });
     return { caughtUp: subscription.caughtUp.promise, done: subscription.done.promise, stop: () => controller.abort() };
   }
+  listCapabilities() {
+    this.assertOpen();
+    return this.resources.extensionRunner.getCapabilities();
+  }
+  onCapabilitiesChanged(listener) {
+    this.assertOpen();
+    return this.resources.extensionRunner.onCapabilitiesChanged(listener);
+  }
   async close() {
     if (this.closed) return;
     this.closed = true;
@@ -6417,6 +6869,11 @@ var AgentRuntime = class _AgentRuntime {
     const active = this.executions.get(runId);
     if (active) this.transientEvents.clear(runId, active.executionId);
     active?.controller.abort();
+    if (this.startedRuns.has(runId)) {
+      await this.handleRunEnd(runId, snapshot.agentId, { id: createId("out"), status: "cancelled", message: reason ?? "Agent run stopped." });
+    } else {
+      this.resources.extensionRunner.dropRunState(runId);
+    }
     return boundaryFromSnapshot(await this.owned.snapshotRun(runId));
   }
   async pump() {
@@ -6528,6 +6985,19 @@ var AgentRuntime = class _AgentRuntime {
       const controller = new AbortController();
       this.executions.set(run.id, { controller, executionId });
       if (this.cancellationRequested.has(run.id)) controller.abort();
+      if (!this.startedRuns.has(run.id)) {
+        this.startedRuns.add(run.id);
+        const turn = typeof run.input === "object" && run.input !== null && !Array.isArray(run.input) ? run.input : {};
+        try {
+          await this.resources.extensionRunner.emitRunStart({
+            runId: run.id,
+            agentId: run.agentId,
+            metadata: run.metadata ?? {},
+            turn
+          });
+        } catch {
+        }
+      }
       const assembly = assembleRegisteredExtensions(config, this.resources.extensionRunner, {
         toolArchiveDir: this.archiveDirFor(run.agentId)
       });
@@ -6754,6 +7224,11 @@ var AgentRuntime = class _AgentRuntime {
           ...output && hasVisibleAssistantText(output) ? { output } : {}
         });
         this.transientEvents.clear(run.id, claim.execution.executionId);
+        await this.handleRunEnd(run.id, run.agentId, {
+          id: createId("out"),
+          status: "cancelled",
+          message: reason
+        });
         return;
       }
       if (result.type === "input_required") {
@@ -6789,33 +7264,53 @@ var AgentRuntime = class _AgentRuntime {
         const output = latestAssistant(run, result.messages, executionContext.messages.length);
         await this.owned.commitOutcome({ runId: run.id, execution: claim.execution, expectedRevision: executionRevision, outcome: durableOutcome(result.outcome), ...output ? { output } : {} });
         this.transientEvents.clear(run.id, claim.execution.executionId, true);
+        await this.handleRunEnd(run.id, run.agentId, result.outcome);
         return;
       }
       const failure = { code: "execution_failed", message: result.error instanceof Error ? result.error.message : "Execution failed." };
       await this.owned.commitOutcome({ runId: run.id, execution: claim.execution, expectedRevision: executionRevision, failure });
       this.transientEvents.clear(run.id, claim.execution.executionId);
+      await this.handleRunEnd(run.id, run.agentId, {
+        id: createId("out"),
+        status: "failed",
+        message: failure.message,
+        error: failure
+      });
     } catch (error) {
       if (!claim && error instanceof RuntimeError && ["run_state_conflict", "runtime_ownership_lost", "run_not_found"].includes(error.code)) return;
       if (claim) {
         if (this.cancellationRequested.has(run.id)) {
+          const reason = this.cancellationReasons.get(run.id) ?? "Agent run stopped.";
           await this.owned.cancelRun({
             runId: run.id,
             expectedRevision: executionRevision,
-            reason: this.cancellationReasons.get(run.id) ?? "Agent run stopped."
+            reason
           }).catch(() => void 0);
+          await this.handleRunEnd(run.id, run.agentId, {
+            id: createId("out"),
+            status: "cancelled",
+            message: reason
+          });
           return;
         }
+        const failureMessage = error instanceof Error ? error.message : "Execution failed.";
         await this.owned.commitOutcome({
           runId: run.id,
           execution: claim.execution,
           expectedRevision: executionRevision,
-          failure: { code: "execution_failed", message: error instanceof Error ? error.message : "Execution failed." }
+          failure: { code: "execution_failed", message: failureMessage }
         }).catch(async (commitError) => {
           await this.owned.cancelRun({
             runId: run.id,
             reason: commitError instanceof Error ? commitError.message : "Run failure could not be committed."
           }).catch(() => void 0);
         });
+        await this.handleRunEnd(run.id, run.agentId, {
+          id: createId("out"),
+          status: "failed",
+          message: failureMessage,
+          error: { code: "execution_failed", message: failureMessage }
+        });
         return;
       }
       throw error;
@@ -6838,6 +7333,8 @@ var AgentRuntime = class _AgentRuntime {
     return { result: batch.results[0], revision: batch.revision };
   }
   async executeToolBatch(input) {
+    const scope = resolveScopeFromMetadata(input.run.metadata);
+    const turn = typeof input.run.input === "object" && input.run.input !== null && !Array.isArray(input.run.input) ? input.run.input : {};
     const checkpoint = input.driver?.checkpoint();
     const isSuspensionResume = checkpoint && typeof checkpoint === "object" && checkpoint.kind === "tool_call_suspension";
     const suspension = isSuspensionResume ? checkpoint : void 0;
@@ -6864,6 +7361,8 @@ var AgentRuntime = class _AgentRuntime {
           ...input.agentMetadata === void 0 ? {} : { agentMetadata: input.agentMetadata },
           ...input.run.metadata === void 0 ? {} : { runMetadata: input.run.metadata },
           toolCallId,
+          scope,
+          turn,
           interaction: createRunInteractionDriver({
             currentPhase: "default",
             attempt: 0,
@@ -6951,6 +7450,8 @@ var AgentRuntime = class _AgentRuntime {
             ...input.agentMetadata === void 0 ? {} : { agentMetadata: input.agentMetadata },
             ...input.run.metadata === void 0 ? {} : { runMetadata: input.run.metadata },
             toolCallId,
+            scope,
+            turn,
             interaction: createToolInteractionDriver(input.driver, {
               toolCallId,
               toolCallIds,
@@ -7105,6 +7606,8 @@ var AgentRuntime = class _AgentRuntime {
         ...input.agentMetadata === void 0 ? {} : { agentMetadata: input.agentMetadata },
         ...input.run.metadata === void 0 ? {} : { runMetadata: input.run.metadata },
         toolCallId,
+        scope,
+        turn,
         interaction: createToolInteractionDriver(input.driver, {
           toolCallId,
           ...suspension?.toolCallIds === void 0 ? {} : { toolCallIds: suspension.toolCallIds },
@@ -10620,6 +11123,7 @@ export {
   DEFAULT_PHASE_ID,
   ExtensionLifetimeError,
   InMemoryConfigProvider,
+  InMemoryExtensionHost,
   InMemoryStore,
   ResourceRegistry,
   ResourceRegistryError,

package/package.json

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