@rowan-agent/agent 0.9.8 → 0.9.9

package/dist/index.js

@@ -1,6 +1,7 @@
 // src/harness/tools/index.ts
-import { mkdir, readFile as readFile2, stat, writeFile } from "fs/promises";
+import { chmod, mkdir, readFile as readFile2, stat, writeFile } from "fs/promises";
 import { basename as basename2, dirname as dirname2, relative as relative2, resolve as resolve2 } from "path";
+import { tmpdir } from "os";
 import Type2 from "typebox";
 import Schema from "typebox/schema";
 
@@ -20,7 +21,7 @@ function buildStructuredSection(tag, items) {
   return lines.join("\n");
 }
 function buildSkillsDescription(skills) {
-  const visibleSkills = skills.filter((skill) => !skill.disableModelInvocation);
+  const visibleSkills = skills.filter((skill) => !(skill.disableAutoInvocation ?? skill.disableModelInvocation));
   if (visibleSkills.length === 0) return "";
   const lines = ["<available_skills>"];
   for (const skill of visibleSkills) {
@@ -170,11 +171,12 @@ function buildPhaseEntry(p) {
   return entry;
 }
 function buildRouteDescription(availablePhases) {
+  const routablePhases = availablePhases.filter(({ name }) => name !== "stop");
   const phasesBlock = buildStructuredSection("phase", [
-    ...availablePhases.map(buildPhaseEntry),
+    ...routablePhases.map(buildPhaseEntry),
     {
       name: "stop",
-      description: "Explicitly finish the current user request or task when no further user input is needed"
+      description: "Complete the task; when the current reply has no final user-facing conclusion, the built-in Stop Phase provides one"
     }
   ]);
   return [
@@ -183,7 +185,7 @@ function buildRouteDescription(availablePhases) {
     "Rules:",
     "- Call route only to continue execution immediately in one or more phases, or to explicitly stop.",
     "- `decision` lists phase executions; a single target equal to the current phase starts another iteration of that phase.",
-    "- `stop` means the current user request or task is complete and no further user input is needed; `stop` must be the only target.",
+    "- `stop` completes the task; when the current reply has no final user-facing conclusion, the built-in Stop Phase provides one. Use it only when the task is complete and no further user input is needed, and make it the only target.",
     "- Each target may include `phase`, `reason`, `payload`.",
     "- A phase may appear multiple times as independent execution instances.",
     "- `payload` MUST match the phase's `payload_schema`",
@@ -197,9 +199,10 @@ function buildRouteDescription(availablePhases) {
   ].join("\n");
 }
 function createRouteTool(availablePhases) {
+  const routablePhases = availablePhases.filter(({ name }) => name !== "stop");
   const DecisionTarget = Type.Object({
     phase: Type.Union([
-      ...availablePhases.map((p) => Type.Literal(p.name)),
+      ...routablePhases.map((p) => Type.Literal(p.name)),
       Type.Literal("stop")
     ]),
     reason: Type.Optional(Type.String({ description: "Brief reason for this decision" })),
@@ -208,10 +211,10 @@ function createRouteTool(availablePhases) {
   return {
     name: PhaseRouteTool,
     description: buildRouteDescription(availablePhases),
-    promptSnippet: "Route is optional: omit it to remain in the current phase and wait for user input; use it for immediate phase execution or an explicit stop.",
+    promptSnippet: "Route is optional: omit it to remain in the current phase and wait for user input; use it for immediate phase execution, or use stop to complete the task and obtain a final user-facing conclusion when needed.",
     promptGuidelines: [
       "Do not call route together with ordinary tools.",
-      "Use route(stop) only when the current user request or task is complete and no further user input is needed."
+      "Use route(stop) only when the current user request or task is complete; the Stop Phase will provide the final user-facing conclusion."
     ],
     parameters: Type.Object({
       decision: Type.Array(DecisionTarget, { description: "Phase executions to start", minItems: 1 }),
@@ -264,7 +267,8 @@ function extractRouteCall(toolCalls) {
 }
 
 // src/harness/tools/index.ts
-var DEFAULT_MAX_READ_BYTES = 64e3;
+var DEFAULT_MAX_READ_BYTES = 50 * 1024;
+var DEFAULT_MAX_READ_LINES = 2e3;
 var DEFAULT_BASH_TIMEOUT_MS = 3e4;
 var DEFAULT_MAX_BASH_OUTPUT_BYTES = 64e3;
 var ReadArgsSchema = Type2.Object({
@@ -311,7 +315,9 @@ function normalizeCoreToolInputPath(path = ".") {
 function createCoreToolContext(input = {}) {
   return {
     root: resolve2(input.root ?? process.cwd()),
+    archiveDir: resolve2(input.archiveDir ?? `${tmpdir()}/rowan-tool-results`),
     maxReadBytes: input.maxReadBytes ?? DEFAULT_MAX_READ_BYTES,
+    maxReadLines: input.maxReadLines ?? DEFAULT_MAX_READ_LINES,
     bashTimeoutMs: input.bashTimeoutMs ?? DEFAULT_BASH_TIMEOUT_MS,
     maxBashOutputBytes: input.maxBashOutputBytes ?? DEFAULT_MAX_BASH_OUTPUT_BYTES
   };
@@ -449,17 +455,9 @@ async function captureStream(stream, maxBytes) {
     if (!value) {
       continue;
     }
-    const remainingBytes = maxBytes - totalBytes;
-    if (remainingBytes > 0) {
-      const kept = value.subarray(0, remainingBytes);
-      chunks.push(kept);
-      totalBytes += kept.byteLength;
-    }
-    if (value.byteLength > remainingBytes || totalBytes >= maxBytes) {
-      truncated = true;
-      await reader.cancel().catch(() => void 0);
-      break;
-    }
+    chunks.push(value);
+    totalBytes += value.byteLength;
+    if (totalBytes > maxBytes) truncated = true;
   }
   const bytes = new Uint8Array(totalBytes);
   let offset = 0;
@@ -472,6 +470,19 @@ async function captureStream(stream, maxBytes) {
     truncated
   };
 }
+async function spillResult(context, toolName, content) {
+  await mkdir(context.archiveDir, { recursive: true, mode: 448 });
+  await chmod(context.archiveDir, 448).catch(() => void 0);
+  const path = `${context.archiveDir}/rowan-${toolName}-${Date.now()}-${crypto.randomUUID()}.log`;
+  await writeFile(path, content, { encoding: "utf8", mode: 384 });
+  await chmod(path, 384).catch(() => void 0);
+  return path;
+}
+function boundedPreview(text, maxBytes) {
+  const bytes = new TextEncoder().encode(text);
+  if (bytes.byteLength <= maxBytes) return { text, truncated: false };
+  return { text: new TextDecoder().decode(bytes.subarray(0, maxBytes)), truncated: true };
+}
 function createReadTool(context) {
   return {
     name: "read",
@@ -516,15 +527,19 @@ function createReadTool(context) {
       }
       const bytes = await readFile2(resolved.absolutePath);
       const source = new TextDecoder().decode(bytes);
-      const selected = readTextLines(source, parsed.offset, parsed.limit);
-      const selectedBytes = new TextEncoder().encode(selected);
-      const sliced = selectedBytes.subarray(0, maxBytes);
-      const text = new TextDecoder().decode(sliced);
+      const sourceLines = source.split(/\r\n|\n|\r/);
+      const requestedOffset = parsed.offset ?? 1;
+      const requestedLimit = parsed.limit ?? context.maxReadLines;
+      const selected = readTextLines(source, requestedOffset, requestedLimit);
+      const preview = boundedPreview(selected, maxBytes);
+      const text = preview.text;
+      const shownLines = text.split(/\r\n|\n|\r/).length;
+      const selectedLineEnd = Math.min(sourceLines.length, requestedOffset + shownLines - 1);
       const resourceType = detectResourceType(resolved.absolutePath);
       let name;
       let baseDir;
       if (resourceType === "skill" || resourceType === "phase") {
-        const { frontmatter } = parseFrontmatter(text);
+        const { frontmatter } = parseFrontmatter(source);
         const marker = resourceType === "skill" ? "SKILL.md" : "PHASE.md";
         name = frontmatter.name ?? inferResourceName(resolved.absolutePath, marker);
         baseDir = dirname2(resolved.absolutePath);
@@ -532,8 +547,19 @@ function createReadTool(context) {
         name = inferResourceName(resolved.absolutePath, basename2(resolved.absolutePath));
       }
       const formatted = resourceType === "skill" || resourceType === "phase" ? formatResourceOutput({ type: resourceType, name, location: resolved.absolutePath, content: text, baseDir }) : text;
-      const content = selectedBytes.byteLength > maxBytes ? `${formatted}
+      const fullFormatted = resourceType === "skill" || resourceType === "phase" ? formatResourceOutput({ type: resourceType, name, location: resolved.absolutePath, content: source, baseDir }) : source;
+      const lineTruncated = parsed.limit === void 0 && requestedOffset + requestedLimit - 1 < sourceLines.length;
+      const truncated = preview.truncated || lineTruncated;
+      let content = truncated ? `${formatted}
 [truncated]` : formatted;
+      const archivePath = await spillResult(context, "read", fullFormatted);
+      content += `
+Full result: ${archivePath}
+Offset: 0`;
+      if (lineTruncated) {
+        content += `
+Showing lines ${requestedOffset}-${selectedLineEnd} of ${sourceLines.length}. Use offset=${selectedLineEnd + 1} to continue.`;
+      }
       return toolResult({
         context: toolContext,
         toolName: "read",
@@ -681,8 +707,13 @@ function createBashTool(context) {
         ]);
         const ok = exitCode === 0 && !timedOut && !aborted;
         const output = [stdout.text, stderr.text].filter(Boolean).join(stdout.text && stderr.text ? "\n" : "");
-        const content = stdout.truncated || stderr.truncated ? `${output}
+        const preview = boundedPreview(output, maxOutputBytes);
+        let content = preview.truncated ? `${preview.text}
 [truncated]` : output;
+        const archivePath = await spillResult(context, "bash", output);
+        content += `
+Full result: ${archivePath}
+Offset: 0`;
         return toolResult({
           context: toolContext,
           toolName: "bash",
@@ -709,7 +740,24 @@ function createCoreTools(input = {}) {
   ];
 }
 
+// src/runtime/core-tools.ts
+function createRuntimeCoreTools(input = {}) {
+  return createCoreTools(input).map((tool) => ({
+    name: tool.name,
+    core: true,
+    description: tool.description,
+    parameters: tool.parameters,
+    execute: async (args, context, signal) => {
+      const result = await tool.execute(args, { skills: [], toolCallId: context.toolCallId }, signal);
+      return result.ok ? { ok: true, content: result.content } : { ok: false, content: result.content, error: result.error ?? "Tool failed." };
+    }
+  }));
+}
+
 // src/runtime/durable-runtime.ts
+import { mkdir as mkdir2, chmod as chmod2, writeFile as writeFile2 } from "fs/promises";
+import { randomUUID } from "crypto";
+import { join as join5 } from "path";
 import { createModelStream } from "@rowan-agent/models";
 
 // src/utils.ts
@@ -748,19 +796,6 @@ function createMessage(role, content, metadata) {
     ...metadata ? { metadata } : {}
   };
 }
-function messageContentText(content) {
-  if (typeof content === "string") {
-    return content;
-  }
-  return content.map((part) => {
-    if (part.type === "text") return part.text;
-    if (part.type === "thinking") return part.thinking;
-    if (part.type === "tool_result") return part.content;
-    if (part.type === "tool_use") return JSON.stringify(part.input);
-    if (part.type === "image") return `[image:${part.mimeType}]`;
-    return "";
-  }).filter(Boolean).join("\n");
-}
 function contentBlocksToMessageContent(blocks) {
   return blocks.map((block) => {
     if (block.type === "text") {
@@ -822,7 +857,8 @@ async function invokeModel(input) {
     config: input.config,
     message: input.message,
     events,
-    metadataPhase: input.phaseId
+    metadataPhase: input.phaseId,
+    output: input.output
   });
   const response = result.doneResponse ?? {
     content: result.text,
@@ -845,6 +881,7 @@ async function invokeModel(input) {
   };
 }
 async function collectStreamResult(input) {
+  const persistAssistant = input.output !== "internal";
   let activeMessageId;
   let lastPartial;
   let stopReason;
@@ -867,7 +904,7 @@ async function collectStreamResult(input) {
     }
     const abortResult2 = LoopGuard.checkAbort(input.config.signal);
     if (abortResult2.stopReason !== "none") {
-      if (activeMessageId) {
+      if (persistAssistant && activeMessageId) {
         await input.message.end(activeMessageId);
         activeMessageId = void 0;
       }
@@ -878,23 +915,27 @@ async function collectStreamResult(input) {
     }
     if (event.type === "start") {
       lastPartial = event.partial;
-      activeMessageId ??= input.message.reserve("assistant", {
-        phase: input.metadataPhase
-      });
+      if (persistAssistant) {
+        activeMessageId ??= input.message.reserve("assistant", {
+          phase: input.metadataPhase
+        });
+      }
     }
     if (event.type === "text_delta") {
       lastPartial = event.partial;
-      if (!activeMessageId) {
+      if (persistAssistant && !activeMessageId) {
         activeMessageId = input.message.reserve("assistant", {
           phase: input.metadataPhase
         });
       }
-      await input.message.update(activeMessageId, event.text);
+      if (persistAssistant && activeMessageId) await input.message.update(activeMessageId, event.text);
     }
     if (event.type === "tool_call_start" || event.type === "tool_call_delta" || event.type === "tool_call_end") {
-      activeMessageId ??= input.message.reserve("assistant", {
-        phase: input.metadataPhase
-      });
+      if (persistAssistant) {
+        activeMessageId ??= input.message.reserve("assistant", {
+          phase: input.metadataPhase
+        });
+      }
       lastPartial = event.partial;
     }
     if (event.type === "thinking_delta") {
@@ -906,10 +947,10 @@ async function collectStreamResult(input) {
       const contentBlocks2 = lastPartial?.contentBlocks ?? [];
       const hasContent2 = contentBlocks2.length > 0 || (event.response?.content?.length ?? 0) > 0 || (event.response?.toolCalls?.length ?? 0) > 0;
       const shouldStoreContentParts = contentBlocks2.some((block) => block.type !== "text");
-      if (activeMessageId && hasContent2 && shouldStoreContentParts) {
+      if (persistAssistant && activeMessageId && hasContent2 && shouldStoreContentParts) {
         input.message.replaceContent(activeMessageId, contentBlocksToMessageContent(contentBlocks2));
       }
-      if (activeMessageId) {
+      if (persistAssistant && activeMessageId) {
         if (hasContent2) await input.message.end(activeMessageId);
         else input.message.discard(activeMessageId);
         activeMessageId = void 0;
@@ -918,13 +959,13 @@ async function collectStreamResult(input) {
   }
   const abortResult = LoopGuard.checkAbort(input.config.signal);
   if (abortResult.stopReason !== "none") {
-    if (activeMessageId) {
+    if (persistAssistant && activeMessageId) {
       await input.message.end(activeMessageId);
       activeMessageId = void 0;
     }
     return { text: abortResult.message, contentBlocks: [], toolCalls: [], stopReason: "aborted" };
   }
-  if (activeMessageId) {
+  if (persistAssistant && activeMessageId) {
     await input.message.end(activeMessageId);
   }
   const hasContent = (lastPartial?.contentBlocks?.length ?? 0) > 0 || (doneResponse?.content?.length ?? 0) > 0 || (doneResponse?.toolCalls?.length ?? 0) > 0;
@@ -1317,7 +1358,7 @@ function optionalBundledSkills(value, field) {
   if (!Array.isArray(value)) throw new TypeError(`${field} must be an array of Skills`);
   const names = /* @__PURE__ */ new Set();
   for (const [index, item] of value.entries()) {
-    if (!isRecord(item) || typeof item.name !== "string" || item.name.trim() === "" || typeof item.description !== "string" || typeof item.filePath !== "string" || typeof item.baseDir !== "string" || typeof item.content !== "string" || typeof item.disableModelInvocation !== "boolean") {
+    if (!isRecord(item) || typeof item.name !== "string" || item.name.trim() === "" || typeof item.description !== "string" || typeof item.filePath !== "string" || typeof item.baseDir !== "string" || typeof item.content !== "string" || item.disableAutoInvocation !== void 0 && typeof item.disableAutoInvocation !== "boolean" || item.disableImplicitInvocation !== void 0 && typeof item.disableImplicitInvocation !== "boolean") {
       throw new TypeError(`${field}[${index}] is invalid`);
     }
     if (names.has(item.name)) throw new TypeError(`Duplicate bundled Skill "${item.name}".`);
@@ -1456,7 +1497,9 @@ async function loadSkill(path) {
     filePath: resolved,
     baseDir: dirname3(resolved),
     content: body,
-    disableModelInvocation: metadata["disable-model-invocation"] === true
+    disableAutoInvocation: metadata["disable-auto-invocation"] === true || metadata["disable-model-invocation"] === true,
+    disableImplicitInvocation: metadata["disable-implicit-invocation"] === true,
+    ...metadata["disable-model-invocation"] === true ? { disableModelInvocation: true } : {}
   };
 }
 async function loadSkills(targetPath) {
@@ -1548,7 +1591,9 @@ async function loadPhase(targetPath) {
     filePath: resolved,
     baseDir,
     content: definition.prompt,
-    model: definition.model
+    model: definition.model,
+    disableAutoInvocation: metadata["disable-auto-invocation"] === true,
+    disableImplicitInvocation: metadata["disable-implicit-invocation"] === true
   };
   const codePath = await discoverPhaseCode(baseDir);
   if (codePath) {
@@ -1684,16 +1729,126 @@ async function loadPhaseCode(codePath) {
 
 // src/harness/phases/default.ts
 var DEFAULT_PHASE_ID = "default";
+var STOP_PHASE_ID = "stop";
+var COMPACT_PHASE_ID = "compact";
 function createDefaultPhase() {
   return {
     name: DEFAULT_PHASE_ID,
-    description: "Executes concrete task operations and produces artifacts.",
+    core: true,
+    description: "Execute the current user request using the current context.",
+    filePath: "",
+    baseDir: "",
+    skills: [],
+    content: [
+      "Execute the current user request using the current context.",
+      "Must not plan or evaluate unless requested; use available tools only when needed.",
+      "If more user input is needed, omit route. If the request is complete, route(stop) as the only target."
+    ].join("\n"),
+    disableAutoInvocation: false,
+    disableImplicitInvocation: true
+  };
+}
+function createStopPhase() {
+  return {
+    name: STOP_PHASE_ID,
+    core: true,
+    description: "Provide the final user-facing conclusion for the completed task.",
+    filePath: "",
+    baseDir: "",
+    skills: [],
+    content: [
+      "Return only a brief normal-exit explanation in the user's language (one or two sentences).",
+      "Must use only facts from the conversation and completed work, and state that the current run ended normally.",
+      "If no actionable work occurred, say so briefly. Never invent Backlog, Task, Context, blockers, or next steps.",
+      "Do not greet, ask questions, mention routing, call tools, or route to another Phase."
+    ].join("\n"),
+    disableAutoInvocation: false,
+    disableImplicitInvocation: false
+  };
+}
+function createCompactPhase() {
+  return {
+    name: COMPACT_PHASE_ID,
+    core: true,
+    description: "Compact the complete conversation context into a durable summary.",
     filePath: "",
     baseDir: "",
     skills: [],
-    content: "Execute tasks using current context.\nNo planning. No evaluation.\nOmit route when more user input is needed. Use route for immediate phase execution, or route(stop) only when the current user request or task is complete and no further user input is needed."
+    content: "Summarize all historical conversation roles and tool activity for future context. Preserve durable archive references and important decisions.",
+    disableAutoInvocation: true,
+    disableImplicitInvocation: false,
+    run: async (context, execution) => {
+      await execution.reportStatus({
+        state: "running",
+        kind: "compacting",
+        message: "Compacting conversation context."
+      });
+      const tools = context.tools.filter((tool) => tool.core && (tool.name === "read" || tool.name === "bash"));
+      const working = { ...context, tools, skills: [...context.skills], messages: [...context.messages] };
+      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));
+        if (calls.length === 0) break;
+        const normalizedCalls = calls.map((call) => ({
+          ...call,
+          args: typeof call.args === "string" ? (() => {
+            try {
+              return JSON.parse(call.args);
+            } catch {
+              return call.args;
+            }
+          })() : call.args
+        }));
+        const assistantContent = result.contentBlocks.length > 0 ? contentBlocksToMessageContent(result.contentBlocks) : normalizedCalls.map((call) => ({ type: "tool_use", id: call.id, name: call.name, input: call.args }));
+        working.messages.push(createMessage("assistant", assistantContent, {
+          kind: "phase_tool",
+          phase: COMPACT_PHASE_ID
+        }));
+        for (const call of normalizedCalls) {
+          const tool = tools.find((candidate) => candidate.name === call.name);
+          let toolResult2;
+          try {
+            toolResult2 = await tool.execute(call.args, {
+              skills: working.skills,
+              toolCallId: call.id
+            });
+          } catch (error) {
+            toolResult2 = {
+              toolCallId: call.id,
+              toolName: call.name,
+              ok: false,
+              content: null,
+              error: error instanceof Error ? error.message : String(error)
+            };
+          }
+          working.messages.push(createMessage("tool", [{
+            type: "tool_result",
+            toolUseId: call.id,
+            content: JSON.stringify(toolResult2),
+            isError: !toolResult2.ok
+          }], {
+            kind: "phase_tool",
+            phase: COMPACT_PHASE_ID
+          }));
+        }
+        result = await execution.invokeModel(working, { output: "internal" });
+      }
+      return {
+        route: "stop",
+        phase: COMPACT_PHASE_ID,
+        payload: { kind: "context_compaction", summary: result.text },
+        status: {
+          state: "completed",
+          kind: "compacted",
+          message: "Conversation context compacted."
+        }
+      };
+    }
   };
 }
+function createCorePhases() {
+  return [createDefaultPhase(), createStopPhase(), createCompactPhase()];
+}
 
 // src/harness/resource-selection.ts
 function selectNamedResources(candidates, names, kind) {
@@ -1745,7 +1900,7 @@ function buildSystemPrompt(options) {
       addGuideline(g);
     }
   }
-  const visibleSkills = (skills ?? []).filter((s) => !s.disableModelInvocation);
+  const visibleSkills = (skills ?? []).filter((s) => !(s.disableAutoInvocation ?? s.disableModelInvocation));
   const skillsBlock = visibleSkills.length > 0 ? buildSkillsDescription(visibleSkills) : "";
   for (const g of promptGuidelines ?? []) {
     addGuideline(g);
@@ -1781,6 +1936,7 @@ function serializeSkills(skills) {
     name: skill.name,
     description: skill.description,
     filePath: skill.filePath,
+    disableAutoInvocation: skill.disableAutoInvocation,
     disableModelInvocation: skill.disableModelInvocation
   }));
 }
@@ -1903,80 +2059,9 @@ var createOutcome = {
   }
 };
 
-// src/harness/context/compaction.ts
-function needsCompaction(messages, options = {}) {
-  const maxMessages = options.maxMessages ?? 50;
-  return messages.length > maxMessages;
-}
-function buildSummary(messages) {
-  const parts = [];
-  let currentRole;
-  let currentContent = [];
-  function flush() {
-    if (currentRole && currentContent.length > 0) {
-      const combined = currentContent.join("\n");
-      const truncated = combined.length > 500 ? combined.slice(0, 500) + "..." : combined;
-      parts.push(`[${currentRole}]: ${truncated}`);
-    }
-    currentContent = [];
-  }
-  for (const msg of messages) {
-    if (msg.role !== currentRole) {
-      flush();
-      currentRole = msg.role;
-    }
-    currentContent.push(messageContentText(msg.content));
-  }
-  flush();
-  return parts.join("\n\n");
-}
-function compactMessages(messages, options = {}) {
-  if (!needsCompaction(messages, options)) {
-    return { compacted: false, messages };
-  }
-  const keepRecent = options.keepRecent ?? 10;
-  const minCompact = options.minCompact ?? 20;
-  const firstUserIdx = messages.findIndex(
-    (m) => m.role === "user"
-  );
-  const recentStart = Math.max(messages.length - keepRecent, firstUserIdx + 1);
-  const oldMessages = messages.slice(firstUserIdx >= 0 ? firstUserIdx + 1 : 0, recentStart);
-  const protectedPhaseMessages = oldMessages.filter(
-    (message) => message.metadata?.kind === "phase_prompt"
-  );
-  const summarizableMessages = oldMessages.filter(
-    (message) => message.metadata?.kind !== "phase_prompt"
-  );
-  if (summarizableMessages.length < minCompact) {
-    return { compacted: false, messages };
-  }
-  const recentMessages = messages.slice(recentStart);
-  const summary = buildSummary(summarizableMessages);
-  const result = [];
-  if (firstUserIdx >= 0) {
-    result.push(messages[firstUserIdx]);
-  }
-  result.push(
-    createMessage("assistant", `[Context compaction summary]
-
-${summary}`, {
-      type: "compaction_summary",
-      compactedCount: summarizableMessages.length
-    })
-  );
-  result.push(...protectedPhaseMessages);
-  result.push(...recentMessages);
-  return {
-    compacted: true,
-    messages: result,
-    summarizedCount: summarizableMessages.length,
-    summary
-  };
-}
-
 // src/loop/runners.ts
 function resolvePhaseOutput(result) {
-  return result ? { ...result } : { message: "Phase completed.", route: "stop" };
+  return result ?? { message: "Phase completed.", route: "stop" };
 }
 function removePhaseMessage(messages, msgId) {
   if (!msgId) return;
@@ -2092,12 +2177,18 @@ async function completeRun(config, state, outcome) {
   return createRunResult(config, state, outcome);
 }
 function createTerminalOutcome(phase, output, transcript) {
-  return phase.run || phase.factory ? createOutcome.phase(output, transcript) : createOutcome.default(output, transcript);
+  const outcome = phase.run || phase.factory ? createOutcome.phase(output, transcript) : createOutcome.default(output, transcript);
+  return phase.name === "compact" ? { ...outcome, display: false } : outcome;
+}
+function shouldRunStopPhase(phase, output) {
+  if (phase.run || phase.factory) return false;
+  return typeof output.message !== "string" || output.message.trim().length === 0;
 }
 function buildToolsWithRouting(config, availablePhases) {
   const tools = config.context.tools.filter((tool) => tool.name !== PhaseRouteTool);
-  if (availablePhases.length > 0) {
-    tools.push(createRouteTool(availablePhases));
+  const autoInvocablePhases = availablePhases.filter((phase) => phase.disableAutoInvocation !== true);
+  if (autoInvocablePhases.length > 0) {
+    tools.push(createRouteTool(autoInvocablePhases));
   }
   return tools;
 }
@@ -2310,7 +2401,15 @@ async function runPhaseLoop(config, state, registry) {
   while (currentPhaseId) {
     const availablePhases = [];
     for (const [, phase2] of registry.phases) {
-      availablePhases.push({ name: phase2.name, description: phase2.description, tools: phase2.tools, skills: phase2.skills, input: phase2.input, isolated: phase2.isolated });
+      availablePhases.push({
+        name: phase2.name,
+        description: phase2.description,
+        tools: phase2.tools,
+        skills: phase2.skills,
+        input: phase2.input,
+        isolated: phase2.isolated,
+        disableAutoInvocation: phase2.disableAutoInvocation
+      });
     }
     const abortResult = LoopGuard.checkAbort(config.signal);
     if (abortResult.stopReason !== "none") {
@@ -2334,13 +2433,6 @@ async function runPhaseLoop(config, state, registry) {
     }
     state.attempt++;
     state.metrics.iterations++;
-    if (needsCompaction(config.context.messages)) {
-      const compacted = compactMessages(config.context.messages);
-      if (compacted.compacted) {
-        config.context.messages = compacted.messages;
-        state.metrics.compactionCount++;
-      }
-    }
     const phase = registry.phases.get(currentPhaseId);
     if (!phase) {
       throw new Error(`Phase "${currentPhaseId}" not found`);
@@ -2465,10 +2557,20 @@ async function runPhaseLoop(config, state, registry) {
         }
       }
     }
+    if (output.status) {
+      await execution.reportStatus(output.status);
+    }
+    if (phase.name === STOP_PHASE_ID) {
+      removePhaseMessage(config.context.messages, previousPhaseMsgId);
+      removePhaseMessage(config.context.messages, previousPhaseInputMsgId);
+      previousPhaseMsgId = void 0;
+      previousPhaseInputMsgId = void 0;
+      return completeRun(config, state, createTerminalOutcome(phase, output, config.context.messages));
+    }
     if (phase.run || phase.factory) {
       if (output.route === void 0 && !routeDecision) output = { ...output, route: "stop" };
     } else if (!phase.target && output.route === void 0 && !routeDecision) {
-      const input = await awaitInput(output.message, true);
+      const input = await awaitInput(output.message ?? `${output.phase ?? "Phase"} completed.`, true);
       if (input?.type === "completed") return input.result;
       if (input?.type === "continued") {
         isContinuing = true;
@@ -2519,11 +2621,16 @@ async function runPhaseLoop(config, state, registry) {
       pendingInstruction = void 0;
       const entryPhaseId = phase.target ?? registry.entryPhaseId;
       if (entryPhaseId === "stop") {
-        removePhaseMessage(config.context.messages, previousPhaseMsgId);
-        removePhaseMessage(config.context.messages, previousPhaseInputMsgId);
-        previousPhaseMsgId = void 0;
-        previousPhaseInputMsgId = void 0;
-        return completeRun(config, state, createTerminalOutcome(phase, output, config.context.messages));
+        if (!shouldRunStopPhase(phase, output)) {
+          removePhaseMessage(config.context.messages, previousPhaseMsgId);
+          removePhaseMessage(config.context.messages, previousPhaseInputMsgId);
+          previousPhaseMsgId = void 0;
+          previousPhaseInputMsgId = void 0;
+          return completeRun(config, state, createTerminalOutcome(phase, output, config.context.messages));
+        }
+        currentPhaseId = STOP_PHASE_ID;
+        previousPayload = void 0;
+        continue;
       }
       currentPhaseId = entryPhaseId;
       previousPayload = void 0;
@@ -2538,11 +2645,18 @@ async function runPhaseLoop(config, state, registry) {
       nextRoute = "stop";
     }
     if (nextRoute === "stop") {
-      removePhaseMessage(config.context.messages, previousPhaseMsgId);
-      removePhaseMessage(config.context.messages, previousPhaseInputMsgId);
-      previousPhaseMsgId = void 0;
-      previousPhaseInputMsgId = void 0;
-      return completeRun(config, state, createTerminalOutcome(phase, output, config.context.messages));
+      if (!shouldRunStopPhase(phase, output)) {
+        removePhaseMessage(config.context.messages, previousPhaseMsgId);
+        removePhaseMessage(config.context.messages, previousPhaseInputMsgId);
+        previousPhaseMsgId = void 0;
+        previousPhaseInputMsgId = void 0;
+        return completeRun(config, state, createTerminalOutcome(phase, output, config.context.messages));
+      }
+      currentPhaseId = STOP_PHASE_ID;
+      previousPayload = output.payload;
+      previousResults = output.payload !== void 0 ? [{ name: phase.name, output: output.payload }] : [];
+      pendingInstruction = phase.target ? void 0 : routeDecision?.instruction;
+      continue;
     }
     const targetPhaseId = nextRoute;
     if (!registry.phases.has(targetPhaseId)) {
@@ -2606,7 +2720,7 @@ async function withRetry(fn, options = {}) {
       }
       const delayMs = getRetryDelay(attempt, baseDelayMs, maxDelayMs);
       options.onRetry?.(attempt, error, delayMs);
-      await new Promise((resolve8) => setTimeout(resolve8, delayMs));
+      await new Promise((resolve9) => setTimeout(resolve9, delayMs));
       if (options.signal?.aborted) {
         throw lastError;
       }
@@ -2730,7 +2844,7 @@ function createPhaseExecution(config, state, phase, messageManager, toolExecutio
       state.currentPhase = snapshot.currentPhase;
       state.metrics.iterations = snapshot.turnNumber;
     },
-    async invokeModel(phaseContext) {
+    async invokeModel(phaseContext, options = {}) {
       if (config.beforePrompt) {
         phaseContext = await config.beforePrompt(phase.name, phaseContext);
       }
@@ -2760,7 +2874,8 @@ function createPhaseExecution(config, state, phase, messageManager, toolExecutio
             config,
             message: messageManager,
             request,
-            phaseId: phase.name
+            phaseId: phase.name,
+            output: options.output
           }),
           {
             signal: config.signal,
@@ -2773,6 +2888,9 @@ function createPhaseExecution(config, state, phase, messageManager, toolExecutio
       await config.onModelTranscript?.(result.transcript, { phase: phase.name, model: phase.model ?? config.model });
       return result;
     },
+    async reportStatus(status) {
+      await config.onPhaseStatus?.(phase.name, status);
+    },
     async executeTool(phaseContext, toolCall) {
       return runTurn(async () => {
         await toolExecutionManager.start(toolCall.id, toolCall.name, toolCall.args);
@@ -2862,12 +2980,13 @@ async function executeParallelPhase(config, state, registry, phase, payload, ins
   if (phaseMsgId) removePhaseMessage(messages, phaseMsgId);
   const decision = output.toolCalls ? extractRouteCall(output.toolCalls) : void 0;
   const resultPayload = decision?.decision[0]?.payload !== void 0 ? normalizePayload(decision.decision[0].payload) : output.payload;
-  return { instanceId, phaseId: phase.name, payload: resultPayload, content: output.message };
+  return { instanceId, phaseId: phase.name, payload: resultPayload, content: output.message ?? `${phase.name} completed.` };
 }
 function selectPhaseTools(candidates, names, includeRouting = true) {
   const routing = includeRouting ? candidates.filter(({ name }) => name === PhaseRouteTool) : [];
-  const ordinary = candidates.filter(({ name }) => name !== PhaseRouteTool);
-  return [...selectNamedResources(ordinary, names, "Tool"), ...routing];
+  const core = candidates.filter(({ core: core2 }) => core2);
+  const ordinary = candidates.filter(({ name, core: core2 }) => name !== PhaseRouteTool && !core2);
+  return [...core, ...selectNamedResources(ordinary, names, "Tool"), ...routing];
 }
 async function waitForBackgroundTasks(backgroundTasks) {
   const entries = Array.from(backgroundTasks.entries());
@@ -3022,6 +3141,7 @@ async function executeOnce(input) {
     onMessageDelta: input.onMessageDelta,
     onOutcome: input.onOutcome,
     onModelTranscript: input.onModelTranscript,
+    onPhaseStatus: input.onPhaseStatus,
     runtime: input.runtime,
     waitForInput: async (nextState, request) => {
       if (!nextState || !request) throw new Error("Input boundary did not include execution state.");
@@ -3762,6 +3882,7 @@ function projectToolContent(content) {
 function projectTool(tool, agentId, runId) {
   return {
     name: tool.name,
+    ...tool.core ? { core: true } : {},
     description: tool.description,
     parameters: tool.parameters,
     execute: async (args, context, signal) => {
@@ -3780,9 +3901,17 @@ function jsonText(value) {
 }
 
 // src/runtime/extensions.ts
-function assembleRegisteredExtensions(config, runner) {
+function assembleRegisteredExtensions(config, runner, options = {}) {
   const extensionTools = runner.getAllRegisteredTools().map(adaptExtensionTool);
-  const tools = [...config.resources.tools];
+  const coreTools = createRuntimeCoreTools({
+    root: config.cwd,
+    ...options.toolArchiveDir ? { archiveDir: options.toolArchiveDir } : {}
+  });
+  const coreNames = new Set(coreTools.map((tool) => tool.name));
+  const tools = [
+    ...config.resources.tools.filter((tool) => !coreNames.has(tool.name)),
+    ...coreTools
+  ];
   const names = new Set(tools.map((tool) => tool.name));
   for (const tool of extensionTools) {
     if (names.has(tool.name)) throw new TypeError(`Extension Tool collides with Context Tool "${tool.name}"`);
@@ -3813,11 +3942,13 @@ function assembleRegisteredExtensions(config, runner) {
   };
 }
 function resolveDefinitionContext(config, assembled = {}) {
-  const tools = selectNamedResources(
-    assembled.tools ?? config.resources.tools,
-    config.definition.tools,
-    "Tool"
-  );
+  const candidateTools = assembled.tools ?? config.resources.tools;
+  const coreTools = candidateTools.filter((tool) => tool.core);
+  const authoredTools = candidateTools.filter((tool) => !tool.core);
+  const tools = [
+    ...selectNamedResources(authoredTools, config.definition.tools, "Tool"),
+    ...coreTools
+  ];
   const skills = mergeSkills(
     selectNamedResources(config.resources.skills, config.definition.skills, "Skill"),
     config.definition.bundledSkills
@@ -3828,11 +3959,16 @@ function resolveDefinitionContext(config, assembled = {}) {
     "Context"
   );
   const candidateRegistry = assembled.phases ?? config.resources.phases;
-  const selectedPhases = selectNamedResources(
-    [...candidateRegistry?.phases.values() ?? []],
-    config.definition.phases?.phaseIds,
-    "Phase"
-  );
+  const phaseCandidates = [...candidateRegistry?.phases.values() ?? []];
+  const coreNames = /* @__PURE__ */ new Set([DEFAULT_PHASE_ID, STOP_PHASE_ID, COMPACT_PHASE_ID]);
+  const selectedPhases = [
+    ...phaseCandidates.filter((phase) => phase.core || coreNames.has(phase.name)),
+    ...selectNamedResources(
+      phaseCandidates.filter((phase) => !phase.core && !coreNames.has(phase.name)),
+      config.definition.phases?.phaseIds,
+      "Phase"
+    )
+  ];
   const phases = new Map(selectedPhases.map((phase) => [phase.name, phase]));
   const requestedEntry = config.definition.phases ? config.definition.phases.entryPhaseId : candidateRegistry?.entryPhaseId ?? null;
   const entryPhaseId = requestedEntry === DEFAULT_PHASE_ID ? DEFAULT_PHASE_ID : requestedEntry && phases.has(requestedEntry) ? requestedEntry : null;
@@ -3847,15 +3983,23 @@ function resolveDefinitionContext(config, assembled = {}) {
   };
 }
 function mergePhases(base, extension) {
-  if (!base && extension.phases.size === 0) return void 0;
-  const phases = new Map(base?.phases ?? []);
+  const core = createCorePhases();
+  const coreNames = new Set(core.map(({ name }) => name));
+  const phases = new Map(core.map((phase) => [phase.name, phase]));
+  for (const [name, phase] of base?.phases ?? []) {
+    if (coreNames.has(name)) {
+      if (!phase.core) throw new TypeError(`Configured Phase collides with Rowan built-in Phase "${name}".`);
+      continue;
+    }
+    phases.set(name, phase);
+  }
   for (const [name, phase] of extension.phases) {
     if (phases.has(name)) throw new TypeError(`Extension Phase collides with Context Phase "${name}"`);
     phases.set(name, phase);
   }
   return {
     phases,
-    entryPhaseId: base?.entryPhaseId ?? extension.entryPhaseId
+    entryPhaseId: base?.entryPhaseId ?? extension.entryPhaseId ?? DEFAULT_PHASE_ID
   };
 }
 function adaptExtensionTool(input) {
@@ -3888,11 +4032,11 @@ function fromLoopResult(result) {
 var MAX_BUFFERED_EVENTS = 128;
 var MAX_BUFFERED_TEXT = 64 * 1024;
 function deferred() {
-  let resolve8;
+  let resolve9;
   const promise = new Promise((done) => {
-    resolve8 = done;
+    resolve9 = done;
   });
-  return { promise, resolve: resolve8 };
+  return { promise, resolve: resolve9 };
 }
 var TransientRunEventSubscription = class {
   queue = [];
@@ -3917,11 +4061,14 @@ var TransientRunEventSubscription = class {
   shift() {
     return this.queue.shift();
   }
-  clear(executionId) {
+  clear(executionId, preserveCompletedPhaseStatus = false) {
     if (executionId === void 0) this.queue.length = 0;
     else {
       for (let index = this.queue.length - 1; index >= 0; index -= 1) {
-        if (this.queue[index]?.executionId === executionId) this.queue.splice(index, 1);
+        const event = this.queue[index];
+        if (event?.executionId === executionId && !(preserveCompletedPhaseStatus && event.kind === "phase_status" && event.status.state === "completed")) {
+          this.queue.splice(index, 1);
+        }
       }
     }
     this.notify();
@@ -4003,9 +4150,9 @@ var TransientRunEventHub = class {
       subscription.push(event);
     }
   }
-  clear(runId, executionId) {
+  clear(runId, executionId, preserveCompletedPhaseStatus = false) {
     for (const subscription of this.subscriptions.get(runId) ?? []) {
-      subscription.clear(executionId);
+      subscription.clear(executionId, preserveCompletedPhaseStatus);
     }
   }
   clearMessage(runId, messageId) {
@@ -4153,7 +4300,7 @@ function createEventBus() {
 
 // src/extensions/runner.ts
 async function execCommand(command, args, cwd, options) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const child = execFile(
       command,
       args,
@@ -4168,7 +4315,7 @@ async function execCommand(command, args, cwd, options) {
           reject(new Error("Command was aborted"));
           return;
         }
-        resolve8({
+        resolve9({
           exitCode: typeof error?.code === "number" ? error.code : error ? 1 : 0,
           stdout: stdout ?? "",
           stderr: stderr ?? ""
@@ -5026,6 +5173,8 @@ function snapshotResourceValue(kind, value) {
   const phase = value;
   const snapshot = {
     ...phase,
+    disableAutoInvocation: phase.disableAutoInvocation ?? false,
+    disableImplicitInvocation: phase.disableImplicitInvocation ?? false,
     ...phase.tools ? { tools: Object.freeze([...phase.tools]) } : {},
     skills: Object.freeze((phase.skills ?? []).map((skill) => Object.freeze({ ...skill }))),
     ...phase.input ? { input: Object.freeze({ ...phase.input }) } : {},
@@ -5051,7 +5200,7 @@ function capitalize(value) {
   return value.charAt(0).toUpperCase() + value.slice(1);
 }
 function isImplicitCoreName(kind, name) {
-  return kind === "tool" && name === "route" || kind === "phase" && name === "default";
+  return kind === "tool" && name === "route" || kind === "phase" && (name === "default" || name === "stop" || name === "compact");
 }
 async function loadDirectoryValues(kind, directory, sourceId) {
   const root = resolve7(directory);
@@ -5235,7 +5384,7 @@ var RuntimeBootstrapRegistry = class extends ResourceRegistry {
   /** Install Rowan-owned implicit resources before any host source is read. */
   async ensureCoreResources() {
     await this.replaceImplicit("tool", "rowan.core", [createRouteTool([])]);
-    await this.replaceImplicit("phase", "rowan.core", [createDefaultPhase()]);
+    await this.replaceImplicit("phase", "rowan.core", createCorePhases());
   }
   async loadExtensions(input) {
     const loaded = Array.isArray(input) ? { extensions: [...input], errors: [] } : (() => {
@@ -5379,7 +5528,10 @@ function intersectPhaseSelection(parent, layer) {
   };
 }
 function resolvePhases(candidates, selection) {
-  const selected = selectNamedResources(candidates, selection?.phaseIds, "Phase");
+  const coreNames = /* @__PURE__ */ new Set([DEFAULT_PHASE_ID, STOP_PHASE_ID, COMPACT_PHASE_ID]);
+  const core = candidates.filter((phase) => phase.core || coreNames.has(phase.name));
+  const authored = candidates.filter((phase) => !coreNames.has(phase.name) && !phase.core);
+  const selected = [...core, ...selectNamedResources(authored, selection?.phaseIds, "Phase")];
   const entryPhaseId = selection?.entryPhaseId ?? null;
   if (entryPhaseId !== null && entryPhaseId !== DEFAULT_PHASE_ID && !selected.some(({ name }) => name === entryPhaseId)) {
     console.warn(`Phase entry "${entryPhaseId}" is not available and will be skipped.`);
@@ -5401,6 +5553,31 @@ var DEFAULT_POLL_MS = 25;
 var MAX_CONSUMER_IDLE_POLL_MS = 250;
 var OWNER_LEASE_MS = 3e4;
 var OWNER_RENEWAL_MS = 1e4;
+var MAX_INLINE_TOOL_RESULT_BYTES = 16 * 1024;
+async function spillLargeToolResult(result, archiveDir, toolName) {
+  if (!archiveDir) return result;
+  const serialized = typeof result.content === "string" ? result.content : JSON.stringify(result.content, null, 2);
+  if (serialized === void 0) return result;
+  const bytes = new TextEncoder().encode(serialized);
+  if (bytes.byteLength <= MAX_INLINE_TOOL_RESULT_BYTES || /\nFull result:\s+\S+/.test(serialized)) {
+    return result;
+  }
+  const toolDir = archiveDir;
+  await mkdir2(toolDir, { recursive: true, mode: 448 });
+  await chmod2(toolDir, 448).catch(() => void 0);
+  const safeToolName = toolName.replace(/[^a-zA-Z0-9._-]+/g, "_");
+  const path = join5(toolDir, `rowan-${safeToolName}-${Date.now()}-${randomUUID()}.log`);
+  await writeFile2(path, serialized, { encoding: "utf8", mode: 384 });
+  await chmod2(path, 384).catch(() => void 0);
+  const preview = new TextDecoder().decode(bytes.subarray(0, MAX_INLINE_TOOL_RESULT_BYTES));
+  return {
+    ...result,
+    content: `${preview}
+[truncated]
+Full result: ${path}
+Offset: 0`
+  };
+}
 var AgentRuntime = class _AgentRuntime {
   concurrency;
   owned;
@@ -5411,6 +5588,7 @@ var AgentRuntime = class _AgentRuntime {
   executionDone = /* @__PURE__ */ new Map();
   cancellationRequested = /* @__PURE__ */ new Set();
   cancellationReasons = /* @__PURE__ */ new Map();
+  autoCompactionRuns = /* @__PURE__ */ new Set();
   consumers = /* @__PURE__ */ new Map();
   transientEvents = new TransientRunEventHub();
   resources;
@@ -5503,6 +5681,36 @@ var AgentRuntime = class _AgentRuntime {
     this.assertOpen();
     return this.owned.compact(input);
   }
+  async contextStatus(agentId, options = {}) {
+    this.assertOpen();
+    const agent = await this.requireAgent(agentId);
+    const contextWindow = options.contextWindow ?? await this.resolveContextWindow(agent);
+    return this.owned.contextStatus(agentId, contextWindow);
+  }
+  async compactContext(agentId, options = {}) {
+    this.assertOpen();
+    const agent = await this.requireAgent(agentId);
+    if (!agent.activatedAt || !agent.currentConfigToken) throw new RuntimeError("agent_not_found", { agentId });
+    const active = (await this.owned.listRuns({ agentId })).filter((run2) => ["queued", "running", "input_required"].includes(run2.state));
+    const existing = active.find((run2) => controlRunKind(run2) === "compact");
+    if (existing) return new DurableRun(this, existing.id);
+    const blocking = active.find((run2) => run2.state === "queued" || run2.state === "running");
+    if (blocking) throw new RuntimeError("context_busy", { agentId, runId: blocking.id, actual: blocking.state });
+    const metadata = {
+      rowan: {
+        kind: "compact",
+        ...options.instructions === void 0 ? {} : { instructions: options.instructions }
+      }
+    };
+    const run = await this.owned.createRun({
+      agentId,
+      input: "",
+      metadata,
+      idempotencyKey: options.idempotencyKey ?? createId("compact")
+    });
+    void this.pump();
+    return new DurableRun(this, run.id);
+  }
   async start(agentId, input, options) {
     this.assertOpen();
     const agent = await this.requireAgent(agentId);
@@ -5522,6 +5730,47 @@ var AgentRuntime = class _AgentRuntime {
     this.assertOpen();
     return pageRuns(await this.owned.listRuns(input), { ...input, storeIncarnation: this.storeIncarnation });
   }
+  async listInvocations(agentId, options) {
+    this.assertOpen();
+    if (!options || !["auto", "implicit", "external"].includes(options.source)) {
+      throw new TypeError("options.source must be auto, implicit, or external");
+    }
+    const agent = await this.requireAgent(agentId);
+    if (!agent.currentConfigToken) throw new RuntimeError("agent_not_found", { agentId });
+    const resolution = await this.commands.resolve({ agent, token: agent.currentConfigToken });
+    if (resolution.kind !== "available") {
+      throw new RuntimeError("configuration_unavailable", {
+        agentId,
+        retryable: resolution.kind === "deferred",
+        reason: resolution.kind === "deferred" ? "Configuration is deferred." : resolution.reason
+      });
+    }
+    const config = isAgentConfiguration(resolution.config) ? this.materializeConfig(resolution.config) : resolution.config;
+    const assembly = assembleRegisteredExtensions(config, this.resources.extensionRunner, {
+      toolArchiveDir: this.archiveDirFor(agentId)
+    });
+    const phases = [...assembly.context.phases?.phases.values() ?? []].filter((phase) => options.source === "external" || (options.source === "auto" ? !phase.disableAutoInvocation : !phase.disableImplicitInvocation)).filter((phase) => options.source !== "implicit" || phase.name !== DEFAULT_PHASE_ID);
+    const skills = assembly.context.skills.filter((skill) => options.source === "external" || (options.source === "auto" ? !(skill.disableAutoInvocation ?? skill.disableModelInvocation) : !skill.disableImplicitInvocation));
+    return [
+      ...phases.map((phase) => ({
+        kind: "phase",
+        name: phase.name,
+        description: phase.description,
+        ...phase.core ? { core: true } : {},
+        disableAutoInvocation: phase.disableAutoInvocation ?? false,
+        disableImplicitInvocation: phase.disableImplicitInvocation ?? false,
+        filePath: phase.filePath
+      })),
+      ...skills.map((skill) => ({
+        kind: "skill",
+        name: skill.name,
+        description: skill.description,
+        disableAutoInvocation: skill.disableAutoInvocation ?? skill.disableModelInvocation ?? false,
+        disableImplicitInvocation: skill.disableImplicitInvocation ?? false,
+        filePath: skill.filePath
+      }))
+    ];
+  }
   async consume(input) {
     this.assertOpen();
     if (input.consumerId.trim().length === 0) throw new TypeError("consumerId must be non-empty");
@@ -5601,16 +5850,19 @@ var AgentRuntime = class _AgentRuntime {
     try {
       while (!this.closed && this.executions.size < this.concurrency) {
         const queued = await this.owned.listRuns({ states: ["queued"] });
-        const next = queued.find((run) => !this.activeAgents.has(run.agentId));
+        const next = queued.filter((run) => !this.activeAgents.has(run.agentId)).sort((left, right) => Number(controlRunKind(right) === "compact") - Number(controlRunKind(left) === "compact"))[0];
         if (!next) return;
         this.activeAgents.add(next.agentId);
         const task = this.execute(next).finally(() => {
           const execution = this.executions.get(next.id);
-          if (execution) this.transientEvents.clear(next.id, execution.executionId);
+          if (execution) this.transientEvents.clear(next.id, execution.executionId, true);
           this.activeAgents.delete(next.agentId);
           this.executions.delete(next.id);
           this.cancellationRequested.delete(next.id);
           this.cancellationReasons.delete(next.id);
+          void this.owned.snapshotRun(next.id).then((snapshot) => {
+            if (snapshot.state !== "queued") this.autoCompactionRuns.delete(next.id);
+          }).catch(() => void 0);
           this.executionDone.delete(next.id);
           void this.pump();
         });
@@ -5667,34 +5919,81 @@ var AgentRuntime = class _AgentRuntime {
           return;
         }
       }
+      const config = resolvedConfig;
+      const controlKind = controlRunKind(run);
+      if (!controlKind && !this.autoCompactionRuns.has(run.id)) {
+        const contextWindow = await resolveContextWindowForConfig(config);
+        const status = await this.owned.contextStatus(run.agentId, contextWindow);
+        const inputTokens = estimateRunInputTokens(run.input);
+        if (status.thresholdTokens > 0 && status.tokens + inputTokens >= status.thresholdTokens) {
+          this.autoCompactionRuns.add(run.id);
+          await this.owned.createRun({
+            agentId: run.agentId,
+            input: "",
+            metadata: {
+              rowan: {
+                kind: "compact",
+                trigger: "auto",
+                sourceRunId: String(run.id)
+              }
+            },
+            idempotencyKey: `auto-compact:${run.id}`
+          });
+          return;
+        }
+      }
       const executionId = createId("exec");
       claim = await this.owned.claimRun({ runId: run.id, expectedRevision: run.revision, executionId, configToken: token });
       executionRevision = claim.run.revision;
       const controller = new AbortController();
       this.executions.set(run.id, { controller, executionId });
       if (this.cancellationRequested.has(run.id)) controller.abort();
-      const config = resolvedConfig;
-      const assembly = assembleRegisteredExtensions(config, this.resources.extensionRunner);
+      const assembly = assembleRegisteredExtensions(config, this.resources.extensionRunner, {
+        toolArchiveDir: this.archiveDirFor(run.agentId)
+      });
       let toolQueue = Promise.resolve();
       const model = "stream" in config && config.stream ? config.model : { provider: config.model.provider, id: config.model.id };
       const stream = "stream" in config && config.stream ? config.stream : createModelStream(config.model);
-      const executionContext = projectModelContext({
-        context: {
-          ...assembly.context,
-          phases: normalizePhaseRegistry(assembly.context.phases)
-        },
-        messages: claim.history,
-        agentId: run.agentId,
-        runId: run.id
-      });
+      const phaseRegistry = normalizePhaseRegistry(assembly.context.phases);
+      let modelMessages = await this.owned.contextMessages(run.agentId);
+      const buildExecutionContext = (messages, phaseId) => {
+        const executionContext2 = projectModelContext({
+          context: {
+            ...assembly.context,
+            phases: phaseRegistry
+          },
+          messages,
+          agentId: run.agentId,
+          runId: run.id
+        });
+        if (phaseId === COMPACT_PHASE_ID || controlKind === "compact") {
+          executionContext2.phases = {
+            ...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;
+      };
+      let executionContext = buildExecutionContext(modelMessages);
       const executionTools = {
         tools: assembly.context.tools,
         beforeToolCall: assembly.beforeToolCall ?? config.beforeToolCall,
         afterToolCall: assembly.afterToolCall ?? config.afterToolCall
       };
-      const result = await executeOnce({
-        canonicalMessages: executionContext.messages,
-        context: executionContext,
+      const executeModel = (context) => executeOnce({
+        canonicalMessages: context.messages,
+        context,
         execution: {
           agentId: run.agentId,
           runId: run.id,
@@ -5703,7 +6002,7 @@ var AgentRuntime = class _AgentRuntime {
           ...run.metadata === void 0 ? {} : { runMetadata: run.metadata }
         },
         model,
-        thinkingLevel: thinkingLevelFromMessages(executionContext.messages),
+        thinkingLevel: thinkingLevelFromMessages(context.messages),
         stream,
         maxAttempts: config.maxAttempts,
         checkpoint: claim.run.checkpoint,
@@ -5712,6 +6011,18 @@ var AgentRuntime = class _AgentRuntime {
         beforePhase: assembly.beforePhase,
         afterPhase: assembly.afterPhase,
         beforePrompt: assembly.beforePrompt,
+        onPhaseStatus: (phaseId, status) => {
+          const active = this.executions.get(run.id);
+          if (active?.executionId !== claim.execution.executionId) return;
+          this.transientEvents.publish({
+            kind: "phase_status",
+            durability: "transient",
+            runId: run.id,
+            executionId: claim.execution.executionId,
+            phaseId,
+            status
+          });
+        },
         onMessageDelta: (event) => {
           const active = this.executions.get(run.id);
           if (this.closed || controller.signal.aborted || active?.executionId !== claim.execution.executionId) return;
@@ -5763,8 +6074,27 @@ var AgentRuntime = class _AgentRuntime {
           }
         }
       });
+      let result = await executeModel(executionContext);
+      if (!controlKind && result.type === "failed" && isContextOverflowError(result.error)) {
+        const compactContext = buildExecutionContext(await this.owned.contextMessages(run.agentId), COMPACT_PHASE_ID);
+        const compactResult = await executeModel(compactContext);
+        const summary = compactResult.type === "completed" ? compactSummary(compactResult.outcome.payload) : void 0;
+        if (summary) {
+          const covered = claim.history.at(-1);
+          await this.owned.commitContextCompaction({
+            id: createId("compact"),
+            agentId: run.agentId,
+            summary,
+            ...covered ? { coveredThrough: { messageId: covered.id, sequence: covered.sequenceWithinRun } } : {},
+            createdAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          modelMessages = await this.owned.contextMessages(run.agentId);
+          executionContext = buildExecutionContext(modelMessages);
+          result = await executeModel(executionContext);
+        }
+      }
       if (this.cancellationRequested.has(run.id) || controller.signal.aborted) {
-        const output = latestAssistant(run, result.messages, claim.history.length, true);
+        const output = latestAssistant(run, result.messages, modelMessages.length, true);
         const reason = this.cancellationReasons.get(run.id) ?? "Agent run stopped.";
         await this.owned.cancelRun({
           runId: run.id,
@@ -5792,9 +6122,24 @@ var AgentRuntime = class _AgentRuntime {
         return;
       }
       if (result.type === "completed") {
-        const output = latestAssistant(run, result.messages, claim.history.length);
+        const output = latestAssistant(run, result.messages.slice(modelMessages.length), modelMessages.length);
+        if (controlKind === "compact" || isCompactionOutcome(result.outcome.payload)) {
+          const summary = compactSummary(result.outcome.payload);
+          if (summary) {
+            const covered = claim.history.at(-1);
+            const record = {
+              id: createId("compact"),
+              agentId: run.agentId,
+              summary,
+              ...covered ? { coveredThrough: { messageId: covered.id, sequence: covered.sequenceWithinRun } } : {},
+              ...compactInstructions(run) ? { instructions: compactInstructions(run) } : {},
+              createdAt: (/* @__PURE__ */ new Date()).toISOString()
+            };
+            await this.owned.commitContextCompaction(record);
+          }
+        }
         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);
+        this.transientEvents.clear(run.id, claim.execution.executionId, true);
         return;
       }
       const failure = { code: "execution_failed", message: result.error instanceof Error ? result.error.message : "Execution failed." };
@@ -5827,6 +6172,13 @@ var AgentRuntime = class _AgentRuntime {
       if (!(error instanceof RuntimeError) || !["run_state_conflict", "runtime_ownership_lost", "run_not_found"].includes(error.code)) throw error;
     });
   }
+  async resolveContextWindow(agent) {
+    if (!agent.currentConfigToken) return 128e3;
+    const resolution = await this.commands.resolve({ agent, token: agent.currentConfigToken });
+    if (resolution.kind !== "available") return 128e3;
+    const config = isAgentConfiguration(resolution.config) ? this.materializeConfig(resolution.config) : resolution.config;
+    return resolveContextWindowForConfig(config);
+  }
   async executeTool(input) {
     const batch = await this.executeToolBatch({ ...input, toolCalls: [input.toolCall] });
     return { result: batch.results[0], revision: batch.revision };
@@ -5917,6 +6269,11 @@ var AgentRuntime = class _AgentRuntime {
       assertToolExecutionResult(result);
       if (input.toolConfig.afterToolCall) result = await input.toolConfig.afterToolCall({ tool: durableTool, result, context, signal: input.signal });
       assertToolExecutionResult(result);
+      result = await spillLargeToolResult(
+        result,
+        this.archiveDirFor(input.run.agentId),
+        input.toolCall.name
+      );
       const committed = await this.owned.commitToolResult({ runId: input.run.id, execution: input.execution, expectedRevision: revision, toolCallId, state: result.ok ? "completed" : "failed", result });
       return {
         result: { toolCallId: providerToolCallId, toolName: input.toolCall.name, ...result },
@@ -5936,6 +6293,11 @@ var AgentRuntime = class _AgentRuntime {
     if (!agent) throw new RuntimeError("agent_not_found", { agentId });
     return agent;
   }
+  archiveDirFor(agentId) {
+    const store = this.owned;
+    const archiveDir = store.contextArchiveDir?.(agentId);
+    return archiveDir ? join5(archiveDir, "tool-results") : void 0;
+  }
   async runConsumer(subscription) {
     const registration = await this.owned.openConsumer(subscription.consumerId);
     let cursor = registration.cursor;
@@ -5977,10 +6339,11 @@ var AgentRuntime = class _AgentRuntime {
     const subscription = this.transientEvents.subscribe(runId);
     try {
       while (true) {
-        if (options.signal?.aborted) throw abortError();
         const observationVersion = subscription.checkpoint();
         const snapshot = await this.owned.snapshotRun(runId);
-        if (["completed", "failed", "cancelled"].includes(snapshot.state)) {
+        const terminal = ["completed", "failed", "cancelled"].includes(snapshot.state);
+        if (options.signal?.aborted && !terminal) throw abortError();
+        if (terminal) {
           const pending = await this.owned.listEvents(cursor ? { after: cursor } : {});
           if (!pending.some((event) => event.runId === runId)) return;
         }
@@ -5993,8 +6356,16 @@ var AgentRuntime = class _AgentRuntime {
           } else if (event.kind === "tool_state_changed" && ["completed", "failed", "indeterminate"].includes(event.transition.to)) {
             subscription.clearTool(event.toolCall.id);
           }
+          if (event.kind === "run_state_changed" && ["completed", "failed", "cancelled"].includes(event.to)) {
+            while (true) {
+              const transient2 = subscription.shift();
+              if (!transient2) break;
+              yield transient2;
+            }
+            yield event;
+            return;
+          }
           yield event;
-          if (event.kind === "run_state_changed" && ["completed", "failed", "cancelled"].includes(event.to)) return;
         }
         const transient = subscription.shift();
         if (transient) {
@@ -6098,21 +6469,67 @@ function boundaryFromSnapshot(snapshot) {
   }
 }
 function delay(ms) {
-  return new Promise((resolve8) => setTimeout(resolve8, ms));
+  return new Promise((resolve9) => setTimeout(resolve9, ms));
+}
+function controlRunKind(run) {
+  const rowan = run.metadata?.rowan;
+  if (typeof rowan !== "object" || rowan === null || !("kind" in rowan)) return void 0;
+  const kind = rowan.kind;
+  return typeof kind === "string" ? kind : void 0;
+}
+function compactInstructions(run) {
+  const rowan = run.metadata?.rowan;
+  if (typeof rowan !== "object" || rowan === null || !("instructions" in rowan)) return void 0;
+  const instructions = rowan.instructions;
+  return typeof instructions === "string" && instructions.trim().length > 0 ? instructions : void 0;
+}
+function compactSummary(payload) {
+  if (typeof payload !== "object" || payload === null || !("summary" in payload)) return void 0;
+  const summary = payload.summary;
+  return typeof summary === "string" && summary.trim().length > 0 ? summary : void 0;
+}
+function isCompactionOutcome(payload) {
+  return typeof payload === "object" && payload !== null && "kind" in payload && payload.kind === "context_compaction";
+}
+async function resolveContextWindowForConfig(config) {
+  if ("contextWindow" in config.model && typeof config.model.contextWindow === "number") {
+    return config.model.contextWindow;
+  }
+  return 128e3;
+}
+function estimateRunInputTokens(input) {
+  const content = typeof input === "string" ? input : input.content;
+  const text = typeof content === "string" ? content : content.map((part) => part.type === "text" ? part.text : part.data).join("\n");
+  return Math.ceil(text.length / 4) + 20;
+}
+function isContextOverflowError(error) {
+  const message = error instanceof Error ? `${error.name} ${error.message}` : typeof error === "string" ? error : (() => {
+    try {
+      return JSON.stringify(error);
+    } catch {
+      return String(error);
+    }
+  })();
+  return /context(?:\s|_|-)?(?:length|window|limit|overflow|exceed)|(?:maximum|max).{0,24}tokens|too many tokens|prompt.{0,24}(?:too large|exceed|limit)/i.test(message);
 }
 function normalizePhaseRegistry(registry) {
-  if (registry?.phases.has(DEFAULT_PHASE_ID) && registry.phases.get(DEFAULT_PHASE_ID)?.filePath !== "") {
-    throw new TypeError(`Configured Phase collides with Rowan built-in Phase "${DEFAULT_PHASE_ID}".`);
+  const core = createCorePhases();
+  const coreNames = new Set(core.map(({ name }) => name));
+  for (const [name, phase] of registry?.phases ?? []) {
+    if (coreNames.has(name) && !phase.core) {
+      throw new TypeError(`Configured Phase collides with Rowan built-in Phase "${name}".`);
+    }
   }
   for (const [name] of registry?.phases ?? []) {
-    if (name === "stop" || name === "continue") {
+    if (name === "continue") {
       throw new TypeError(`Configured Phase name "${name}" is reserved by Rowan routing controls.`);
     }
   }
+  const authored = [...registry?.phases ?? []].filter(([name, phase]) => !coreNames.has(name) || phase.core === false);
   return {
     phases: new Map([
-      [DEFAULT_PHASE_ID, createDefaultPhase()],
-      ...registry?.phases ?? []
+      ...core.map((phase) => [phase.name, phase]),
+      ...authored
     ]),
     entryPhaseId: registry?.entryPhaseId ?? DEFAULT_PHASE_ID
   };
@@ -6130,13 +6547,13 @@ function toJsonValue(value) {
   return value;
 }
 function deferred2() {
-  let resolve8;
+  let resolve9;
   let reject;
   const promise = new Promise((res, rej) => {
-    resolve8 = (value) => res(value);
+    resolve9 = (value) => res(value);
     reject = rej;
   });
-  return { promise, resolve: resolve8, reject };
+  return { promise, resolve: resolve9, reject };
 }
 
 // src/runtime/durable-store.ts
@@ -6158,6 +6575,7 @@ var InMemoryStore = class _InMemoryStore {
   ownerEpoch = 0;
   eventSequence = 0;
   retentionFloor = 1;
+  contextCompactions = /* @__PURE__ */ new Map();
   constructor(options = {}) {
     this.incarnation = options.incarnation ?? createId("store");
   }
@@ -6176,6 +6594,7 @@ var InMemoryStore = class _InMemoryStore {
     for (const [agentId, sequence] of state.nextReadySequence) store.nextReadySequence.set(agentId, sequence);
     store.eventSequence = state.eventSequence;
     store.retentionFloor = Math.max(1, state.retentionFloor ?? 1);
+    for (const [agentId, record] of state.contextCompactions ?? []) store.contextCompactions.set(agentId, clone(record));
     store.ownerEpoch = Math.max(
       0,
       ...state.runs.map((run) => run.execution?.ownerEpoch ?? 0)
@@ -6197,7 +6616,8 @@ var InMemoryStore = class _InMemoryStore {
       retentionFloor: this.retentionFloor,
       nextAgentSequence: [...this.nextAgentSequence.entries()],
       nextReadySequence: [...this.nextReadySequence.entries()],
-      eventSequence: this.eventSequence
+      eventSequence: this.eventSequence,
+      contextCompactions: [...this.contextCompactions.entries()]
     });
   }
   attachOwner(lease) {
@@ -6376,6 +6796,18 @@ var InMemoryStore = class _InMemoryStore {
         actual: -1
       });
     }
+    const coveredThrough = this.contextCompactions.get(agent.id)?.coveredThrough;
+    if (coveredThrough) {
+      const history = this.activeHistory(agent.id, Number.MAX_SAFE_INTEGER);
+      const coveredIndex = history.findIndex((message) => message.id === coveredThrough.messageId);
+      const originalIndex = history.findIndex((message) => message.id === original.id);
+      if (coveredIndex >= 0 && originalIndex >= 0 && originalIndex <= coveredIndex) {
+        throw new RuntimeError("message_history_compacted", {
+          agentId: agent.id,
+          messageId: original.id
+        });
+      }
+    }
     const actualRevision = original.messageRevision ?? 0;
     if (actualRevision !== input.expectedMessageRevision) {
       throw new RuntimeError("message_revision_conflict", {
@@ -6519,10 +6951,10 @@ var InMemoryStore = class _InMemoryStore {
     const run = this.requireRun(input.runId);
     this.assertRevision(run, input.expectedRevision);
     this.assertState(run, ["queued"]);
-    if ([...this.runs.values()].some((candidate) => candidate.agentId === run.agentId && candidate.id !== run.id && candidate.agentSequence < run.agentSequence && !["completed", "failed", "cancelled"].includes(candidate.state))) {
+    if (!isControlRun(run) && [...this.runs.values()].some((candidate) => candidate.agentId === run.agentId && candidate.id !== run.id && candidate.agentSequence < run.agentSequence && !["completed", "failed", "cancelled"].includes(candidate.state))) {
       throw new RuntimeError("run_state_conflict", { runId: run.id, expected: ["queued"], actual: run.state });
     }
-    if ([...this.runs.values()].some((candidate) => candidate.agentId === run.agentId && candidate.id !== run.id && ["running", "input_required"].includes(candidate.state))) {
+    if ([...this.runs.values()].some((candidate) => candidate.agentId === run.agentId && candidate.id !== run.id && (candidate.state === "running" || !isControlRun(run) && candidate.state === "input_required"))) {
       throw new RuntimeError("run_state_conflict", { runId: run.id, expected: ["queued"], actual: run.state });
     }
     if (run.pinnedConfigToken && input.configToken && run.pinnedConfigToken !== input.configToken) {
@@ -6530,7 +6962,7 @@ var InMemoryStore = class _InMemoryStore {
     }
     if (!run.pinnedConfigToken && input.configToken) run.pinnedConfigToken = input.configToken;
     let message;
-    if (!run.checkpoint && !run.initialMessageId) {
+    if (!run.checkpoint && !run.initialMessageId && !isControlRun(run)) {
       const userInput = normalizeUserInput(run.input);
       message = {
         id: input.messageId ?? createId("msg"),
@@ -7205,6 +7637,72 @@ var InMemoryStore = class _InMemoryStore {
     this.requireAgent(agentId);
     return this.activeHistory(agentId, Number.MAX_SAFE_INTEGER);
   }
+  contextStatus(lease, agentId, contextWindow) {
+    this.assertOwner(lease);
+    this.requireAgent(agentId);
+    if (!Number.isFinite(contextWindow) || contextWindow <= 0) {
+      throw new TypeError("contextWindow must be a positive finite number");
+    }
+    const messages = this.contextMessages(lease, agentId);
+    const tokens = estimateMessageTokens(messages);
+    const record = this.contextCompactions.get(agentId);
+    const thresholdTokens = Math.max(0, Math.floor(contextWindow) - 16384);
+    return {
+      tokens,
+      contextWindow: Math.floor(contextWindow),
+      percent: Math.round(tokens / contextWindow * 100),
+      thresholdTokens,
+      estimated: true,
+      ...record?.coveredThrough ? { coveredThrough: clone(record.coveredThrough) } : {}
+    };
+  }
+  contextMessages(lease, agentId, recentTokenBudget = 2e4) {
+    this.assertOwner(lease);
+    this.requireAgent(agentId);
+    if (!Number.isFinite(recentTokenBudget) || recentTokenBudget <= 0) {
+      throw new TypeError("recentTokenBudget must be a positive finite number");
+    }
+    const history = this.activeHistory(agentId, Number.MAX_SAFE_INTEGER);
+    const record = this.contextCompactions.get(agentId);
+    if (!record) return history;
+    const coveredIndex = record.coveredThrough ? history.findIndex((message) => message.id === record.coveredThrough.messageId) : -1;
+    const suffix = coveredIndex >= 0 ? history.slice(coveredIndex + 1) : history;
+    const recent = [];
+    let tokens = 0;
+    for (let index = suffix.length - 1; index >= 0; index -= 1) {
+      const message = suffix[index];
+      const messageTokens = estimateMessageTokens([message]);
+      if (recent.length > 0 && tokens + messageTokens > recentTokenBudget) break;
+      recent.unshift(message);
+      tokens += messageTokens;
+    }
+    const covered = record.coveredThrough ? history.find((message) => message.id === record.coveredThrough.messageId) : void 0;
+    const summary = {
+      id: `context-summary:${record.id}`,
+      agentId,
+      runId: covered?.runId ?? history.at(-1)?.runId ?? `context:${agentId}`,
+      role: "assistant",
+      content: `[Context summary]
+
+${record.summary}`,
+      sequenceWithinRun: covered?.sequenceWithinRun ?? 0,
+      createdAt: record.createdAt,
+      metadata: { kind: "context_summary", compactionId: record.id }
+    };
+    return [summary, ...recent];
+  }
+  commitContextCompaction(lease, record) {
+    this.assertOwner(lease);
+    this.requireAgent(record.agentId);
+    if (record.id.trim().length === 0 || record.summary.trim().length === 0) {
+      throw new TypeError("context compaction id and summary must be non-empty");
+    }
+    const existing = this.contextCompactions.get(record.agentId);
+    if (existing?.id === record.id) return clone(existing);
+    const next = clone(record);
+    this.contextCompactions.set(record.agentId, next);
+    return clone(next);
+  }
   activeHistory(agentId, beforeSequence) {
     return clone([
       ...this.historySeeds.get(agentId) ?? [],
@@ -7287,6 +7785,15 @@ var MemoryOwnedStore = class {
   async compact(input) {
     return this.store.compact(this.lease, input);
   }
+  async contextStatus(agentId, contextWindow) {
+    return this.store.contextStatus(this.lease, agentId, contextWindow);
+  }
+  async contextMessages(agentId, recentTokenBudget) {
+    return this.store.contextMessages(this.lease, agentId, recentTokenBudget);
+  }
+  async commitContextCompaction(record) {
+    return this.store.commitContextCompaction(this.lease, record);
+  }
   async createRun(input) {
     return this.store.createRun(this.lease, input);
   }
@@ -7376,6 +7883,29 @@ function userInputContent(input) {
 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";
+}
+function estimateMessageTokens(messages) {
+  let characters = 0;
+  for (const message of messages) {
+    characters += messageContentText2(message.content).length;
+    characters += 20;
+  }
+  return Math.ceil(characters / 4);
+}
+function messageContentText2(content) {
+  if (typeof content === "string") return content;
+  return content.map((part) => {
+    if (part.type === "text") return part.text;
+    if (part.type === "thinking") return part.thinking;
+    if (part.type === "tool_use") return JSON.stringify(part.input);
+    if (part.type === "tool_result") return JSON.stringify(part.result);
+    if (part.type === "image") return `[image:${part.mimeType}]`;
+    return "";
+  }).join("\n");
+}
 function targetInput(input, metadata) {
   const content = typeof input === "string" ? input : input.content;
   return metadata === void 0 ? { content } : { content, metadata: clone(metadata) };
@@ -7417,6 +7947,9 @@ function assertToolValue(value, argument) {
 
 // src/runtime/sqlite-durable-store.ts
 import { Database } from "bun:sqlite";
+import { appendFileSync, chmodSync, mkdirSync, readFileSync as readFileSync2, rmSync } from "fs";
+import { dirname as dirname7, join as join6, resolve as resolve8 } from "path";
+import { tmpdir as tmpdir2 } from "os";
 var SCHEMA_ID = "rowan.agent.runtime";
 var SCHEMA_VERSION = "2";
 var SCHEMA_VALUE = `${SCHEMA_ID}:${SCHEMA_VERSION}`;
@@ -7521,10 +8054,15 @@ var CURRENT_SCHEMA_SQL = `
 `;
 var SqliteStore = class {
   database;
+  archiveRoot;
+  mirroredEventIds = /* @__PURE__ */ new Map();
+  mirroredCompactionIds = /* @__PURE__ */ new Map();
+  mirroredAgents = /* @__PURE__ */ new Set();
   closed = false;
   configured = false;
   constructor(filename = ":memory:") {
     this.database = new Database(filename, { create: true, readwrite: true, strict: true });
+    this.archiveRoot = filename === ":memory:" ? join6(tmpdir2(), `rowan-context-archives-${crypto.randomUUID()}`) : join6(dirname7(resolve8(filename)), "context-archives");
   }
   async openOwner(input) {
     this.assertOpen();
@@ -7576,6 +8114,10 @@ var SqliteStore = class {
     this.closed = true;
     this.database.close();
   }
+  /** Filesystem location owned by this Store for one Agent's readable archive. */
+  contextArchiveDir(agentId) {
+    return join6(this.archiveRoot, String(agentId));
+  }
   async reserveAgent(lease, input) {
     return this.invoke(lease, (store, current) => store.reserveAgent(current, input));
   }
@@ -7591,6 +8133,15 @@ var SqliteStore = class {
   async reviseMessage(lease, input) {
     return this.invoke(lease, (store, current) => store.reviseMessage(current, input));
   }
+  async contextStatus(lease, agentId, contextWindow) {
+    return this.invoke(lease, (store, current) => store.contextStatus(current, agentId, contextWindow), false);
+  }
+  async contextMessages(lease, agentId, recentTokenBudget) {
+    return this.invoke(lease, (store, current) => store.contextMessages(current, agentId, recentTokenBudget), false);
+  }
+  async commitContextCompaction(lease, record) {
+    return this.invoke(lease, (store, current) => store.commitContextCompaction(current, record));
+  }
   async createRun(lease, input) {
     return this.invoke(lease, (store, current) => store.createRun(current, input));
   }
@@ -7838,6 +8389,64 @@ var SqliteStore = class {
         [consumerId, Number(String(cursor).split(":").at(-1)), null, (/* @__PURE__ */ new Date()).toISOString()]
       );
     }
+    this.mirrorState(state);
+  }
+  /** Append the semantic durable event mirror and remove deleted Agent sidecars. */
+  mirrorState(state) {
+    mkdirSync(this.archiveRoot, { recursive: true, mode: 448 });
+    chmodSync(this.archiveRoot, 448);
+    const currentAgents = new Set(state.agents.map((agent) => String(agent.id)));
+    for (const agentId of this.mirroredAgents) {
+      if (currentAgents.has(agentId)) continue;
+      rmSync(join6(this.archiveRoot, agentId), { recursive: true, force: true });
+      this.mirroredEventIds.delete(agentId);
+      this.mirroredCompactionIds.delete(agentId);
+    }
+    for (const agent of state.agents) {
+      const agentId = String(agent.id);
+      const archiveDir = join6(this.archiveRoot, agentId);
+      const toolDir = join6(archiveDir, "tool-results");
+      mkdirSync(toolDir, { recursive: true, mode: 448 });
+      chmodSync(archiveDir, 448);
+      chmodSync(toolDir, 448);
+      const sessionPath = join6(archiveDir, "session.jsonl");
+      try {
+        chmodSync(sessionPath, 384);
+      } catch {
+      }
+      const known = this.mirroredEventIds.get(agentId) ?? /* @__PURE__ */ new Set();
+      const knownCompactions = this.mirroredCompactionIds.get(agentId) ?? /* @__PURE__ */ new Set();
+      if (known.size === 0 || knownCompactions.size === 0) {
+        try {
+          for (const line of readFileSync2(sessionPath, "utf8").split("\n")) {
+            if (!line.trim()) continue;
+            const parsed = JSON.parse(line);
+            if (parsed.event?.id) known.add(parsed.event.id);
+            if (parsed.record?.id) knownCompactions.add(parsed.record.id);
+          }
+        } catch {
+        }
+      }
+      const lines = state.events.filter((event) => String(event.agentId) === agentId && !known.has(String(event.id))).map((event) => JSON.stringify({ schemaVersion: 1, kind: "rowan_event", event }) + "\n");
+      if (lines.length > 0) {
+        appendFileSync(sessionPath, lines.join(""), { encoding: "utf8", mode: 384 });
+        chmodSync(sessionPath, 384);
+        for (const event of state.events) {
+          if (String(event.agentId) === agentId) known.add(String(event.id));
+        }
+      }
+      const compactionLines = (state.contextCompactions ?? []).filter(([candidateId, record]) => String(candidateId) === agentId && !knownCompactions.has(record.id)).map(([, record]) => JSON.stringify({ schemaVersion: 1, kind: "context_compacted", record }) + "\n");
+      if (compactionLines.length > 0) {
+        appendFileSync(sessionPath, compactionLines.join(""), { encoding: "utf8", mode: 384 });
+        chmodSync(sessionPath, 384);
+        for (const [, record] of state.contextCompactions ?? []) {
+          if (String(record.agentId) === agentId) knownCompactions.add(record.id);
+        }
+      }
+      this.mirroredEventIds.set(agentId, known);
+      this.mirroredCompactionIds.set(agentId, knownCompactions);
+    }
+    this.mirroredAgents = currentAgents;
   }
   requireMatchingOwner(lease, requireLive) {
     const row = this.readOwner();
@@ -7893,6 +8502,9 @@ var SqliteOwnedStore = class {
   }
   store;
   lease;
+  contextArchiveDir(agentId) {
+    return this.store.contextArchiveDir(agentId);
+  }
   reserveAgent(input) {
     return this.store.reserveAgent(this.lease, input);
   }
@@ -7911,6 +8523,15 @@ var SqliteOwnedStore = class {
   compact(input) {
     return this.store.compact(this.lease, input);
   }
+  contextStatus(agentId, contextWindow) {
+    return this.store.contextStatus(this.lease, agentId, contextWindow);
+  }
+  contextMessages(agentId, recentTokenBudget) {
+    return Promise.resolve(this.store.contextMessages(this.lease, agentId, recentTokenBudget));
+  }
+  commitContextCompaction(record) {
+    return this.store.commitContextCompaction(this.lease, record);
+  }
   createRun(input) {
     return this.store.createRun(this.lease, input);
   }
@@ -8016,18 +8637,12 @@ function assertOwnerInput(ownerId, leaseMs) {
 
 // src/index.ts
 function createCoreTools2(input = {}) {
-  return createCoreTools(input).map((tool) => ({
-    name: tool.name,
-    description: tool.description,
-    parameters: tool.parameters,
-    execute: async (args, context, signal) => {
-      const result = await tool.execute(args, { skills: [], toolCallId: context.toolCallId }, signal);
-      return result.ok ? { ok: true, content: result.content } : { ok: false, content: result.content, error: result.error ?? "Tool failed." };
-    }
-  }));
+  return createRuntimeCoreTools(input);
 }
 export {
   AgentRuntime,
+  COMPACT_PHASE_ID,
+  DEFAULT_PHASE_ID,
   ExtensionLifetimeError,
   InMemoryConfigProvider,
   InMemoryStore,
@@ -8038,9 +8653,14 @@ export {
   RuntimeBootstrapRegistry,
   RuntimeError,
   RuntimeExtensionLifetime,
+  STOP_PHASE_ID,
   SqliteStore,
   brandConfigToken,
+  createCompactPhase,
+  createCorePhases,
   createCoreTools2 as createCoreTools,
+  createDefaultPhase,
+  createStopPhase,
   isRuntimeError,
   loadExtensionsFromPath as loadExtensions,
   loadPhase,