@rowan-agent/agent 0.9.11 → 0.9.12

package/dist/index.d.ts

@@ -55,6 +55,159 @@ type ToolResult = {
     error?: string;
 };
 
+interface BeforePhaseEvent {
+    type: "before_phase";
+    phaseId: string;
+    input: PhaseContext;
+}
+interface AfterPhaseEvent {
+    type: "after_phase";
+    phaseId: string;
+    output: PhaseOutput;
+}
+interface BeforePromptEvent {
+    type: "before_prompt";
+    phaseId: string;
+    input: PhaseContext;
+}
+interface BeforeToolCallEvent {
+    type: "before_tool_call";
+    tool: Tool$1;
+    args: unknown;
+}
+interface AfterToolCallEvent {
+    type: "after_tool_call";
+    tool: Tool$1;
+    result: ToolResult;
+}
+type HookEvent = BeforePhaseEvent | AfterPhaseEvent | BeforePromptEvent | BeforeToolCallEvent | AfterToolCallEvent;
+interface BeforePhaseResult {
+    abort?: Outcome$1;
+    skip?: {
+        route: string;
+        message: string;
+    };
+    input?: PhaseContext;
+}
+interface AfterPhaseResult {
+    abort?: Outcome$1;
+    retry?: PhaseContext;
+    output?: PhaseOutput;
+}
+interface BeforePromptResult {
+    input?: PhaseContext;
+}
+interface BeforeToolCallResult {
+    allow: boolean;
+    reason?: string;
+}
+interface AfterToolCallResult {
+    result?: ToolResult;
+}
+interface HookResultMap {
+    before_phase: BeforePhaseResult | undefined;
+    after_phase: AfterPhaseResult | undefined;
+    before_prompt: BeforePromptResult | undefined;
+    before_tool_call: BeforeToolCallResult | undefined;
+    after_tool_call: AfterToolCallResult | undefined;
+}
+type HookEventType = HookEvent["type"];
+type HookHandler<K extends HookEventType> = (event: Extract<HookEvent, {
+    type: K;
+}>) => HookResultMap[K] | Promise<HookResultMap[K]> | void | Promise<void>;
+declare class HooksManager {
+    private handlers;
+    on<K extends HookEventType>(eventType: K, handler: HookHandler<K>): void;
+    off<K extends HookEventType>(eventType: K, handler: HookHandler<K>): void;
+    emit<K extends HookEventType>(eventType: K, event: Extract<HookEvent, {
+        type: K;
+    }>): Promise<void>;
+    emitFirst<K extends HookEventType>(eventType: K, event: Extract<HookEvent, {
+        type: K;
+    }>): Promise<HookResultMap[K] | undefined>;
+}
+
+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 ExecutionState = {
+    currentPhase: string;
+    attempt: number;
+    metrics: LoopMetrics;
+    status: "idle" | "running" | "suspended" | "completed" | "aborted" | "failed";
+    continuation?: ExecutionContinuationState;
+    phaseInteractions?: PhaseInteractionState;
+};
+type ExecutionContinuationState = {
+    isContinuing: boolean;
+    previousPayload?: unknown;
+    previousResults: Array<{
+        name: string;
+        output?: unknown;
+    }>;
+    pendingInstruction?: string;
+    previousPhaseMessageId?: string;
+};
+
+type PhaseInteractionKind = "user_input" | "permission" | "elicitation" | "confirmation";
+type PhaseInteractionStatus = "pending" | "answered" | "denied" | "cancelled" | "expired";
+type PhaseInteraction = Readonly<{
+    id: string;
+    phase: string;
+    kind: PhaseInteractionKind;
+    prompt: string;
+    payload?: JsonValue;
+    createdAt: string;
+    status: PhaseInteractionStatus;
+}>;
+type PhaseInteractionState = Readonly<{
+    requests: readonly PhaseInteraction[];
+    answers: Readonly<Record<string, JsonValue>>;
+    checkpoint?: JsonValue;
+}>;
+type PhaseInteractionDriver = Readonly<{
+    signal: AbortSignal;
+    request(input: Readonly<{
+        id?: string;
+        kind: PhaseInteractionKind;
+        prompt: string;
+        payload?: JsonValue;
+    }>): PhaseInteraction;
+    pending(): readonly PhaseInteraction[];
+    answers(): ReadonlyMap<string, JsonValue>;
+    suspend(input?: Readonly<{
+        checkpoint?: JsonValue;
+    }>): never;
+}>;
+declare class PhaseInteractionCancelledError extends Error {
+    readonly code: "phase_interaction_cancelled";
+    constructor();
+}
+declare class PhaseInteractionBoundary extends Error {
+    readonly state: ExecutionState;
+    readonly interactions: readonly PhaseInteraction[];
+    constructor(state: ExecutionState, interactions: readonly PhaseInteraction[]);
+}
+
 /** Durable and transient DTOs owned by the event-driven Agent Runtime. */
 
 declare const opaqueIdBrand: unique symbol;
