@runtypelabs/sdk 1.8.0 → 1.8.2

package/dist/index.cjs

@@ -2293,12 +2293,22 @@ function getDefaultPlanPath(taskName) {
   const slug = sanitizeTaskSlug(taskName || "task");
   return `.runtype/marathons/${slug}/plan.md`;
 }
+function getDefaultExternalReportPath(taskName) {
+  const slug = sanitizeTaskSlug(taskName || "task");
+  return `${slug}.md`;
+}
 function sanitizeTaskSlug(taskName) {
   return taskName.toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
 }
 
 // src/workflows/default-workflow.ts
+function isExternalTask(state) {
+  return state.workflowVariant === "external";
+}
 function hasSufficientResearchEvidence(state) {
+  if (isExternalTask(state)) {
+    return false;
+  }
   if (state.isCreationTask) {
     return (state.recentReadPaths?.length || 0) >= 1;
   }
@@ -2442,6 +2452,17 @@ var researchPhase = {
   description: "Inspect the repo and identify the correct target file",
   buildInstructions(state) {
     const planPath = state.planPath || getDefaultPlanPath(state.taskName);
+    const reportPath = state.planPath || getDefaultExternalReportPath(state.taskName);
+    if (isExternalTask(state)) {
+      return [
+        "--- Workflow Phase: Research ---",
+        "This is an external web research task, not a repository editing task.",
+        "Research the requested website or external source directly using built-in web tools first.",
+        "Do NOT inspect the local repo or search for a target file unless the user explicitly asks for local workspace changes.",
+        `Write the final markdown report to exactly: ${reportPath}`,
+        "Do NOT end with TASK_COMPLETE until that markdown file has been written."
+      ].join("\n");
+    }
     if (state.isCreationTask) {
       return [
         "--- Workflow Phase: Research ---",
@@ -2461,6 +2482,15 @@ var researchPhase = {
     ].join("\n");
   },
   buildToolGuidance(state) {
+    if (isExternalTask(state)) {
+      const reportPath = state.planPath || getDefaultExternalReportPath(state.taskName);
+      return [
+        "This is a web/external research task.",
+        "Start with built-in web tools such as firecrawl or web search, not local repo discovery tools.",
+        "Do not call search_repo, glob_files, tree_directory, list_directory, or read_file unless the user explicitly asked you to inspect local files.",
+        `Use write_file to save the final markdown report to exactly: ${reportPath}.`
+      ];
+    }
     if (state.isCreationTask) {
       return [
         "This is a creation task \u2014 you are building new files, not editing existing ones.",
@@ -2494,10 +2524,45 @@ var researchPhase = {
       `Next step: write the plan markdown to ${state.planPath} before editing the product file.`
     ].join("\n");
   },
-  interceptToolCall() {
+  interceptToolCall(toolName, _args, ctx) {
+    if (!isExternalTask(ctx.state)) {
+      return void 0;
+    }
+    const normalizedPathArg = typeof _args.path === "string" && _args.path.trim() ? ctx.normalizePath(String(_args.path)) : void 0;
+    const normalizedReportPath = ctx.normalizePath(
+      ctx.state.planPath || getDefaultExternalReportPath(ctx.state.taskName)
+    );
+    if (ctx.isDiscoveryTool(toolName) || toolName === "read_file" || toolName === "restore_file_checkpoint") {
+      return [
+        `Blocked by marathon external research guard: ${toolName} is disabled for web research tasks.`,
+        "Research the requested external source with built-in web tools instead.",
+        "Use local file tools only if the user explicitly asked for workspace inspection or if you are saving the final deliverable."
+      ].join(" ");
+    }
+    if (toolName === "write_file" && normalizedPathArg && normalizedPathArg !== normalizedReportPath) {
+      return [
+        `Blocked by marathon external research guard: write_file must target "${normalizedReportPath}".`,
+        "Save the final markdown report to the required workspace path before TASK_COMPLETE."
+      ].join(" ");
+    }
     return void 0;
   },
   buildRecoveryMessage(state) {
+    if (isExternalTask(state)) {
+      const recent2 = state.sessions.slice(-2);
+      const reportPath = state.planPath || getDefaultExternalReportPath(state.taskName);
+      if (recent2.length < 2 || !recent2.every((session) => session.wroteFiles === false)) {
+        return void 0;
+      }
+      const repeatedSameActions2 = hasRepeatedSameActions(state.sessions);
+      return [
+        "Recovery instruction:",
+        "This web research task is missing its required markdown artifact.",
+        `Your next action must be write_file to "${reportPath}" with the final findings in markdown.`,
+        "Do not end with TASK_COMPLETE until that file has been written.",
+        ...repeatedSameActions2 ? ["You are repeating the same actions; break the loop by writing the final report now."] : []
+      ].join("\n");
+    }
     const recent = state.sessions.slice(-2);
     const normalizedPlanPath = typeof state.planPath === "string" && state.planPath.trim() ? normalizeCandidatePath(state.planPath) : void 0;
     const recentPlanOnlyLoop = Boolean(normalizedPlanPath) && recent.length === 2 && recent.every((session) => {
@@ -2541,6 +2606,12 @@ var researchPhase = {
     ].join("\n");
   },
   shouldForceEndTurn(snapshot, ctx) {
+    if (isExternalTask(ctx.state)) {
+      if (ctx.isDiscoveryTool(snapshot.toolName) && snapshot.actionKeyCount >= 2) {
+        return "this web research task is looping on local repo discovery instead of using external tools";
+      }
+      return void 0;
+    }
     const state = ctx.state;
     const sufficientResearch = hasSufficientResearchEvidence(state);
     if (sufficientResearch && snapshot.discoveryPauseCount >= 12) {
@@ -2553,6 +2624,12 @@ var researchPhase = {
       return "this session exceeded the discovery-tool budget without ending the turn";
     }
     return void 0;
+  },
+  canAcceptCompletion(state, trace) {
+    if (!isExternalTask(state)) {
+      return true;
+    }
+    return Boolean(state.planWritten || trace.planWritten);
   }
 };
 var planningPhase = {
@@ -2779,6 +2856,65 @@ var executionPhase = {
 };
 function classifyVariant(message) {
   const lower = message.toLowerCase();
+  const externalVerbs = [
+    "fetch",
+    "browse",
+    "scrape",
+    "crawl",
+    "download",
+    "visit",
+    "navigate to",
+    "go to",
+    "open the",
+    "look up",
+    "search for",
+    "find out",
+    "check out",
+    "pull up"
+  ];
+  const externalTargets = [
+    "http://",
+    "https://",
+    "www.",
+    ".com",
+    ".org",
+    ".io",
+    ".net",
+    ".dev",
+    "website",
+    "webpage",
+    "web page",
+    "home page",
+    "homepage",
+    "hacker news",
+    "reddit",
+    "twitter",
+    "github.com",
+    "firecrawl",
+    "exa_search"
+  ];
+  const hasExternalVerb = externalVerbs.some((v) => lower.includes(v));
+  const hasExternalTarget = externalTargets.some((t) => lower.includes(t));
+  const modificationVerbs = [
+    "fix",
+    "update",
+    "change",
+    "modify",
+    "edit",
+    "refactor",
+    "improve",
+    "add to",
+    "remove",
+    "delete",
+    "rename",
+    "migrate"
+  ];
+  const hasModificationVerb = modificationVerbs.some(
+    (v) => lower.startsWith(v) || new RegExp(`\\b${v}\\b`).test(lower)
+  );
+  if (hasExternalVerb && hasExternalTarget && !hasModificationVerb) {
+    return "external";
+  }
   const creationPatterns = [
     /^create\b/,
     /^build\b/,
@@ -2799,30 +2935,13 @@ function classifyVariant(message) {
     /^new\b/
   ];
   const hasCreationStart = creationPatterns.some((p) => p.test(lower));
-  const modificationVerbs = [
-    "fix",
-    "update",
-    "change",
-    "modify",
-    "edit",
-    "refactor",
-    "improve",
-    "add to",
-    "remove",
-    "delete",
-    "rename",
-    "migrate"
-  ];
-  const hasModificationVerb = modificationVerbs.some(
-    (v) => lower.startsWith(v) || new RegExp(`\\b${v}\\b`).test(lower)
-  );
   if (hasCreationStart && !hasModificationVerb) {
     return "create";
   }
   return "modify";
 }
 async function generateBootstrapContext(message, localTools, variant) {
-  if (variant === "create") return void 0;
+  if (variant === "create" || variant === "external") return void 0;
   if (!localTools) return void 0;
   const searchTool = localTools.search_repo;
   const globTool = localTools.glob_files;
@@ -2858,7 +2977,7 @@ async function generateBootstrapContext(message, localTools, variant) {
   return ["Bootstrap repo hints:", ...lines].join("\n").slice(0, 1500);
 }
 function buildCandidateBlock(state) {
-  if (!state.bestCandidatePath || state.isCreationTask) return "";
+  if (!state.bestCandidatePath || state.isCreationTask || isExternalTask(state)) return "";
   return [
     "",
     "--- Best Candidate ---",
@@ -3108,7 +3227,11 @@ var designPhase = {
   buildTransitionSummary(_state, _nextPhaseName) {
     return [
       "Automatic phase transition: design \u2192 build.",
-      "Requirements understood. Build the game and deploy it using deploy_sandbox with the files parameter."
+      "Requirements understood. Build the game and deploy it using deploy_sandbox.",
+      "",
+      "MANDATORY: Use the `files` parameter for ALL game HTML/JS/CSS.",
+      "code = minimal Express static server (~4 lines), files = game assets.",
+      "NEVER embed HTML inside res.send() template literals."
     ].join("\n");
   },
   interceptToolCall(toolName, _args, _ctx) {
@@ -3168,7 +3291,32 @@ var buildPhase = {
       "  4. If the deploy fails, read the error output, fix the code, and call deploy_sandbox again.",
       "  5. The sandbox is persistent \u2014 subsequent calls reuse the same sandbox.",
       "  6. Load game libraries from CDN in your HTML (e.g., Three.js from unpkg/cdnjs) OR include them in packageJson.",
-      "  7. Make the game fullscreen by default (width: 100vw, height: 100vh, no margin/padding on body)."
+      "  7. Make the game fullscreen by default (width: 100vw, height: 100vh, no margin/padding on body).",
+      "",
+      "STARTER TEMPLATES \u2014 Copy and customize based on the game type:",
+      "",
+      "ALL templates use this server code:",
+      '  code: `const express = require("express"); const app = express(); app.use(express.static("public")); app.listen(3000, () => console.log("Game server running on port 3000"));`',
+      '  packageJson: { "dependencies": { "express": "^4.18.2" } }',
+      '  language: "javascript"',
+      "",
+      "THREE.JS (3D games \u2014 racing, flying, FPS, etc.):",
+      "  files: {",
+      '    "public/index.html": HTML with <script type="importmap">{"imports":{"three":"https://cdn.jsdelivr.net/npm/three@0.170.0/build/three.module.js"}}</script> and <script type="module" src="game.js"></script>',
+      '    "public/game.js": Import three, create scene/camera/renderer, game loop with requestAnimationFrame',
+      "  }",
+      "",
+      "PHASER (2D games \u2014 platformers, shooters, puzzles):",
+      "  files: {",
+      '    "public/index.html": HTML with <script src="https://cdn.jsdelivr.net/npm/phaser@3.80.1/dist/phaser.min.js"></script> and <script src="game.js"></script>',
+      '    "public/game.js": Phaser.Game config with scenes, preload/create/update lifecycle',
+      "  }",
+      "",
+      "CANVAS 2D (simple games \u2014 pong, snake, breakout):",
+      "  files: {",
+      '    "public/index.html": HTML with <canvas id="game" width="800" height="600"></canvas> and <script src="game.js"></script>',
+      '    "public/game.js": Get canvas context, game loop with requestAnimationFrame, draw calls',
+      "  }"
     ].join("\n");
   },
   buildToolGuidance(_state) {
@@ -3182,8 +3330,23 @@ var buildPhase = {
   isComplete() {
     return false;
   },
-  interceptToolCall(toolName, _args, _ctx) {
-    return blockLocalTools(toolName);
+  interceptToolCall(toolName, args, _ctx) {
+    const localBlock = blockLocalTools(toolName);
+    if (localBlock) return localBlock;
+    if (toolName === "deploy_sandbox" && args) {
+      const hasFiles = args.files && typeof args.files === "object" && Object.keys(args.files).length > 0;
+      const codeStr = typeof args.code === "string" ? args.code : "";
+      const embedsHtml = /res\.send\s*\(/.test(codeStr) && /<html|<body|<script/i.test(codeStr);
+      if (!hasFiles && embedsHtml) {
+        return [
+          "Blocked: You are embedding HTML inside res.send() \u2014 this will break due to nested template literals.",
+          "You MUST use the `files` parameter. Put your game HTML/JS/CSS in files and use a minimal Express static server for code.",
+          'Example: code: `const express = require("express"); const app = express(); app.use(express.static("public")); app.listen(3000);`',
+          'files: { "public/index.html": "<!DOCTYPE html>...", "public/game.js": "// game code" }'
+        ].join("\n");
+      }
+    }
+    return void 0;
   },
   canAcceptCompletion(_state, trace) {
     return trace.entries.some((entry) => entry.startsWith("deploy_sandbox"));
@@ -4901,8 +5064,10 @@ var _AgentsEndpoint = class _AgentsEndpoint {
     return `[${toolName} output (${resultStr.length} chars) saved to ${filePath} \u2014 use read_file to retrieve if needed]`;
   }
   getDefaultPlanPath(taskName) {
-    const slug = this.sanitizeTaskSlug(taskName || "task");
-    return `.runtype/marathons/${slug}/plan.md`;
+    return getDefaultPlanPath(taskName);
+  }
+  getDefaultExternalReportPath(taskName) {
+    return getDefaultExternalReportPath(taskName);
   }
   dirnameOfCandidatePath(candidatePath) {
     const normalized = this.normalizeCandidatePath(candidatePath);
@@ -5008,7 +5173,10 @@ var _AgentsEndpoint = class _AgentsEndpoint {
   }
   sanitizeResumeState(resumeState, taskName) {
     if (!resumeState) return void 0;
-    const planPath = typeof resumeState.planPath === "string" && resumeState.planPath.trim() ? this.normalizeCandidatePath(resumeState.planPath) : this.getDefaultPlanPath(taskName);
+    const workflowVariant = resumeState.workflowVariant;
+    const defaultPlanPath = workflowVariant === "external" ? this.getDefaultExternalReportPath(taskName) : this.getDefaultPlanPath(taskName);
+    const planPath = typeof resumeState.planPath === "string" && resumeState.planPath.trim() ? this.normalizeCandidatePath(resumeState.planPath) : defaultPlanPath;
+    const migratedPlanPath = workflowVariant === "external" && planPath === this.getDefaultPlanPath(taskName) ? this.getDefaultExternalReportPath(taskName) : planPath;
     const candidatePaths = this.dedupeNormalizedCandidatePaths(resumeState.candidatePaths);
     const recentReadPaths = this.dedupeNormalizedCandidatePaths(resumeState.recentReadPaths);
     const normalizedBestCandidatePath = typeof resumeState.bestCandidatePath === "string" && resumeState.bestCandidatePath.trim() ? this.normalizeCandidatePath(resumeState.bestCandidatePath) : void 0;
@@ -5019,7 +5187,7 @@ var _AgentsEndpoint = class _AgentsEndpoint {
     return {
       ...resumeState,
       workflowPhase,
-      planPath,
+      planPath: migratedPlanPath,
       planWritten: Boolean(resumeState.planWritten),
       bestCandidatePath,
       bestCandidateReason: bestCandidatePath ? resumeState.bestCandidateReason : void 0,
@@ -5445,13 +5613,14 @@ var _AgentsEndpoint = class _AgentsEndpoint {
     const taskName = typeof options.trackProgress === "string" ? options.trackProgress : options.trackProgress ? `${agent.name} task` : "";
     const resolvedTaskName = taskName || `${agent.name} task`;
     const seededResumeState = this.sanitizeResumeState(options.resumeState, resolvedTaskName);
+    const classifiedVariant = seededResumeState?.workflowVariant ?? workflow.classifyVariant?.(options.message);
     const state = {
       agentId: id,
       agentName: agent.name,
       taskName: resolvedTaskName,
       status: "running",
       workflowPhase: seededResumeState?.workflowPhase || workflow.phases[0]?.name || "research",
-      planPath: seededResumeState?.planPath || this.getDefaultPlanPath(resolvedTaskName),
+      planPath: seededResumeState?.planPath || (classifiedVariant === "external" ? this.getDefaultExternalReportPath(resolvedTaskName) : this.getDefaultPlanPath(resolvedTaskName)),
       planWritten: seededResumeState?.planWritten || false,
       bestCandidateNeedsVerification: seededResumeState?.bestCandidateNeedsVerification || false,
       bestCandidateVerified: seededResumeState?.bestCandidateVerified || false,
@@ -5474,11 +5643,13 @@ var _AgentsEndpoint = class _AgentsEndpoint {
       ...seededResumeState?.recentReadPaths ? { recentReadPaths: seededResumeState.recentReadPaths } : {},
       ...seededResumeState?.recentActionKeys ? { recentActionKeys: seededResumeState.recentActionKeys } : {}
     };
-    state.workflowVariant = seededResumeState?.workflowVariant ?? workflow.classifyVariant?.(options.message);
+    state.workflowVariant = classifiedVariant;
     state.isCreationTask = seededResumeState?.isCreationTask ?? state.workflowVariant === "create";
     this.updateWorkflowPhase(state, this.createEmptyToolTrace(), workflow);
     let recordId;
     const localToolNames = options.localTools ? Object.keys(options.localTools) : void 0;
+    const builtinToolSchemas = await this.loadBuiltinToolSchemas(options.toolIds);
+    const compactInstructions = this.resolveCompactInstructions(options.compactInstructions, agent);
     if (!options.previousMessages) {
       if (workflow.generateBootstrapContext) {
         state.bootstrapContext = await workflow.generateBootstrapContext(
@@ -5490,7 +5661,7 @@ var _AgentsEndpoint = class _AgentsEndpoint {
         state.bootstrapContext = await this.generateBootstrapDiscoveryContext(
           options.message,
           options.localTools,
-          state.isCreationTask
+          state.isCreationTask || state.workflowVariant === "external"
         );
       }
       const bootstrapCandidate = this.extractBestCandidateFromBootstrapContext(state.bootstrapContext);
@@ -5512,7 +5683,7 @@ var _AgentsEndpoint = class _AgentsEndpoint {
       if (session === 0 && !options.previousMessages) {
         state.originalMessage = options.message;
       }
-      const messages = this.buildSessionMessages(
+      const preparedSession = await this.prepareSessionContext(
         options.message,
         state,
         session,
@@ -5520,61 +5691,93 @@ var _AgentsEndpoint = class _AgentsEndpoint {
         localToolNames,
         continuationContext,
         workflow,
-        options.toolIds
+        options.toolIds,
+        {
+          autoCompactTokenThreshold: options.autoCompactTokenThreshold,
+          contextLimitTokens: options.contextLimitTokens,
+          model: options.model,
+          compactStrategy: options.compactStrategy,
+          compactInstructions,
+          localTools: options.localTools,
+          builtinToolSchemas,
+          onContextCompaction: options.onContextCompaction,
+          onContextNotice: options.onContextNotice
+        }
       );
+      const {
+        messages,
+        requestContextManagement,
+        pendingNativeCompactionEvent
+      } = preparedSession;
       let sessionResult;
       const sessionData = {
         messages,
         debugMode: options.debugMode,
         model: options.model,
-        ...options.toolIds?.length ? { tools: { toolIds: options.toolIds } } : {}
+        ...options.toolIds?.length ? { tools: { toolIds: options.toolIds } } : {},
+        ...requestContextManagement ? { contextManagement: requestContextManagement } : {}
       };
       let sessionToolMessages = [];
-      if (useStream && options.localTools) {
-        const localToolResult = await this.executeWithLocalTools(
-          id,
-          sessionData,
-          sessionLocalTools || options.localTools,
-          sessionCallbacks,
-          {
-            onLocalToolResult: this.createLocalToolLoopGuard(state, sessionTrace, workflow)
-          },
-          state.taskName
-        );
-        if (!localToolResult) {
-          throw new Error("Agent stream ended without a complete event");
+      if (pendingNativeCompactionEvent) {
+        await this.emitContextCompactionEvent(options.onContextCompaction, {
+          phase: "start",
+          ...pendingNativeCompactionEvent
+        });
+      }
+      try {
+        if (useStream && options.localTools) {
+          const localToolResult = await this.executeWithLocalTools(
+            id,
+            sessionData,
+            sessionLocalTools || options.localTools,
+            sessionCallbacks,
+            {
+              onLocalToolResult: this.createLocalToolLoopGuard(state, sessionTrace, workflow)
+            },
+            state.taskName
+          );
+          if (!localToolResult) {
+            throw new Error("Agent stream ended without a complete event");
+          }
+          const { completeEvent, toolMessages: captured } = localToolResult;
+          sessionToolMessages = captured;
+          sessionResult = {
+            success: completeEvent.success,
+            result: completeEvent.finalOutput || "",
+            iterations: completeEvent.iterations,
+            totalCost: completeEvent.totalCost || 0,
+            totalTokens: completeEvent.totalTokens,
+            stopReason: completeEvent.stopReason,
+            error: completeEvent.error
+          };
+        } else if (useStream && options.streamCallbacks) {
+          const completeEvent = await this.executeWithCallbacks(
+            id,
+            sessionData,
+            sessionCallbacks || options.streamCallbacks
+          );
+          if (!completeEvent) {
+            throw new Error("Agent stream ended without a complete event");
+          }
+          sessionResult = {
+            success: completeEvent.success,
+            result: completeEvent.finalOutput || "",
+            iterations: completeEvent.iterations,
+            totalCost: completeEvent.totalCost || 0,
+            totalTokens: completeEvent.totalTokens,
+            stopReason: completeEvent.stopReason,
+            error: completeEvent.error
+          };
+        } else {
+          sessionResult = await this.execute(id, sessionData);
         }
-        const { completeEvent, toolMessages: captured } = localToolResult;
-        sessionToolMessages = captured;
-        sessionResult = {
-          success: completeEvent.success,
-          result: completeEvent.finalOutput || "",
-          iterations: completeEvent.iterations,
-          totalCost: completeEvent.totalCost || 0,
-          totalTokens: completeEvent.totalTokens,
-          stopReason: completeEvent.stopReason,
-          error: completeEvent.error
-        };
-      } else if (useStream && options.streamCallbacks) {
-        const completeEvent = await this.executeWithCallbacks(
-          id,
-          sessionData,
-          sessionCallbacks || options.streamCallbacks
-        );
-        if (!completeEvent) {
-          throw new Error("Agent stream ended without a complete event");
+      } finally {
+        if (pendingNativeCompactionEvent) {
+          await this.emitContextCompactionEvent(options.onContextCompaction, {
+            phase: "complete",
+            ...pendingNativeCompactionEvent
+          });
         }
-        sessionResult = {
-          success: completeEvent.success,
-          result: completeEvent.finalOutput || "",
-          iterations: completeEvent.iterations,
-          totalCost: completeEvent.totalCost || 0,
-          totalTokens: completeEvent.totalTokens,
-          stopReason: completeEvent.stopReason,
-          error: completeEvent.error
-        };
-      } else {
-        sessionResult = await this.execute(id, sessionData);
       }
       const toolTraceSummary = this.buildToolTraceSummary(sessionTrace);
       const effectiveSessionOutput = this.buildEffectiveSessionOutput(
@@ -5661,7 +5864,9 @@ var _AgentsEndpoint = class _AgentsEndpoint {
         }
       }
       if (!state.messages) state.messages = [];
-      if (state.messages.length > 0 && messages.length > state.messages.length) {
+      if (this.isCompactHistoryMessageSet(messages)) {
+        state.messages = [...messages];
+      } else if (state.messages.length > 0 && messages.length > state.messages.length) {
         const newMessages = messages.slice(state.messages.length);
         state.messages.push(...newMessages);
       } else {
@@ -5682,13 +5887,15 @@ var _AgentsEndpoint = class _AgentsEndpoint {
       if (state.sessions.length > 50) {
         state.sessions = state.sessions.slice(-50);
       }
-      if (sessionResult.stopReason === "complete") {
+      const detectedTaskCompletion = this.detectTaskCompletion(sessionResult.result);
+      const acceptedTaskCompletion = detectedTaskCompletion && this.canAcceptTaskCompletion(sessionResult.result, state, sessionTrace, workflow);
+      if (sessionResult.stopReason === "complete" && !detectedTaskCompletion) {
         state.status = "complete";
       } else if (sessionResult.stopReason === "error") {
         state.status = "error";
       } else if (sessionResult.stopReason === "max_cost") {
         state.status = "budget_exceeded";
-      } else if (this.canAcceptTaskCompletion(sessionResult.result, state, sessionTrace, workflow)) {
+      } else if (acceptedTaskCompletion) {
         state.status = "complete";
       } else if (maxCost && state.totalCost >= maxCost) {
         state.status = "budget_exceeded";
@@ -5726,88 +5933,426 @@ var _AgentsEndpoint = class _AgentsEndpoint {
     const upper = output.toUpperCase();
     return _AgentsEndpoint.STOP_PHRASES.some((phrase) => upper.includes(phrase.toUpperCase()));
   }
+  resolveReservedOutputTokens(contextLimitTokens) {
+    if (typeof contextLimitTokens !== "number" || !Number.isFinite(contextLimitTokens) || contextLimitTokens <= 0) {
+      return void 0;
+    }
+    return Math.max(8e3, Math.min(64e3, Math.floor(contextLimitTokens * 0.15)));
+  }
+  resolveEffectiveInputBudgetTokens(contextLimitTokens) {
+    if (typeof contextLimitTokens !== "number" || !Number.isFinite(contextLimitTokens) || contextLimitTokens <= 0) {
+      return void 0;
+    }
+    const reservedOutputTokens = this.resolveReservedOutputTokens(contextLimitTokens) ?? 0;
+    return Math.max(1, contextLimitTokens - reservedOutputTokens);
+  }
+  resolveCompactStrategy(strategy, modelId) {
+    if (strategy === "summary_fallback") {
+      return "summary_fallback";
+    }
+    const normalizedModelId = modelId?.trim().toLowerCase() ?? "";
+    const supportsAnthropicNativeCompaction = normalizedModelId.includes("claude") || normalizedModelId.includes("anthropic");
+    if (strategy === "provider_native") {
+      return supportsAnthropicNativeCompaction ? "provider_native" : "summary_fallback";
+    }
+    return supportsAnthropicNativeCompaction ? "provider_native" : "summary_fallback";
+  }
+  estimateTextTokens(text) {
+    if (!text) return 0;
+    return Math.ceil(text.length / 4);
+  }
+  estimateUnknownTokens(value) {
+    if (typeof value === "string") return this.estimateTextTokens(value);
+    try {
+      return this.estimateTextTokens(JSON.stringify(value));
+    } catch {
+      return 0;
+    }
+  }
+  estimateMessageContentTokens(content) {
+    if (typeof content === "string") return this.estimateTextTokens(content);
+    return content.reduce((total, part) => {
+      if (typeof part.text === "string") total += this.estimateTextTokens(part.text);
+      if (typeof part.image === "string") total += 85;
+      if (typeof part.data === "string") {
+        total += Math.min(200, this.estimateTextTokens(part.data));
+      }
+      return total + 4;
+    }, 0);
+  }
+  estimateToolCallTokens(toolCalls) {
+    if (!toolCalls || toolCalls.length === 0) return 0;
+    return toolCalls.reduce(
+      (sum, toolCall) => sum + 12 + this.estimateTextTokens(toolCall.toolName) + this.estimateUnknownTokens(toolCall.args),
+      0
+    );
+  }
+  estimateToolResultTokens(toolResults) {
+    if (!toolResults || toolResults.length === 0) return 0;
+    return toolResults.reduce(
+      (sum, toolResult) => sum + 12 + this.estimateTextTokens(toolResult.toolName) + this.estimateUnknownTokens(toolResult.result),
+      0
+    );
+  }
+  estimateMessageTokens(message) {
+    return 6 + this.estimateMessageContentTokens(message.content) + this.estimateToolCallTokens(message.toolCalls) + this.estimateToolResultTokens(message.toolResults);
+  }
+  estimateConversationTokens(messages) {
+    return messages.reduce((sum, message) => sum + this.estimateMessageTokens(message), 0);
+  }
+  estimateConversationBreakdown(messages) {
+    let historyTokens = 0;
+    let toolOutputTokens = 0;
+    for (const message of messages) {
+      const contentTokens = this.estimateMessageContentTokens(message.content);
+      const toolCallTokens = this.estimateToolCallTokens(message.toolCalls);
+      const toolResultTokens = this.estimateToolResultTokens(message.toolResults);
+      const messageTotal = 6 + contentTokens + toolCallTokens + toolResultTokens;
+      if (message.role === "tool") {
+        toolOutputTokens += messageTotal;
+      } else {
+        historyTokens += 6 + contentTokens + toolCallTokens;
+        toolOutputTokens += toolResultTokens;
+      }
+    }
+    return {
+      historyTokens,
+      toolOutputTokens,
+      estimatedInputTokens: historyTokens + toolOutputTokens
+    };
+  }
+  estimateToolDefinitionTokens(localTools, builtinToolSchemas) {
+    const localToolDefinitions = Object.entries(localTools || {}).map(([name, definition]) => ({
+      name,
+      description: definition.description,
+      parametersSchema: definition.parametersSchema
+    }));
+    const payload = [...localToolDefinitions, ...builtinToolSchemas];
+    if (payload.length === 0) return 0;
+    return this.estimateUnknownTokens(payload);
+  }
+  async loadBuiltinToolSchemas(toolIds) {
+    if (!toolIds || toolIds.length === 0) return [];
+    try {
+      const schemas = await this.client.get("/tools/schema", { toolIds });
+      return Array.isArray(schemas) ? schemas : [];
+    } catch {
+      return [];
+    }
+  }
+  buildDefaultCompactInstructions() {
+    return [
+      "Preserve changed files or best candidate paths.",
+      "Preserve verification or test results.",
+      "Preserve the current workflow phase and remaining work.",
+      "Preserve unresolved blockers or follow-up risks.",
+      "Preserve artifact references and offloaded tool outputs."
+    ].join(" ");
+  }
+  resolveCompactInstructions(optionInstructions, agent) {
+    if (typeof optionInstructions === "string" && optionInstructions.trim()) {
+      return optionInstructions.trim();
+    }
+    const config = agent.config;
+    if (!config || typeof config !== "object") {
+      return void 0;
+    }
+    const compactInstructions = config.compactInstructions;
+    return typeof compactInstructions === "string" && compactInstructions.trim() ? compactInstructions.trim() : void 0;
+  }
+  extractArtifactReferences(state) {
+    const references = /* @__PURE__ */ new Set();
+    const offloadPrefix = "[Output saved to ";
+    for (const message of state.messages ?? []) {
+      if (!message.toolResults) continue;
+      for (const toolResult of message.toolResults) {
+        if (typeof toolResult.result !== "string") continue;
+        let startIndex = 0;
+        while (startIndex < toolResult.result.length) {
+          const prefixIndex = toolResult.result.indexOf(offloadPrefix, startIndex);
+          if (prefixIndex === -1) break;
+          const pathStart = prefixIndex + offloadPrefix.length;
+          const closingBracket = toolResult.result.indexOf("]", pathStart);
+          if (closingBracket === -1) break;
+          const bracketContent = toolResult.result.slice(pathStart, closingBracket);
+          const separatorIndex = bracketContent.indexOf(" \u2014 ");
+          const pathText = separatorIndex === -1 ? bracketContent.trim() : bracketContent.slice(0, separatorIndex).trim();
+          if (pathText) {
+            references.add(pathText);
+          }
+          startIndex = closingBracket + 1;
+        }
+      }
+    }
+    if (state.planPath) {
+      references.add(state.planPath);
+    }
+    return [...references].slice(0, 8);
+  }
+  buildContextBudgetBreakdown(details) {
+    const conversationBreakdown = this.estimateConversationBreakdown(details.historyMessages);
+    const currentTurnTokens = this.estimateTextTokens(details.currentTurnContent);
+    const toolDefinitionTokens = this.estimateToolDefinitionTokens(
+      details.localTools,
+      details.builtinToolSchemas
+    );
+    const reservedOutputTokens = this.resolveReservedOutputTokens(details.contextLimitTokens);
+    const effectiveInputBudgetTokens = this.resolveEffectiveInputBudgetTokens(details.contextLimitTokens);
+    const summaryTokens = details.summaryText ? this.estimateTextTokens(
+      `${_AgentsEndpoint.AUTO_COMPACT_SUMMARY_PREFIX}
+
+${details.summaryText}
+
+Do NOT redo any of the above work.`
+    ) : void 0;
+    return {
+      historyTokens: conversationBreakdown.historyTokens,
+      toolOutputTokens: conversationBreakdown.toolOutputTokens,
+      currentTurnTokens,
+      toolDefinitionTokens,
+      ...summaryTokens ? { summaryTokens } : {},
+      ...reservedOutputTokens ? { reservedOutputTokens } : {},
+      ...effectiveInputBudgetTokens ? { effectiveInputBudgetTokens } : {},
+      estimatedInputTokens: conversationBreakdown.estimatedInputTokens + currentTurnTokens + toolDefinitionTokens
+    };
+  }
+  async emitContextCompactionEvent(onContextCompaction, event) {
+    if (!onContextCompaction) return;
+    try {
+      await onContextCompaction(event);
+    } catch {
+    }
+  }
+  async emitContextNotice(onContextNotice, event) {
+    if (!onContextNotice) return;
+    try {
+      await onContextNotice(event);
+    } catch {
+    }
+  }
+  async buildCompactHistoryMessagesWithLifecycle(state, userContent, sessionIndex, details) {
+    const baseEvent = {
+      mode: details.mode,
+      strategy: details.strategy,
+      sessionIndex: sessionIndex + 1,
+      model: details.model,
+      estimatedTokens: details.beforeTokens,
+      thresholdTokens: details.thresholdTokens,
+      contextLimitTokens: details.contextLimitTokens,
+      effectiveInputBudgetTokens: details.effectiveInputBudgetTokens,
+      reservedOutputTokens: details.reservedOutputTokens,
+      beforeTokens: details.beforeTokens,
+      afterTokens: details.afterTokens,
+      breakdown: details.breakdown
+    };
+    await this.emitContextCompactionEvent(details.onContextCompaction, {
+      phase: "start",
+      ...baseEvent
+    });
+    const compactMessages = this.buildCompactHistoryMessages(
+      state,
+      userContent,
+      details.compactInstructions,
+      details.mode
+    );
+    await this.emitContextCompactionEvent(details.onContextCompaction, {
+      phase: "complete",
+      ...baseEvent
+    });
+    return compactMessages;
+  }
+  buildCompactHistoryMessages(state, userContent, compactInstructions, mode = "auto") {
+    const summary = this.generateCompactSummary(state, compactInstructions);
+    const prefix = mode === "forced" ? _AgentsEndpoint.FORCED_COMPACT_SUMMARY_PREFIX : _AgentsEndpoint.AUTO_COMPACT_SUMMARY_PREFIX;
+    return [
+      {
+        role: "system",
+        content: `${prefix}
+
+${summary}
+
+Do NOT redo any of the above work.`
+      },
+      {
+        role: "user",
+        content: userContent
+      }
+    ];
+  }
+  isCompactHistoryMessageSet(messages) {
+    if (messages.length === 0) return false;
+    const firstMessage = messages[0];
+    return firstMessage?.role === "system" && typeof firstMessage.content === "string" && (firstMessage.content.startsWith(_AgentsEndpoint.AUTO_COMPACT_SUMMARY_PREFIX) || firstMessage.content.startsWith(_AgentsEndpoint.FORCED_COMPACT_SUMMARY_PREFIX));
+  }
   /**
    * Generate a compact summary of prior work for continuation context.
    * Used when compact mode is enabled to keep token usage low.
    */
-  generateCompactSummary(state) {
-    const sessionSummaries = (state.sessions ?? []).map(
-      (s) => `- Session ${s.index}: ${s.stopReason} ($${s.cost.toFixed(4)}) -- ${s.outputPreview.slice(0, 100)}`
+  generateCompactSummary(state, compactInstructions) {
+    const recentSessions = (state.sessions ?? []).slice(-5);
+    const sessionSummaries = recentSessions.map(
+      (session) => `- Session ${session.index}: ${session.stopReason} ($${session.cost.toFixed(4)}) ${session.outputPreview.slice(0, 160)}`
     ).join("\n");
+    const candidatePaths = Array.from(
+      new Set(
+        [
+          ...state.bestCandidatePath ? [state.bestCandidatePath] : [],
+          ...state.candidatePaths ?? []
+        ].filter(Boolean)
+      )
+    ).slice(0, 8);
+    const verificationSummary = state.bestCandidateVerified ? "Latest candidate verified." : state.bestCandidateNeedsVerification ? "Latest candidate still needs verification." : state.lastVerificationPassed ? "Latest verification passed." : state.verificationRequired ? "Verification is still required." : "No verification requirement recorded.";
+    const artifactReferences = this.extractArtifactReferences(state);
+    const pendingNextStep = state.lastStopReason === "complete" ? "Confirm nothing else remains before declaring the task complete." : `Continue the ${state.workflowPhase || "research"} phase without redoing prior work.`;
+    const instructions = compactInstructions || this.buildDefaultCompactInstructions();
     return [
-      `Task: ${state.taskName}`,
-      `Status: ${state.status}`,
-      `Workflow phase: ${state.workflowPhase || "research"}`,
-      `Sessions completed: ${state.sessionCount}`,
-      `Total cost: $${state.totalCost.toFixed(4)}`,
-      ...state.planPath ? [`Plan path: ${state.planPath}`] : [],
-      ...state.planWritten ? ["Plan written: yes"] : [],
-      ...state.bestCandidatePath ? [
-        `Best candidate: ${state.bestCandidatePath}`,
-        ...state.bestCandidateReason ? [`Candidate reason: ${state.bestCandidateReason}`] : []
-      ] : [],
-      ...state.bootstrapContext ? ["", state.bootstrapContext] : [],
+      "Task + Phase",
+      `- Task: ${state.taskName}`,
+      `- Status: ${state.status}`,
+      `- Workflow phase: ${state.workflowPhase || "research"}`,
+      `- Sessions completed: ${state.sessionCount}`,
+      `- Total cost: $${state.totalCost.toFixed(4)}`,
+      "",
+      "Completed Work",
+      ...sessionSummaries ? [sessionSummaries] : ["- No completed session summaries recorded yet."],
+      "",
+      "Changed Files / Candidate Paths",
+      ...candidatePaths.length > 0 ? candidatePaths.map((candidatePath) => `- ${candidatePath}`) : ["- No candidate paths recorded yet."],
+      ...state.planPath ? [`- ${state.workflowVariant === "external" ? "Report path" : "Plan path"}: ${state.planPath}`] : [],
+      ...state.planWritten ? ["- Planning artifact has been written."] : [],
+      ...state.bestCandidateReason ? [`- Best candidate rationale: ${state.bestCandidateReason}`] : [],
+      "",
+      "Verification Status",
+      `- ${verificationSummary}`,
+      ...state.lastError ? [`- Last error: ${state.lastError}`] : [],
+      "",
+      "Pending Next Step",
+      `- ${pendingNextStep}`,
       "",
-      "Session history:",
-      sessionSummaries,
+      "Artifact / Tool Output References",
+      ...artifactReferences.length > 0 ? artifactReferences.map((reference) => `- ${reference}`) : ["- No offloaded artifacts recorded."],
       "",
-      "Last output (truncated):",
-      (state.lastOutput || "").slice(0, 1500)
+      "Compaction Instructions",
+      `- ${instructions}`,
+      "",
+      "Last Output (truncated)",
+      (state.lastOutput || "").slice(0, 1800) || "- No final output recorded yet."
     ].join("\n");
   }
   /**
    * Build messages for a session, injecting progress context for continuation sessions.
    * Optionally accepts continuation context for marathon resume scenarios.
    */
-  buildSessionMessages(originalMessage, state, sessionIndex, maxSessions, localToolNames, continuationContext, workflow, builtinToolIds) {
+  async buildSessionMessages(originalMessage, state, sessionIndex, maxSessions, localToolNames, continuationContext, workflow, builtinToolIds, compactionOptions) {
+    const prepared = await this.prepareSessionContext(
+      originalMessage,
+      state,
+      sessionIndex,
+      maxSessions,
+      localToolNames,
+      continuationContext,
+      workflow,
+      builtinToolIds,
+      compactionOptions
+    );
+    return prepared.messages;
+  }
+  async prepareSessionContext(originalMessage, state, sessionIndex, maxSessions, localToolNames, continuationContext, workflow, builtinToolIds, compactionOptions) {
     const wf = workflow ?? defaultWorkflow;
+    const compactInstructions = compactionOptions?.compactInstructions;
+    const resolvedStrategy = continuationContext?.compact ? "summary_fallback" : this.resolveCompactStrategy(compactionOptions?.compactStrategy, compactionOptions?.model);
+    const requestContextManagement = resolvedStrategy === "provider_native" && typeof compactionOptions?.autoCompactTokenThreshold === "number" && compactionOptions.autoCompactTokenThreshold > 0 ? {
+      compactStrategy: resolvedStrategy,
+      ...compactInstructions ? { compactInstructions } : {},
+      nativeCompaction: {
+        provider: "anthropic",
+        thresholdTokens: compactionOptions.autoCompactTokenThreshold
+      }
+    } : void 0;
+    const maybeEmitToolDefinitionWarning = async (breakdown) => {
+      if (sessionIndex !== 0) return;
+      if (typeof compactionOptions?.contextLimitTokens !== "number" || compactionOptions.contextLimitTokens <= 0) {
+        return;
+      }
+      if (breakdown.toolDefinitionTokens <= 0) return;
+      const ratio = breakdown.toolDefinitionTokens / compactionOptions.contextLimitTokens;
+      if (ratio < 0.1) return;
+      await this.emitContextNotice(compactionOptions?.onContextNotice, {
+        kind: "tool_definitions_warning",
+        sessionIndex: sessionIndex + 1,
+        model: compactionOptions?.model,
+        message: `Tool definitions consume about ${(ratio * 100).toFixed(1)}% of the ${compactionOptions.contextLimitTokens.toLocaleString()} token context window. Reduce the enabled tool set if context pressure remains high.`,
+        estimatedTokens: breakdown.toolDefinitionTokens,
+        contextLimitTokens: compactionOptions.contextLimitTokens,
+        effectiveInputBudgetTokens: breakdown.effectiveInputBudgetTokens,
+        reservedOutputTokens: breakdown.reservedOutputTokens
+      });
+    };
+    const buildNativeCompactionEvent = (mode, breakdown) => {
+      if (resolvedStrategy !== "provider_native" || typeof compactionOptions?.autoCompactTokenThreshold !== "number" || compactionOptions.autoCompactTokenThreshold <= 0 || breakdown.estimatedInputTokens < compactionOptions.autoCompactTokenThreshold) {
+        return void 0;
+      }
+      return {
+        mode,
+        strategy: resolvedStrategy,
+        sessionIndex: sessionIndex + 1,
+        model: compactionOptions?.model,
+        estimatedTokens: breakdown.estimatedInputTokens,
+        thresholdTokens: compactionOptions.autoCompactTokenThreshold,
+        contextLimitTokens: compactionOptions.contextLimitTokens,
+        effectiveInputBudgetTokens: breakdown.effectiveInputBudgetTokens,
+        reservedOutputTokens: breakdown.reservedOutputTokens,
+        beforeTokens: breakdown.estimatedInputTokens,
+        breakdown
+      };
+    };
     const currentPhase = wf.phases.find((p) => p.name === state.workflowPhase);
     const toolGuidanceLines = currentPhase?.buildToolGuidance(state) ?? [];
     const isDeployWorkflow = wf.name === "deploy";
+    const isExternalTask2 = state.workflowVariant === "external";
+    const requiredArtifactPath = state.planPath;
     const localToolsBlock = localToolNames?.length ? [
       "",
       "--- Local Tools ---",
       `You have access to tools (${localToolNames.join(", ")}) that execute directly on the user's machine.`,
-      ...isDeployWorkflow ? ["Use deploy_sandbox to deploy code and get a live preview URL."] : [
+      ...isDeployWorkflow ? ["Use deploy_sandbox to deploy code and get a live preview URL."] : isExternalTask2 ? [
+        "This is a web/external research task. Do not inspect or edit the local repository unless the user explicitly asked for workspace changes.",
+        ...requiredArtifactPath ? [`Write the final markdown findings to exactly: ${requiredArtifactPath}`] : []
+      ] : [
         "Use these tools to inspect the existing repository and make real file edits \u2014 not just code in your response."
       ],
       ...toolGuidanceLines,
-      ...isDeployWorkflow ? [] : ["Always use write_file to save your output so the user can run it immediately."]
+      ...isDeployWorkflow ? [] : isExternalTask2 ? ["Use write_file only if you want to save the final deliverable into the workspace."] : ["Always use write_file to save your output so the user can run it immediately."]
     ].join("\n") : "";
     const builtinToolNames = builtinToolIds?.map((id) => id.replace(/^builtin:/, ""));
     const builtinToolsBlock = builtinToolNames?.length ? [
       "",
       "--- Built-in Tools ---",
       `You have access to built-in tools (${builtinToolNames.join(", ")}) for web search, web scraping, image generation, and other capabilities.`,
-      "Use these tools when the task requires information from the web, generating images, or other capabilities beyond local file operations."
+      isExternalTask2 ? "This task targets an external site or source. Start with these built-in tools before considering any local file tools." : "Use these tools when the task requires information from the web, generating images, or other capabilities beyond local file operations."
     ].join("\n") : "";
     const toolsBlock = localToolsBlock + builtinToolsBlock;
-    const bootstrapBlock = state.bootstrapContext ? ["", "--- Initial Repository Discovery ---", state.bootstrapContext].join("\n") : "";
+    const bootstrapBlock = state.bootstrapContext ? [
+      "",
+      isExternalTask2 ? "--- Initial Research Context ---" : "--- Initial Repository Discovery ---",
+      state.bootstrapContext
+    ].join("\n") : "";
     const phaseBlock = ["", this.buildPhaseInstructions(state, wf)].join("\n");
     const candidateBlock = wf.buildCandidateBlock?.(state) ?? "";
     const multiSessionInstruction = `This is a multi-session task (session ${sessionIndex + 1}/${maxSessions}). When you have fully completed the task, end your response with TASK_COMPLETE on its own line.`;
     if (continuationContext && sessionIndex === 0) {
       const defaultContinueMessage = "Continue the task. Review your prior work above and proceed with any remaining work. If everything is already complete, respond with TASK_COMPLETE.";
       const userMessage = continuationContext.newUserMessage || defaultContinueMessage;
-      if (continuationContext.compact) {
-        const summary = this.generateCompactSummary(state);
-        const messages2 = [
-          {
-            role: "system",
-            content: `You are continuing a previously completed task. Here is a summary of prior work:
-
-${summary}
-
-Do NOT redo any of the above work.`
-          },
-          {
-            role: "user",
-            content: [userMessage, phaseBlock, toolsBlock, bootstrapBlock, candidateBlock, "", multiSessionInstruction].join("\n")
-          }
-        ];
-        return messages2;
-      }
-      const messages = [
+      const userContent = [
+        userMessage,
+        phaseBlock,
+        toolsBlock,
+        bootstrapBlock,
+        candidateBlock,
+        "",
+        multiSessionInstruction
+      ].join("\n");
+      const fullHistoryMessages = [
         ...continuationContext.previousMessages,
         {
           role: "system",
@@ -5815,14 +6360,79 @@ Do NOT redo any of the above work.`
         },
         {
           role: "user",
-          content: [userMessage, phaseBlock, toolsBlock, bootstrapBlock, candidateBlock, "", multiSessionInstruction].join("\n")
+          content: userContent
         }
       ];
-      return messages;
+      const summaryText = this.generateCompactSummary(state, compactInstructions);
+      const breakdown = this.buildContextBudgetBreakdown({
+        historyMessages: continuationContext.previousMessages,
+        currentTurnContent: userContent,
+        localTools: compactionOptions?.localTools,
+        builtinToolSchemas: compactionOptions?.builtinToolSchemas || [],
+        summaryText,
+        contextLimitTokens: compactionOptions?.contextLimitTokens
+      });
+      await maybeEmitToolDefinitionWarning(breakdown);
+      if (continuationContext.compact) {
+        return {
+          messages: await this.buildCompactHistoryMessagesWithLifecycle(
+            state,
+            userContent,
+            sessionIndex,
+            {
+              mode: "forced",
+              strategy: "summary_fallback",
+              model: compactionOptions?.model,
+              beforeTokens: breakdown.estimatedInputTokens,
+              afterTokens: (breakdown.summaryTokens || 0) + breakdown.currentTurnTokens + breakdown.toolDefinitionTokens,
+              thresholdTokens: compactionOptions?.autoCompactTokenThreshold,
+              contextLimitTokens: compactionOptions?.contextLimitTokens,
+              effectiveInputBudgetTokens: breakdown.effectiveInputBudgetTokens,
+              reservedOutputTokens: breakdown.reservedOutputTokens,
+              breakdown,
+              onContextCompaction: compactionOptions?.onContextCompaction,
+              compactInstructions
+            }
+          ),
+          requestContextManagement
+        };
+      }
+      if (resolvedStrategy === "summary_fallback" && typeof compactionOptions?.autoCompactTokenThreshold === "number" && compactionOptions.autoCompactTokenThreshold > 0 && breakdown.estimatedInputTokens >= compactionOptions.autoCompactTokenThreshold) {
+        return {
+          messages: await this.buildCompactHistoryMessagesWithLifecycle(
+            state,
+            userContent,
+            sessionIndex,
+            {
+              mode: "auto",
+              strategy: "summary_fallback",
+              model: compactionOptions?.model,
+              beforeTokens: breakdown.estimatedInputTokens,
+              afterTokens: (breakdown.summaryTokens || 0) + breakdown.currentTurnTokens + breakdown.toolDefinitionTokens,
+              thresholdTokens: compactionOptions?.autoCompactTokenThreshold,
+              contextLimitTokens: compactionOptions?.contextLimitTokens,
+              effectiveInputBudgetTokens: breakdown.effectiveInputBudgetTokens,
+              reservedOutputTokens: breakdown.reservedOutputTokens,
+              breakdown,
+              onContextCompaction: compactionOptions?.onContextCompaction,
+              compactInstructions
+            }
+          ),
+          requestContextManagement
+        };
+      }
+      return {
+        messages: fullHistoryMessages,
+        requestContextManagement,
+        pendingNativeCompactionEvent: buildNativeCompactionEvent("auto", breakdown)
+      };
     }
     if (sessionIndex === 0) {
       const content2 = [originalMessage, phaseBlock, toolsBlock, bootstrapBlock, candidateBlock, "", multiSessionInstruction].join("\n");
-      return [{ role: "user", content: content2 }];
+      return {
+        messages: [{ role: "user", content: content2 }],
+        requestContextManagement
+      };
     }
     const recentSessions = state.sessions.slice(-5);
     const progressSummary = recentSessions.map(
@@ -5856,10 +6466,49 @@ Do NOT redo any of the above work.`
           ...historyMessages.slice(-MAX_HISTORY_MESSAGES)
         ];
       }
-      return [
+      const summaryText = this.generateCompactSummary(state, compactInstructions);
+      const breakdown = this.buildContextBudgetBreakdown({
+        historyMessages,
+        currentTurnContent: continuationContent,
+        localTools: compactionOptions?.localTools,
+        builtinToolSchemas: compactionOptions?.builtinToolSchemas || [],
+        summaryText,
+        contextLimitTokens: compactionOptions?.contextLimitTokens
+      });
+      await maybeEmitToolDefinitionWarning(breakdown);
+      const messages = [
         ...historyMessages,
         { role: "user", content: continuationContent }
       ];
+      if (resolvedStrategy === "summary_fallback" && typeof compactionOptions?.autoCompactTokenThreshold === "number" && compactionOptions.autoCompactTokenThreshold > 0 && breakdown.estimatedInputTokens >= compactionOptions.autoCompactTokenThreshold) {
+        return {
+          messages: await this.buildCompactHistoryMessagesWithLifecycle(
+            state,
+            continuationContent,
+            sessionIndex,
+            {
+              mode: "auto",
+              strategy: "summary_fallback",
+              model: compactionOptions?.model,
+              beforeTokens: breakdown.estimatedInputTokens,
+              afterTokens: (breakdown.summaryTokens || 0) + breakdown.currentTurnTokens + breakdown.toolDefinitionTokens,
+              thresholdTokens: compactionOptions?.autoCompactTokenThreshold,
+              contextLimitTokens: compactionOptions?.contextLimitTokens,
+              effectiveInputBudgetTokens: breakdown.effectiveInputBudgetTokens,
+              reservedOutputTokens: breakdown.reservedOutputTokens,
+              breakdown,
+              onContextCompaction: compactionOptions?.onContextCompaction,
+              compactInstructions
+            }
+          ),
+          requestContextManagement
+        };
+      }
+      return {
+        messages,
+        requestContextManagement,
+        pendingNativeCompactionEvent: buildNativeCompactionEvent("auto", breakdown)
+      };
     }
     const recoveryMessage = this.buildStuckTurnRecoveryMessage(state, wf);
     const content = [
@@ -5879,7 +6528,10 @@ Do NOT redo any of the above work.`
       "",
       "Continue where you left off. Do not redo previous work. If the task is already complete, respond with TASK_COMPLETE."
     ].join("\n");
-    return [{ role: "user", content }];
+    return {
+      messages: [{ role: "user", content }],
+      requestContextManagement
+    };
   }
   /**
    * Upsert a record to sync long-task progress to the dashboard.
@@ -5929,6 +6581,8 @@ Do NOT redo any of the above work.`
     }
   }
 };
+_AgentsEndpoint.AUTO_COMPACT_SUMMARY_PREFIX = "You are continuing a long-running task. Here is a compact summary of prior work:";
+_AgentsEndpoint.FORCED_COMPACT_SUMMARY_PREFIX = "You are continuing a previously completed task. Here is a summary of prior work:";
 /** Stop phrases that indicate the agent considers its task complete. */
 _AgentsEndpoint.STOP_PHRASES = [
   "DONE:",