@@ -387,159 +540,6 @@ type PhaseStatusEvent = Readonly<{
 }>;
 type RunEvent = DurableRunEvent | MessageDelta | ThinkingDelta | ToolProgress | PhaseStatusEvent;
 
-interface BeforePhaseEvent {
-    type: "before_phase";
-    phaseId: string;
-    input: PhaseContext;
-}
-interface AfterPhaseEvent {
-    type: "after_phase";
-    phaseId: string;
-    output: PhaseOutput;
-}
-interface BeforePromptEvent {
-    type: "before_prompt";
-    phaseId: string;
-    input: PhaseContext;
-}
-interface BeforeToolCallEvent {
-    type: "before_tool_call";
-    tool: Tool$1;
-    args: unknown;
-}
-interface AfterToolCallEvent {
-    type: "after_tool_call";
-    tool: Tool$1;
-    result: ToolResult;
-}
-type HookEvent = BeforePhaseEvent | AfterPhaseEvent | BeforePromptEvent | BeforeToolCallEvent | AfterToolCallEvent;
-interface BeforePhaseResult {
-    abort?: Outcome$1;
-    skip?: {
-        route: string;
-        message: string;
-    };
-    input?: PhaseContext;
-}
-interface AfterPhaseResult {
-    abort?: Outcome$1;
-    retry?: PhaseContext;
-    output?: PhaseOutput;
-}
-interface BeforePromptResult {
-    input?: PhaseContext;
-}
-interface BeforeToolCallResult {
-    allow: boolean;
-    reason?: string;
-}
-interface AfterToolCallResult {
-    result?: ToolResult;
-}
-interface HookResultMap {
-    before_phase: BeforePhaseResult | undefined;
-    after_phase: AfterPhaseResult | undefined;
-    before_prompt: BeforePromptResult | undefined;
-    before_tool_call: BeforeToolCallResult | undefined;
-    after_tool_call: AfterToolCallResult | undefined;
-}
-type HookEventType = HookEvent["type"];
-type HookHandler<K extends HookEventType> = (event: Extract<HookEvent, {
-    type: K;
-}>) => HookResultMap[K] | Promise<HookResultMap[K]> | void | Promise<void>;
-declare class HooksManager {
-    private handlers;
-    on<K extends HookEventType>(eventType: K, handler: HookHandler<K>): void;
-    off<K extends HookEventType>(eventType: K, handler: HookHandler<K>): void;
-    emit<K extends HookEventType>(eventType: K, event: Extract<HookEvent, {
-        type: K;
-    }>): Promise<void>;
-    emitFirst<K extends HookEventType>(eventType: K, event: Extract<HookEvent, {
-        type: K;
-    }>): Promise<HookResultMap[K] | undefined>;
-}
-
-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 ExecutionState = {
-    currentPhase: string;
-    attempt: number;
-    metrics: LoopMetrics;
-    status: "idle" | "running" | "suspended" | "completed" | "aborted" | "failed";
-    continuation?: ExecutionContinuationState;
-    phaseInteractions?: PhaseInteractionState;
-};
-type ExecutionContinuationState = {
-    isContinuing: boolean;
-    previousPayload?: unknown;
-    previousResults: Array<{
-        name: string;
-        output?: unknown;
-    }>;
-    pendingInstruction?: string;
-    previousPhaseMessageId?: string;
-};
-
-type PhaseInteractionKind = "user_input" | "permission" | "elicitation" | "confirmation";
-type PhaseInteractionStatus = "pending" | "answered" | "denied" | "cancelled" | "expired";
-type PhaseInteraction = Readonly<{
-    id: string;
-    phase: string;
-    kind: PhaseInteractionKind;
-    prompt: string;
-    payload?: JsonValue;
-    createdAt: string;
-    status: PhaseInteractionStatus;
-}>;
-type PhaseInteractionState = Readonly<{
-    requests: readonly PhaseInteraction[];
-    answers: Readonly<Record<string, JsonValue>>;
-    checkpoint?: JsonValue;
-}>;
-type PhaseInteractionDriver = Readonly<{
-    signal: AbortSignal;
-    request(input: Readonly<{
-        id?: string;
-        kind: PhaseInteractionKind;
-        prompt: string;
-        payload?: JsonValue;
-    }>): PhaseInteraction;
-    pending(): readonly PhaseInteraction[];
-    answers(): ReadonlyMap<string, JsonValue>;
-    suspend(input?: Readonly<{
-        checkpoint?: JsonValue;
-    }>): never;
-}>;
-declare class PhaseInteractionCancelledError extends Error {
-    readonly code: "phase_interaction_cancelled";
-    constructor();
-}
-declare class PhaseInteractionBoundary extends Error {
-    readonly state: ExecutionState;
-    readonly interactions: readonly PhaseInteraction[];
-    constructor(state: ExecutionState, interactions: readonly PhaseInteraction[]);
-}
-
 type ModelInvokeOutput = {
     text: string;
     contentBlocks: ContentBlock[];
@@ -932,6 +932,8 @@ type PhaseExecutionIdentity = Readonly<{
     agentId: string;
     runId: string;
     executionId: string;
+    /** Original durable Run input, before any Phase-local interpretation. */
+    input?: UserContent;
     /** Opaque metadata captured at the durable boundary; Rowan does not decode it. */
     agentMetadata?: Readonly<Record<string, unknown>>;
     runMetadata?: Readonly<Record<string, unknown>>;
@@ -1378,6 +1380,8 @@ type AgentConfiguration = Readonly<{
     }>;
     resourceView: ResourceView;
     contexts?: readonly ContextCandidate[];
+    /** Trusted Host-owned Contexts appended after Definition selection. */
+    additionalContexts?: readonly ContextCandidate[];
     cwd?: string;
     maxAttempts?: number;
     model: ModelConfig | ModelRef;
@@ -1938,6 +1942,7 @@ interface AgentRuntime$1 {
         contextWindow?: number;
     }): Promise<ContextStatus>;
     compactContext(agentId: AgentId, options?: {
+        input?: UserInput;
         instructions?: string;
         idempotencyKey?: string;
     }): Promise<AgentRun>;
@@ -2029,6 +2034,7 @@ declare class AgentRuntime implements AgentRuntime$1 {
         contextWindow?: number;
     }): Promise<ContextStatus>;
     compactContext(agentId: AgentId, options?: {
+        input?: UserInput;
         instructions?: string;
         idempotencyKey?: string;
     }): Promise<AgentRun>;

package/dist/index.js

@@ -1751,7 +1751,7 @@ async function loadPhaseCode(codePath) {
   throw new Error(`Phase code at "${codePath}" must export a default function or a run() function.`);
 }
 
-// src/harness/phases/default.ts
+// src/harness/phases/core-phases.ts
 var DEFAULT_PHASE_ID = "default";
 var STOP_PHASE_ID = "stop";
 var COMPACT_PHASE_ID = "compact";
@@ -1809,6 +1809,14 @@ function createCompactPhase() {
       });
       const tools = context.tools.filter((tool) => tool.core && (tool.name === "read" || tool.name === "bash"));
       const working = { ...context, tools, skills: [...context.skills], messages: [...context.messages] };
+      const instructions = compactInstructions(context);
+      if (instructions) {
+        working.messages.push(createMessage("user", `Additional compaction instructions:
+${instructions}`, {
+          kind: "phase_input",
+          phase: COMPACT_PHASE_ID
+        }));
+      }
       let result = await execution.invokeModel(working, { output: "internal" });
       for (let attempt = 0; attempt < 8 && result.toolCalls.length > 0; attempt += 1) {
         const calls = result.toolCalls.filter((call) => tools.some((tool) => tool.name === call.name));
@@ -1860,7 +1868,11 @@ function createCompactPhase() {
       return {
         route: "stop",
         phase: COMPACT_PHASE_ID,
-        payload: { kind: "context_compaction", summary: result.text },
+        payload: {
+          kind: "context_compaction",
+          summary: result.text,
+          ...instructions ? { instructions } : {}
+        },
         status: {
           state: "completed",
           kind: "compacted",
@@ -1870,6 +1882,21 @@ function createCompactPhase() {
     }
   };
 }
+function compactInstructions(context) {
+  const rowan = context.execution.runMetadata?.rowan;
+  if (typeof rowan === "object" && rowan !== null && !Array.isArray(rowan)) {
+    const configured = rowan.instructions;
+    if (typeof configured === "string" && configured.trim().length > 0) {
+      return configured.trim();
+    }
+  }
+  const input = context.execution.input;
+  if (input === void 0) return void 0;
+  const text = typeof input === "string" ? input : input.filter((part) => part.type === "text").map((part) => part.text).join("");
+  const match = text.match(/^\/compact(?:\s+([\s\S]*))?$/i);
+  const instructions = match?.[1]?.trim();
+  return instructions || void 0;
+}
 function createCorePhases() {
   return [createDefaultPhase(), createStopPhase(), createCompactPhase()];
 }
@@ -3378,6 +3405,10 @@ function assertAgentConfigRequest(config) {
     if (typeof context.name !== "string" || context.name.trim() === "") throw new TypeError("Context candidate name must be non-empty");
     assertJsonValue(context.value, `Context candidate "${context.name}" value`);
   }
+  for (const context of config.additionalContexts ?? []) {
+    if (typeof context.name !== "string" || context.name.trim() === "") throw new TypeError("Additional Context candidate name must be non-empty");
+    assertJsonValue(context.value, `Additional Context candidate "${context.name}" value`);
+  }
 }
 function assertToolExecutionResult(value) {
   if (!isToolResult(value)) throw new TypeError("Tool result must be JSON-safe and contain no Runtime identity");
@@ -3563,6 +3594,12 @@ function snapshotConfiguration(config) {
         name: context.name,
         value: snapshotJsonValue(context.value)
       })))
+    } : {},
+    ...config.additionalContexts ? {
+      additionalContexts: Object.freeze(config.additionalContexts.map((context) => Object.freeze({
+        name: context.name,
+        value: snapshotJsonValue(context.value)
+      })))
     } : {}
   });
 }
@@ -5474,14 +5511,18 @@ function resolveConfigurationSnapshot(registry, input) {
     throw new Error(`Agent Definition "${input.definition.name}" is not available in the Resource View.`);
   }
   const layer = input.definition.layer;
-  const definition = applyDefinitionLayer(base, layer);
+  const selectedContexts = selectNamedResources(input.contexts ?? [], base.contexts, "Context");
+  const contexts = appendAdditionalContexts(selectedContexts, input.additionalContexts ?? []);
+  const definition = addAdditionalContextNames(
+    applyDefinitionLayer(base, layer),
+    contexts.slice(selectedContexts.length).map(({ name }) => name)
+  );
   const tools = selectNamedResources(resolved.tools, definition.tools, "Tool");
   const skills = mergeSkills(
     selectNamedResources(resolved.skills, definition.skills, "Skill"),
     definition.bundledSkills
   );
   const phases = resolvePhases(resolved.phases, definition.phases);
-  const contexts = selectNamedResources(input.contexts ?? [], base.contexts, "Context");
   return {
     identity: input.identity,
     definition,
@@ -5539,6 +5580,22 @@ function applyDefinitionLayer(base, layer) {
     ...layer.phases === void 0 ? {} : { phases: intersectPhaseSelection(base.phases, layer.phases) }
   };
 }
+function appendAdditionalContexts(selected, additional) {
+  const contexts = [...selected];
+  const seen = new Set(contexts.map(({ name }) => name));
+  for (const context of additional) {
+    if (seen.has(context.name)) continue;
+    seen.add(context.name);
+    contexts.push(context);
+  }
+  return contexts;
+}
+function addAdditionalContextNames(definition, names) {
+  if (definition.contexts === void 0 || names.length === 0) return definition;
+  const existing = new Set(definition.contexts);
+  const additions = names.filter((name) => !existing.has(name));
+  return additions.length === 0 ? definition : { ...definition, contexts: [...definition.contexts, ...additions] };
+}
 function intersectNames(parent, layer, kind) {
   if (parent === void 0) return [...layer];
   const parentNames = new Set(parent);
@@ -5735,7 +5792,9 @@ var AgentRuntime = class _AgentRuntime {
     };
     const run = await this.owned.createRun({
       agentId,
-      input: "",
+      // An empty input is a system-triggered Control Run. A non-empty input
+      // represents a user invocation and is committed by the Durable Store.
+      input: options.input ?? "",
       metadata,
       idempotencyKey: options.idempotencyKey ?? createId("compact")
     });
@@ -6002,17 +6061,6 @@ var AgentRuntime = class _AgentRuntime {
             ...executionContext2.phases,
             entryPhaseId: COMPACT_PHASE_ID
           };
-          const instructions = controlKind === "compact" ? compactInstructions(run) : void 0;
-          if (instructions) {
-            executionContext2.messages.push({
-              id: createId("msg"),
-              role: "user",
-              content: `Additional compaction instructions:
-${instructions}`,
-              createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-              metadata: { kind: "phase_input", phase: COMPACT_PHASE_ID }
-            });
-          }
         }
         return executionContext2;
       };
@@ -6029,6 +6077,7 @@ ${instructions}`,
           agentId: run.agentId,
           runId: run.id,
           executionId: claim.execution.executionId,
+          input: typeof run.input === "string" ? run.input : run.input.content,
           ...agent.metadata === void 0 ? {} : { agentMetadata: agent.metadata },
           ...run.metadata === void 0 ? {} : { runMetadata: run.metadata }
         },
@@ -6175,6 +6224,7 @@ ${instructions}`,
         const output = latestAssistant(run, result.messages.slice(modelMessages.length), modelMessages.length);
         if (controlKind === "compact" || isCompactionOutcome(result.outcome.payload)) {
           const summary = compactSummary(result.outcome.payload);
+          const instructions = compactInstructions2(run) ?? compactOutputInstructions(result.outcome.payload);
           if (summary) {
             const covered = claim.history.at(-1);
             const record = {
@@ -6182,7 +6232,7 @@ ${instructions}`,
               agentId: run.agentId,
               summary,
               ...covered ? { coveredThrough: { messageId: covered.id, sequence: covered.sequenceWithinRun } } : {},
-              ...compactInstructions(run) ? { instructions: compactInstructions(run) } : {},
+              ...instructions ? { instructions } : {},
               createdAt: (/* @__PURE__ */ new Date()).toISOString()
             };
             await this.owned.commitContextCompaction(record);
@@ -6527,7 +6577,7 @@ function controlRunKind(run) {
   const kind = rowan.kind;
   return typeof kind === "string" ? kind : void 0;
 }
-function compactInstructions(run) {
+function compactInstructions2(run) {
   const rowan = run.metadata?.rowan;
   if (typeof rowan !== "object" || rowan === null || !("instructions" in rowan)) return void 0;
   const instructions = rowan.instructions;
@@ -6538,6 +6588,11 @@ function compactSummary(payload) {
   const summary = payload.summary;
   return typeof summary === "string" && summary.trim().length > 0 ? summary : void 0;
 }
+function compactOutputInstructions(payload) {
+  if (typeof payload !== "object" || payload === null || !("instructions" in payload)) return void 0;
+  const instructions = payload.instructions;
+  return typeof instructions === "string" && instructions.trim().length > 0 ? instructions.trim() : void 0;
+}
 function isCompactionOutcome(payload) {
   return typeof payload === "object" && payload !== null && "kind" in payload && payload.kind === "context_compaction";
 }
@@ -7012,7 +7067,7 @@ var InMemoryStore = class _InMemoryStore {
     }
     if (!run.pinnedConfigToken && input.configToken) run.pinnedConfigToken = input.configToken;
     let message;
-    if (!run.checkpoint && !run.initialMessageId && !isControlRun(run)) {
+    if (!run.checkpoint && !run.initialMessageId && (!isControlRun(run) || hasUserInput(run.input))) {
       const userInput = normalizeUserInput(run.input);
       message = {
         id: input.messageId ?? createId("msg"),
@@ -7930,12 +7985,16 @@ function ownershipLost(expected, actual, reason) {
 function userInputContent(input) {
   return typeof input === "string" ? input : input.content;
 }
+function hasUserInput(input) {
+  const content = userInputContent(input);
+  return content.length > 0;
+}
 function userInputMetadata(input) {
   return typeof input === "string" ? void 0 : input.metadata;
 }
 function isControlRun(run) {
   const rowan = run.metadata?.rowan;
-  return typeof rowan === "object" && rowan !== null && "kind" in rowan && rowan.kind === "compact";
+  return typeof rowan === "object" && rowan !== null && typeof rowan.kind === "string" && rowan.kind.length > 0;
 }
 function estimateMessageTokens(messages) {
   let characters = 0;

package/package.json

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