@sema-agent/core 5.11.0 → 5.13.0

package/dist/core/runner/runtask.js

@@ -3,7 +3,7 @@ import { CheckpointError, BINDING_CHECKPOINT_VERSION, checkpointVersionOf, MAX_S
 import { engineVersion } from "../version.js";
 import { CONFIG_CATALOG_VERSION, declarationReasons, resolveEffectiveConfig } from "../../config/catalog.js";
 import { eventDefaultOn } from "../../prompt-assembly/event-registry.js";
-import { DEFAULT_COMPACTION_INSTRUCTIONS, createRapidRefillState, isCompactionManualCancel, maybeCompact, nextTrimForceBackoff, recordCompactionAndCheckRapidRefill } from "../auto-compaction.js";
+import { DEFAULT_COMPACTION_INSTRUCTIONS, createRapidRefillState, isCompactionManualCancel, maybeCompact, nextTrimForceBackoff, recordCompactionAndCheckRapidRefill, sanitizeCompactionSettings } from "../auto-compaction.js";
 import { ASK_USER_QUESTION_TOOL_NAME, QUESTION_AWAITS_RESUME } from "../ask-question.js";
 import { computeCostMicroUsd, modelCostToPricing } from "../pricing.js";
 import { emitTrace } from "../trace.js";
@@ -23,7 +23,7 @@ import { OUTPUT_TOOL_NAME, SKILLS_LISTING_PROBE_HEADER, resolveOutputRetries } f
 import { cacheFamilyOf, usageCostMicroUsd } from "./usage-accounting.js";
 import { assembleResult, errorCodeOf } from "./assemble-result.js";
 import { ATTACHMENT_BYTE_CAP, CHANGED_FILES_MAX, AGENT_LISTING_REMOVED_HEADER, SKILLS_LISTING_DELTA_HEADER, SKILLS_LISTING_REMOVED_HEADER, advanceCadenceClock, agentListingDeltaHeader, agentListingInitialHeader, replayAnnouncedListing, replayAnnouncedModels, clipToBytes, collectDateChange, collectDueAttachments, collectInstructionsChange, commitAgentListing, commitInstructionsChange, commitSkillsListing, createAttachmentState, rebaseCadenceWindows, reduceToolEnd, renderAgentListingDelta, renderMcpDroppedTools, renderMcpInstructionsDelta, renderOrphanedBackgroundTasks, selectMcpDroppedBatch, renderSkillsListingDelta, renderToolsDelta, stampWriteAnchor } from "./turn-attachments.js";
-import { buildWorkingFileAttachments, centerAdoptionOption, emitInputTruncated } from "./compaction-call-options.js";
+import { buildWorkingFileAttachments, centerAdoptionOption, emitInputTruncated, forkContextOption } from "./compaction-call-options.js";
 import { prepareTask, resolveCheckpointStore } from "./prepare-task.js";
 import { settleTeardownLeg } from "./teardown-bounded.js";
 import { TOOL_SEARCH_NAME } from "./tool-disclosure.js";
@@ -426,6 +426,12 @@ function makeTurnBoundary(prepared, stats, rs, deps) {
             if (declaredMaxTurns !== undefined && declaredMaxTurns > 0) {
                 ratios.push({ axis: "turn budget", ratio: (stats.turns + 1) / declaredMaxTurns });
             }
+            if (walltimeMonotonicDeadline !== undefined) {
+                const walltimeWindowMs = walltimeMonotonicDeadline - rs.telemetry.taskStartMonotonic;
+                if (walltimeWindowMs > 0) {
+                    ratios.push({ axis: "walltime budget", ratio: (performance.now() - rs.telemetry.taskStartMonotonic) / walltimeWindowMs });
+                }
+            }
             let tightest;
             for (const r of ratios)
                 if (tightest === undefined || r.ratio > tightest.ratio)
@@ -490,7 +496,7 @@ function makeTurnBoundary(prepared, stats, rs, deps) {
                         rs.attach.attachState.surfacedMtime.delete(p);
                     changed = scan.changed;
                 }
-                const backgroundTasksOn = rs.attach.attachmentsCfg?.backgroundTasks === true;
+                const backgroundTasksOn = (rs.attach.attachmentsCfg?.backgroundTasks ?? eventDefaultOn("background_tasks")) === true;
                 const bgTasks = backgroundTasksOn && rs.attach.attachState.postCompactPending ? prepared.listBackgroundTasks() : undefined;
                 const toolsDeltaOn = rs.attach.attachmentsCfg?.toolsDelta === true;
                 const tdRef = toolsDeltaOn ? prepared.toolsDeltaRef : undefined;
@@ -760,6 +766,7 @@ function makeTurnBoundary(prepared, stats, rs, deps) {
                 ...centerAdoptionOption(prepared),
                 model: event.model,
                 compactionModel: prepared.compModel,
+                ...forkContextOption(prepared, false),
                 brain: compactionBrain,
                 getApiKeyAndHeaders: spec.getApiKeyAndHeaders,
                 thinking: prepared.thinking,
@@ -1443,6 +1450,12 @@ export class Runner {
                 errorMessage: err instanceof Error ? err.message : String(err),
                 errorCode: code,
                 ...(remoteEnvFailure !== undefined ? { remoteEnvFailures: remoteEnvFailure } : {}),
+                ...(() => {
+                    const hinted = err.retryAfterMs;
+                    return code === "memory.admission_required" && typeof hinted === "number" && Number.isFinite(hinted) && hinted > 0
+                        ? { retryAfterMs: hinted }
+                        : {};
+                })(),
                 stats: { turns: 0, tokens: 0, toolCalls: 0, cachedTokens: 0, costMicroUsd: 0 },
             };
             emitTrace(spec.tracer ?? this.deps.tracer, () => ({
@@ -1696,9 +1709,7 @@ export class Runner {
             queue.push({ type: "task_notification", notification: item.payload, ...notificationIdent() });
             if (notificationHarness) {
                 const xml = renderTaskNotificationXml(item.payload);
-                const deliver = item.priority === "later"
-                    ? notificationHarness.followUp(xml, { provenance: "engine-note", enginePayload: item.payload })
-                    : notificationHarness.steer(xml, { provenance: "engine-note", enginePayload: item.payload });
+                const deliver = notificationHarness.steer(xml, { provenance: "engine-note", enginePayload: item.payload });
                 void deliver.then(() => item.onDisposition?.("queued"), () => {
                     parkTaskNotification(item.payload, item.priority);
                     item.onDisposition?.("parked");
@@ -1927,7 +1938,8 @@ export class Runner {
         rs.attach.agentListingOn = rs.attach.attachmentsCfg?.agentListing !== false && eventDefaultOn("agent_listing");
         rs.attach.skillsListingOn = rs.attach.attachmentsCfg?.skillsListing !== false && eventDefaultOn("skills_listing");
         const listingsLive = (rs.attach.agentListingOn && prepared.agentListing !== undefined) || (rs.attach.skillsListingOn && prepared.skillsListing !== undefined);
-        rs.attach.attachState = rs.attach.attachmentsCfg !== undefined || listingsLive ? createAttachmentState() : undefined;
+        const backgroundTasksLive = (rs.attach.attachmentsCfg?.backgroundTasks ?? eventDefaultOn("background_tasks")) === true;
+        rs.attach.attachState = rs.attach.attachmentsCfg !== undefined || listingsLive || backgroundTasksLive ? createAttachmentState() : undefined;
         rs.attach.dateState = prepared.dateChange !== undefined ? { announcedDate: prepared.dateChange.legDate } : undefined;
         rs.attach.instrProbe = this.deps.probeInstructionSources;
         rs.attach.instrState =
@@ -1940,7 +1952,7 @@ export class Runner {
                 : undefined;
         rs.counters.cadenceTurns = 0;
         rs.turn.lastTurnHadToolCalls = false;
-        if (rs.attach.attachState !== undefined && rs.attach.attachmentsCfg?.backgroundTasks === true) {
+        if (rs.attach.attachState !== undefined && (rs.attach.attachmentsCfg?.backgroundTasks ?? eventDefaultOn("background_tasks")) === true) {
             try {
                 const branch = await prepared.session.getBranch();
                 for (let i = branch.length - 1; i >= 0; i--) {
@@ -2264,6 +2276,19 @@ export class Runner {
         };
         const withinTaskCompaction = (spec.compaction?.enabled ?? true) && (spec.compaction?.withinTask ?? true);
         const compactionBreaker = { failures: 0 };
+        if (spec.compaction?.enabled ?? true) {
+            const prefixWindow = prepared.model.autoCompactTokens ?? prepared.model.contextTokens ?? prepared.model.contextWindow;
+            if (Number.isFinite(prefixWindow) && prefixWindow > 0) {
+                const prefixSettings = sanitizeCompactionSettings({ ...DEFAULT_COMPACTION_SETTINGS, ...spec.compaction }, prefixWindow);
+                const prefixCompactAt = prefixWindow - prefixSettings.reserveTokens;
+                if (prepared.promptOverheadTokens >= prefixCompactAt) {
+                    this.deps.onError?.(new Error(`compaction cannot help: the fixed request prefix (system prompt + tool schemas, ≈${prepared.promptOverheadTokens} tokens) ` +
+                        `already meets or exceeds the compaction threshold (${prefixCompactAt} of a ${prefixWindow}-token window). ` +
+                        `Compaction only shrinks conversation history, so this run will re-trigger or overflow regardless — ` +
+                        `shrink the system prompt/tool surface or use a larger-window model.`), { phase: "config", sessionId: prepared.sessionId });
+                }
+            }
+        }
         const windowSafetyOptions = (mainModel) => ({
             ...(rs.budget.maxCostMicroUsd !== undefined
                 ? {
@@ -2302,6 +2327,22 @@ export class Runner {
         });
         const stopHook = (spec.hooks ?? this.deps.hooks)?.stop;
         const finalVerificationOn = spec.finalVerification === true;
+        const finalVerifyBudgetFill = () => {
+            let worst = 0;
+            if (rs.budget.maxTokensWindow !== undefined && rs.budget.maxTokensWindow > 0)
+                worst = Math.max(worst, stats.tokens / rs.budget.maxTokensWindow);
+            if (rs.budget.maxCostMicroUsd !== undefined && rs.budget.maxCostMicroUsd > 0)
+                worst = Math.max(worst, stats.costMicroUsd / rs.budget.maxCostMicroUsd);
+            if (walltimeMonotonicDeadline !== undefined && prepared.suspendForResource === undefined) {
+                const windowMs = walltimeMonotonicDeadline - rs.telemetry.taskStartMonotonic;
+                if (windowMs > 0)
+                    worst = Math.max(worst, (performance.now() - rs.telemetry.taskStartMonotonic) / windowMs);
+            }
+            return worst;
+        };
+        const emitFinalVerifyEcho = (body) => {
+            queue.push({ type: "steering_injected", source: "final_verification", preview: body.slice(0, 220), ...ident() });
+        };
         if (stopHook || finalVerificationOn) {
             let consecutiveBlocks = 0;
             prepared.harness.setStopGate(async () => {
@@ -2311,58 +2352,69 @@ export class Runner {
                     (rs.counters.finalVerifyInjections === 0 || (rs.counters.finalVerifyInjections === 1 && rs.counters.groundingSignalPreR9 && !rs.counters.groundingSignalPostR9)) &&
                     rs.counters.wroteThisRun &&
                     prepared.outputRef.set !== true &&
-                    !(rs.limits.effectiveMaxTurns !== undefined && rs.limits.effectiveMaxTurns > 0 && stats.turns >= rs.limits.effectiveMaxTurns - 1)) {
+                    !(rs.limits.effectiveMaxTurns !== undefined && rs.limits.effectiveMaxTurns > 0 && stats.turns >= rs.limits.effectiveMaxTurns - 1) &&
+                    finalVerifyBudgetFill() < 0.9) {
                     rs.counters.finalVerifyInjections += 1;
                     if (rs.counters.finalVerifyInjections === 2) {
+                        const reentryBody = "<system-reminder>[final verification] Your tool calls in this run worked with raw bytes, structural parsing, " +
+                            "or checksum/digest computation — the deliverable very likely embeds verifiable structure (structural fields, an " +
+                            "embedded checksum-family value, reference data it must match, or a replayable deterministic path). You MUST " +
+                            "execute the grounding check that structure supports — recompute the embedded value and compare it against the " +
+                            "declared one, re-parse the structure from the raw bytes and reconcile it with your output, compare against the " +
+                            "reference data, or replay the deterministic path — and REPORT the check's concrete result before finishing. " +
+                            "A closing statement without a reported check result is not verification. If you already ran such a check, state " +
+                            "its concrete result now; if the check mismatches, fix the deliverable first. This is the final reminder from " +
+                            "this verification gate — it will not intervene again.</system-reminder>";
+                        emitFinalVerifyEcho(reentryBody);
                         return [
                             {
                                 role: "user",
                                 engineMinted: true,
-                                content: "<system-reminder>[final verification] Your tool calls in this run worked with raw bytes, structural parsing, " +
-                                    "or checksum/digest computation — the deliverable very likely embeds verifiable structure (structural fields, an " +
-                                    "embedded checksum-family value, reference data it must match, or a replayable deterministic path). You MUST " +
-                                    "execute the grounding check that structure supports — recompute the embedded value and compare it against the " +
-                                    "declared one, re-parse the structure from the raw bytes and reconcile it with your output, compare against the " +
-                                    "reference data, or replay the deterministic path — and REPORT the check's concrete result before finishing. " +
-                                    "A closing statement without a reported check result is not verification. If you already ran such a check, state " +
-                                    "its concrete result now; if the check mismatches, fix the deliverable first. This is the final reminder from " +
-                                    "this verification gate — it will not intervene again.</system-reminder>",
+                                content: reentryBody,
                                 timestamp: Date.now(),
                             },
                         ];
                     }
+                    const nudgeBody = "<system-reminder>[final verification] Before finishing: re-verify the FINAL deliverable through its REAL entry point, " +
+                        "exactly as the acceptance criteria would exercise it — execute the binary/function/endpoint directly and read the ACTUAL " +
+                        "output and exit code. Do NOT rely on earlier self-tests, shell redirections, or assumptions (a program that prints to " +
+                        "stdout is not a program that writes the required file). If anything mismatches the task's requirements, fix it before " +
+                        "finishing. " +
+                        "Treat verification writes as state-harmless: when the deliverable itself is a persisted final " +
+                        "state (for example a committed or pushed file, a deployed artifact, or a required output file), " +
+                        "do not change that state merely to test it. This constrains HOW you verify — it is never a " +
+                        "license to skip the real acceptance path or to check a substitute of your own making: expected " +
+                        "values must come from the task's requirements, never from content you generated. If the real " +
+                        "acceptance path requires a write, use disposable inputs or an isolated target, end in the exact " +
+                        "required final state, and verify that final state before finishing. " +
+                        "If the work relied on a third-party API, library, or model, check the usage contract the object itself declares " +
+                        "(docstrings, metadata, configuration — e.g. prompt conventions shipped with a model) and confirm your calls follow " +
+                        "it rather than a default symmetric usage. Verify not only that the deliverable EXISTS but that the METHOD that " +
+                        "produced it matches the task's requirements. " +
+                        "Choose the verification SURFACE deliberately: check against the reference data, oracle, or evaluation tooling the " +
+                        "task itself provides — re-running your own implementation and getting the same answer is self-consistency, not " +
+                        "correctness — and cross-check through an independent second path where the task or environment offers one " +
+                        "(checksums, runtime artifacts). Verify the PERSISTED artifact — re-read what is actually on disk or committed, " +
+                        "not in-memory state — against every hard constraint from the original task text (numeric bounds, allowed-value " +
+                        "lists, naming semantics, required files), reconciling whole-set completeness: nothing missing, nothing duplicated. " +
+                        "If the deliverable embeds verifiable structure — structural fields, an embedded checksum-family value, " +
+                        "reference data it must match, or a replayable deterministic path — you MUST execute the grounding check " +
+                        "that structure supports and REPORT its concrete result in your closing summary: for such a deliverable, " +
+                        "no reported check result means the work is not finished. " +
+                        "If the task produced neither an executable deliverable nor any verifiable structure or acceptance " +
+                        "oracle to check against, briefly confirm completion and stop. " +
+                        "Residue YOUR OWN testing created (scratch files, running processes, generated outputs the task does not ask for) " +
+                        "is not protected state — if the task's required final state is a clean target, removing your own residue is part " +
+                        "of delivering it. " +
+                        "Verification must never LAUNDER uncertainty: if part of your conclusion was uncertain before this check, keep " +
+                        "reporting it as uncertain unless the check you actually ran resolved it — a re-stated conclusion is not new " +
+                        "evidence.</system-reminder>";
+                    emitFinalVerifyEcho(nudgeBody);
                     return [
                         {
                             role: "user",
                             engineMinted: true,
-                            content: "<system-reminder>[final verification] Before finishing: re-verify the FINAL deliverable through its REAL entry point, " +
-                                "exactly as the acceptance criteria would exercise it — execute the binary/function/endpoint directly and read the ACTUAL " +
-                                "output and exit code. Do NOT rely on earlier self-tests, shell redirections, or assumptions (a program that prints to " +
-                                "stdout is not a program that writes the required file). If anything mismatches the task's requirements, fix it before " +
-                                "finishing. " +
-                                "Treat verification writes as state-harmless: when the deliverable itself is a persisted final " +
-                                "state (for example a committed or pushed file, a deployed artifact, or a required output file), " +
-                                "do not change that state merely to test it. This constrains HOW you verify — it is never a " +
-                                "license to skip the real acceptance path or to check a substitute of your own making: expected " +
-                                "values must come from the task's requirements, never from content you generated. If the real " +
-                                "acceptance path requires a write, use disposable inputs or an isolated target, end in the exact " +
-                                "required final state, and verify that final state before finishing. " +
-                                "If the work relied on a third-party API, library, or model, check the usage contract the object itself declares " +
-                                "(docstrings, metadata, configuration — e.g. prompt conventions shipped with a model) and confirm your calls follow " +
-                                "it rather than a default symmetric usage. Verify not only that the deliverable EXISTS but that the METHOD that " +
-                                "produced it matches the task's requirements. " +
-                                "Choose the verification SURFACE deliberately: check against the reference data, oracle, or evaluation tooling the " +
-                                "task itself provides — re-running your own implementation and getting the same answer is self-consistency, not " +
-                                "correctness — and cross-check through an independent second path where the task or environment offers one " +
-                                "(checksums, runtime artifacts). Verify the PERSISTED artifact — re-read what is actually on disk or committed, " +
-                                "not in-memory state — against every hard constraint from the original task text (numeric bounds, allowed-value " +
-                                "lists, naming semantics, required files), reconciling whole-set completeness: nothing missing, nothing duplicated. " +
-                                "If the deliverable embeds verifiable structure — structural fields, an embedded checksum-family value, " +
-                                "reference data it must match, or a replayable deterministic path — you MUST execute the grounding check " +
-                                "that structure supports and REPORT its concrete result in your closing summary: for such a deliverable, " +
-                                "no reported check result means the work is not finished. " +
-                                "If the task produced neither an executable deliverable nor any verifiable structure or acceptance " +
-                                "oracle to check against, briefly confirm completion and stop.</system-reminder>",
+                            content: nudgeBody,
                             timestamp: Date.now(),
                         },
                     ];
@@ -2433,6 +2485,7 @@ export class Runner {
                             ...centerAdoptionOption(prepared),
                             model: prepared.harness.getModel(),
                             compactionModel: prepared.compModel,
+                            ...forkContextOption(prepared, true),
                             brain: compactionBrain,
                             getApiKeyAndHeaders: spec.getApiKeyAndHeaders,
                             thinking: prepared.thinking,
@@ -2801,7 +2854,7 @@ export class Runner {
                 });
             }
         }
-        if (rs.attach.attachState?.postCompactPending === true && rs.attach.attachmentsCfg?.backgroundTasks === true) {
+        if (rs.attach.attachState?.postCompactPending === true && (rs.attach.attachmentsCfg?.backgroundTasks ?? eventDefaultOn("background_tasks")) === true) {
             emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.announce_dropped", version: 1, taskId: rs.telemetry.taskId, ts: Date.now() }));
         }
         const comp = await this.finish(spec, prepared, {
@@ -3649,6 +3702,7 @@ export class Runner {
                     ...centerAdoptionOption(prepared),
                     model: prepared.model,
                     compactionModel: prepared.compModel,
+                    ...forkContextOption(prepared, false),
                     brain: opts?.brain ?? this.deps.brain,
                     getApiKeyAndHeaders: spec.getApiKeyAndHeaders,
                     thinking: prepared.thinking,

package/dist/core/runner/turn-attachments.js

@@ -367,7 +367,9 @@ function renderBackgroundTasks(tasks) {
                 ? "stopped"
                 : t.status === "running"
                     ? "still running in background"
-                    : t.status;
+                    : t.status === "parked"
+                        ? "parked awaiting an out-of-band approval — do NOT re-issue the gated call"
+                        : t.status;
         return `- [${t.id}] Task "${(t.description ?? "background task").slice(0, PROJECTION_CONTENT_MAX)}" ${phrase}`;
     });
     return ("Context was compacted. Background tasks from before the compaction (check output with TaskOutput, " +

package/dist/core/session-store.d.ts

@@ -10,6 +10,7 @@ export interface TtlSessionStoreOptions {
     evict?: EvictPolicy;
 }
 export declare class TtlSessionStore implements SessionStore {
+    readonly retention: "none";
     private repo;
     private entries;
     private owners;

package/dist/core/session-store.js

@@ -4,6 +4,7 @@ const DAY_MS = 24 * 60 * 60 * 1000;
 import { SESSION_DEFAULT_TTL_DAYS } from "../config/defaults.js";
 export { SESSION_DEFAULT_TTL_DAYS };
 export class TtlSessionStore {
+    retention = "none";
     repo;
     entries = new Map();
     owners = new Map();

package/dist/core/tool-result-store.d.ts

@@ -1,5 +1,6 @@
 import type { AgentTool } from "../internal/harness-types.js";
 export interface ToolResultStore {
+    readonly retention?: import("./retention.js").RetentionDeclaration;
     put(ref: string, content: string): Promise<void> | void;
     get(ref: string, opts?: {
         offset?: number;
@@ -15,6 +16,7 @@ export interface ToolResultSlice {
 }
 export declare class InMemoryToolResultStore implements ToolResultStore {
     private readonly opts?;
+    readonly retention: "none";
     private readonly map;
     private totalChars;
     constructor(opts?: {

package/dist/core/tool-result-store.js

@@ -25,6 +25,7 @@ function refSegment(raw) {
 }
 export class InMemoryToolResultStore {
     opts;
+    retention = "none";
     map = new Map();
     totalChars = 0;
     constructor(opts) {

package/dist/core/types.d.ts

@@ -3,6 +3,10 @@ import type { AgentTool, ThinkingLevel } from "../internal/harness.js";
 import type { CompleteSimpleFn, DocumentContent, ImageContent, Model, ResilienceOptions, StreamFn, TextContent } from "../internal/llm.js";
 import type { TaskNotificationPayload } from "./task-notification.js";
 export type ModelRef = string | Model;
+export interface StaleToolResultOffloadOptions {
+    keepRecentPerTool?: number;
+    minSavingsChars?: number;
+}
 export type ModelRole = "default" | "summarize" | "subagent" | "team" | "synthesize" | "advisor" | "verifier" | "classifier";
 export type RoleSpec = ModelRef | {
     model?: ModelRef;
@@ -371,6 +375,7 @@ export interface TaskSpec {
             maxFiles?: number;
             maxCharsPerFile?: number;
         };
+        staleToolResultOffload?: StaleToolResultOffloadOptions;
         clampTolerance?: number;
     };
     attachments?: {
@@ -382,7 +387,7 @@ export interface TaskSpec {
         };
         planModeReminder?: true;
         budgetUsd?: true;
-        backgroundTasks?: true;
+        backgroundTasks?: boolean;
         toolsDelta?: true;
         agentListing?: boolean;
         skillsListing?: boolean;
@@ -579,7 +584,7 @@ export type TaskEvent = ({
     reason?: string;
 } & TaskEventIdentity) | ({
     type: "steering_injected";
-    source: "limit_approach" | "todo_reminder" | "task_reminder" | "tool_search_usage_reminder" | "changed_files" | "plan_mode" | "date_change" | "instructions_change" | "workflow_size_guideline_change" | "budget_usd" | "background_tasks" | "tools_delta" | "agent_listing" | "skills_listing" | "mcp_instructions" | "mcp_dropped_tools";
+    source: "limit_approach" | "todo_reminder" | "task_reminder" | "tool_search_usage_reminder" | "changed_files" | "plan_mode" | "date_change" | "instructions_change" | "workflow_size_guideline_change" | "budget_usd" | "background_tasks" | "tools_delta" | "agent_listing" | "skills_listing" | "mcp_instructions" | "mcp_dropped_tools" | "final_verification";
     preview: string;
 } & TaskEventIdentity) | ({
     type: "diagnostics";
@@ -732,6 +737,11 @@ export interface RunnerDeps {
     fileSnapshotStore?: import("./file-snapshot-store.js").FileSnapshotStore;
     sessionPolicyStore?: import("./session-policy-store.js").SessionPolicyStore;
     runtimeCapsResolver?: (principal: string | undefined) => RuntimeCaps | undefined | Promise<RuntimeCaps | undefined>;
+    lockedConfig?: import("./locked-config.js").LockedConfig;
+    compliancePostureResolver?: (principal: string | undefined) => import("./compliance.js").CompliancePosture | undefined | Promise<import("./compliance.js").CompliancePosture | undefined>;
+    memoryScopeAdmission?: import("./memory-admission.js").MemoryScopeAdmission;
+    deploymentMemoryScopes?: readonly string[];
+    retentionPolicy?: import("./retention.js").RetentionPolicy;
     autoMode?: {
         rules?: import("./auto-mode-prompt.js").AutoModeRules;
         settingsDenyRules?: readonly string[];

package/dist/engine/compaction/compaction.d.ts

@@ -1,4 +1,4 @@
-import type { Model, StreamFn, Usage } from "../llm/index.js";
+import type { Context, Message, Model, StreamFn, Tool, Usage } from "../llm/index.js";
 import { type AgentCoreCompletionRuntimeDeps } from "../loop/runtime-deps.js";
 import type { AgentMessage, ThinkingLevel } from "../loop/types.js";
 import { CompactionError, type Result, type SessionTreeEntry } from "../harness/types.js";
@@ -47,6 +47,15 @@ export interface CutPointResult {
 }
 export declare function findCutPoint(entries: SessionTreeEntry[], startIndex: number, endIndex: number, keepRecentTokens: number, charsPerToken?: number): CutPointResult;
 export declare const SUMMARIZATION_SYSTEM_PROMPT = "You are a context summarization assistant. Your task is to read a conversation between a user and an AI coding assistant, then produce a structured summary following the exact format specified.\n\nDo NOT continue the conversation. Do NOT respond to any questions in the conversation. ONLY output the structured summary.";
+export interface CompactionForkContext {
+    systemPrompt?: string;
+    systemBlocks?: Context["systemBlocks"];
+    messages: Message[];
+    tools?: Tool[];
+    modelId?: string;
+}
+export declare function extractForkSummaryEnvelope(text: string): string | undefined;
+export declare function forkSummarizationInstruction(customInstructions?: string): string;
 export declare function summaryOutputBudgetTokens(model: Model, settings: CompactionSettings): number;
 export interface SummarizationInputTruncation {
     label: "history" | "turn_prefix";
@@ -77,5 +86,5 @@ export interface CompactionPreparation {
 }
 export declare function prepareCompaction(pathEntries: SessionTreeEntry[], settings: CompactionSettings, charsPerToken?: number, windowTokens?: number): Result<CompactionPreparation | undefined, CompactionError>;
 export { computeFileLists, serializeConversation } from "./utils.js";
-export declare function compact(preparation: CompactionPreparation, model: Model, apiKey: string | undefined, headers?: Record<string, string>, customInstructions?: string, signal?: AbortSignal, thinkingLevel?: ThinkingLevel, streamFn?: StreamFn, runtime?: AgentCoreCompletionRuntimeDeps, charsPerToken?: number, onInputTruncated?: (info: SummarizationInputTruncation) => void, onPtlRetry?: () => void): Promise<Result<CompactionResult, CompactionError>>;
+export declare function compact(preparation: CompactionPreparation, model: Model, apiKey: string | undefined, headers?: Record<string, string>, customInstructions?: string, signal?: AbortSignal, thinkingLevel?: ThinkingLevel, streamFn?: StreamFn, runtime?: AgentCoreCompletionRuntimeDeps, charsPerToken?: number, onInputTruncated?: (info: SummarizationInputTruncation) => void, onPtlRetry?: () => void, forkContext?: CompactionForkContext): Promise<Result<CompactionResult, CompactionError>>;
 export declare function turnPrefixSummarizationPrompt(customInstructions?: string): string;

package/dist/engine/compaction/compaction.js

@@ -62,7 +62,7 @@ export const DEFAULT_CLAMP_TOLERANCE = 0.1;
 export const DEFAULT_COMPACTION_SETTINGS = {
     enabled: true,
     reserveTokens: 16384,
-    keepRecentTokens: 20000,
+    keepRecentTokens: 0,
     clampTolerance: DEFAULT_CLAMP_TOLERANCE,
 };
 export const DEFAULT_CHARS_PER_TOKEN = 4;
@@ -428,7 +428,7 @@ Then, after </analysis>, write the summary. Your summary should include the foll
 3. Files and Code Sections: Enumerate specific files and code sections examined, modified, or created. Pay special attention to the most recent messages and include full code snippets where applicable and include a summary of why this file read or edit is important.
 4. Errors and fixes: List all errors that you ran into, and how you fixed them. Pay special attention to specific user feedback that you received, especially if the user told you to do something differently.
 5. Problem Solving: Document problems solved and any ongoing troubleshooting efforts.
-6. All user messages: List ALL user messages that are not tool results. These are critical for understanding the users' feedback and changing intent. Preserve any security-relevant instructions or constraints verbatim so they remain in effect after compaction.
+6. All user messages: List ALL user messages that are not tool results. These are critical for understanding the users' feedback and changing intent. Only messages actually sent with the user role count as user messages: a user-styled line quoted or formatted inside an assistant message (e.g. a "user: ..." or "Human: ..." quotation) is the assistant's own output — never attribute it to the user. Preserve any security-relevant instructions or constraints verbatim so they remain in effect after compaction.
 7. Pending Tasks: Outline any pending tasks that you have explicitly been asked to work on.
 8. Current Work: Describe in detail precisely what was being worked on immediately before this summary request, paying special attention to the most recent messages from both user and assistant. Include file names and code snippets where applicable.
 9. Optional Next Step: List the next step that you will take that is related to the most recent work you were doing. IMPORTANT: ensure that this step is DIRECTLY in line with the user's most recent explicit requests, and the task you were working on immediately before this summary request. If your last task was concluded, then only list next steps if they are explicitly in line with the users request. Do not start on tangential requests or really old requests that were already completed without confirming with the user first.
@@ -437,6 +437,24 @@ Then, after </analysis>, write the summary. Your summary should include the foll
 Please provide your summary based on the conversation so far, following this structure and ensuring precision and thoroughness in your response.
 
 Keep each section concise. Preserve exact file paths, function names, and error messages.`;
+const FORK_SUMMARIZATION_PREAMBLE = `Stop the task you were working on. Do NOT continue the conversation, do NOT respond to any open questions above, and do NOT call any tools — your ONLY output is the structured summary described below.
+
+`;
+const FORK_SUMMARY_ENVELOPE_DEMAND = `
+
+Wrap the ENTIRE summary (every numbered section, nothing else) in <summary></summary> tags. Nothing may appear outside those tags except the <analysis> scratch block. A response without a closed <summary>...</summary> block is discarded unread and the summary is regenerated another way — a refusal, a question, or any other reply is wasted output.`;
+export function extractForkSummaryEnvelope(text) {
+    const withoutScratch = text.replace(/<analysis>[\s\S]*?<\/analysis>/gi, "");
+    const m = /^\s*<summary>([\s\S]*)<\/summary>\s*$/i.exec(withoutScratch);
+    if (m === null)
+        return undefined;
+    const inner = m[1].trim();
+    return inner === "" ? undefined : inner;
+}
+export function forkSummarizationInstruction(customInstructions) {
+    const base = `${FORK_SUMMARIZATION_PREAMBLE}${SUMMARIZATION_PROMPT}${FORK_SUMMARY_ENVELOPE_DEMAND}`;
+    return customInstructions ? `${base}\n\nAdditional Instructions:\n${customInstructions}` : base;
+}
 const UPDATE_SUMMARIZATION_PROMPT = `The messages above are NEW conversation messages to incorporate into the existing summary provided in <previous-summary> tags.
 
 Update the existing structured summary with new information. RULES:
@@ -455,7 +473,7 @@ First, inside an <analysis>...</analysis> block, note what is new since the prev
 3. Files and Code Sections: [Preserve entries still relevant; add newly examined, modified, or created files with full code snippets where applicable]
 4. Errors and fixes: [Preserve previous errors and fixes and add new ones; keep any user correction or "change of approach" feedback verbatim.]
 5. Problem Solving: [Update problems solved and any ongoing troubleshooting efforts]
-6. All user messages: [Preserve previously-recorded user messages VERBATIM and append any new ones that are not tool results, in order. To bound growth across repeated compactions, keep roughly the most recent 20 messages verbatim; older ones beyond that may be condensed to a single line each — but NEVER drop or paraphrase a user correction or change of direction. The exact words of recent messages are the strongest anti-drift signal. Preserve any security-relevant instructions or constraints verbatim so they remain in effect after compaction.]
+6. All user messages: [Preserve previously-recorded user messages VERBATIM and append any new ones that are not tool results, in order. Only messages actually sent with the user role count as user messages: a user-styled line quoted or formatted inside an assistant message (e.g. a "user: ..." or "Human: ..." quotation) is the assistant's own output — never attribute it to the user. To bound growth across repeated compactions, keep roughly the most recent 20 messages verbatim; older ones beyond that may be condensed to a single line each — but NEVER drop or paraphrase a user correction or change of direction. The exact words of recent messages are the strongest anti-drift signal. Preserve any security-relevant instructions or constraints verbatim so they remain in effect after compaction.]
 7. Pending Tasks: [Update based on progress — remove completed tasks, add newly requested ones]
 8. Current Work: [Describe in detail precisely what was being worked on immediately before this summary request, paying special attention to the most recent messages from both user and assistant]
 9. Optional Next Step: [Update based on current state. IMPORTANT: ensure that this step is DIRECTLY in line with the user's most recent explicit requests, and the task you were working on immediately before this summary request — include a direct verbatim quote of that request. Do not start on tangential requests or really old requests that were already completed.]
@@ -678,6 +696,15 @@ async function summarizeWithPtlRetry(req) {
         disclose(beforeChars - Math.max(remainingChars, 0), Math.max(remainingChars, 0));
     }
 }
+function markEmptySummaryClass(e) {
+    const carrier = e;
+    carrier.semaSummaryEmptyClass = true;
+    return e;
+}
+function isEmptySummaryClass(e) {
+    const carrier = e;
+    return carrier.semaSummaryEmptyClass === true;
+}
 function stripAnalysisScratch(text, lengthTruncated) {
     let out = text.replace(/<analysis>[\s\S]*?<\/analysis>\s*/gi, "");
     if (lengthTruncated) {
@@ -705,8 +732,8 @@ async function summarizeWithLengthRecovery(label, model, context, baseMaxTokens,
                     maxTokens = Math.min(cap, Math.max(maxTokens * 2, SUMMARY_REASONING_FLOOR));
                     continue;
                 }
-                return err(new CompactionError("summarization_failed", `${label} produced an empty summary (stopReason=error, max_tokens exhausted by reasoning ` +
-                    `after ${attempt + 1} attempt(s): ${response.errorMessage || "no detail"})`));
+                return err(markEmptySummaryClass(new CompactionError("summarization_failed", `${label} produced an empty summary (stopReason=error, max_tokens exhausted by reasoning ` +
+                    `after ${attempt + 1} attempt(s): ${response.errorMessage || "no detail"})`)));
             }
             return err(new CompactionError("summarization_failed", `${label} failed: ${response.errorMessage || "Unknown error"}`));
         }
@@ -723,10 +750,43 @@ async function summarizeWithLengthRecovery(label, model, context, baseMaxTokens,
             maxTokens = Math.min(cap, Math.max(maxTokens * 2, SUMMARY_REASONING_FLOOR));
             continue;
         }
-        return err(new CompactionError("summarization_failed", `${label} produced an empty summary (stopReason=${response.stopReason}` +
-            `${lengthTruncated ? ", the output was analysis scratch cut at max_tokens" : ""})`));
+        return err(markEmptySummaryClass(new CompactionError("summarization_failed", `${label} produced an empty summary (stopReason=${response.stopReason}` +
+            `${lengthTruncated ? ", the output was analysis scratch cut at max_tokens" : ""})`)));
     }
 }
+async function forkSummarize(fork, model, baseMaxTokens, apiKey, headers, customInstructions, signal, thinkingLevel, streamFn, runtime, charsPerToken) {
+    const instruction = forkSummarizationInstruction(customInstructions);
+    const context = {
+        ...(fork.systemPrompt !== undefined ? { systemPrompt: fork.systemPrompt } : {}),
+        ...(fork.systemBlocks !== undefined ? { systemBlocks: fork.systemBlocks } : {}),
+        ...(fork.tools !== undefined && fork.tools.length > 0 ? { tools: fork.tools } : {}),
+        messages: [
+            ...fork.messages,
+            { role: "user", content: [{ type: "text", text: instruction }], timestamp: Date.now() },
+        ],
+    };
+    let result;
+    try {
+        result = await summarizeWithLengthRecovery("Summarization", model, context, baseMaxTokens, apiKey, headers, signal, thinkingLevel, streamFn, runtime, charsPerToken);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        if (parsePromptTooLong(msg).isPtl)
+            return { kind: "fallback", detail: msg };
+        throw e;
+    }
+    if (!result.ok) {
+        if (result.error.code === "summarization_failed" && (isEmptySummaryClass(result.error) || parsePromptTooLong(result.error.message).isPtl)) {
+            return { kind: "fallback", detail: result.error.message };
+        }
+        return { kind: "err", error: result.error };
+    }
+    const enveloped = extractForkSummaryEnvelope(result.value);
+    if (enveloped === undefined) {
+        return { kind: "fallback", detail: "fork response lacked a closed <summary> envelope (non-conforming output)" };
+    }
+    return { kind: "ok", summary: enveloped };
+}
 export async function generateSummary(currentMessages, model, summaryBudgetTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel, streamFn, runtime, charsPerToken, onInputTruncated, onPtlRetry) {
     let basePrompt = previousSummary ? UPDATE_SUMMARIZATION_PROMPT : SUMMARIZATION_PROMPT;
     if (customInstructions) {
@@ -866,7 +926,7 @@ Summarize the prefix to provide context for the retained suffix:
 
 Be concise. Focus on what's needed to understand the kept suffix.`;
 export { computeFileLists, serializeConversation } from "./utils.js";
-export async function compact(preparation, model, apiKey, headers, customInstructions, signal, thinkingLevel, streamFn, runtime, charsPerToken, onInputTruncated, onPtlRetry) {
+export async function compact(preparation, model, apiKey, headers, customInstructions, signal, thinkingLevel, streamFn, runtime, charsPerToken, onInputTruncated, onPtlRetry, forkContext) {
     const { firstKeptEntryId, messagesToSummarize, turnPrefixMessages, isSplitTurn, tokensBefore, previousSummary, fileOps, invokedSkills, persistedOutputRefs, elidedMessages, settings, } = preparation;
     if (!firstKeptEntryId) {
         return err(new CompactionError("invalid_session", "First kept entry has no UUID - session may need migration"));
@@ -876,7 +936,25 @@ export async function compact(preparation, model, apiKey, headers, customInstruc
     }
     let summary;
     const summaryBudget = summaryOutputBudgetTokens(model, settings);
-    if (isSplitTurn && turnPrefixMessages.length > 0) {
+    if (forkContext !== undefined && forkContext.messages.length > 0) {
+        const forked = await forkSummarize(forkContext, model, Math.floor(0.8 * summaryBudget), apiKey, headers, customInstructions, signal, thinkingLevel, streamFn, runtime, charsPerToken);
+        if (forked.kind === "ok") {
+            summary = forked.summary;
+        }
+        else if (forked.kind === "err") {
+            return err(forked.error);
+        }
+        else {
+            try {
+                onPtlRetry?.();
+            }
+            catch {
+            }
+        }
+    }
+    if (summary !== undefined) {
+    }
+    else if (isSplitTurn && turnPrefixMessages.length > 0) {
         const [historyResult, turnPrefixResult] = await Promise.all([
             messagesToSummarize.length > 0
                 ? generateSummary(messagesToSummarize, model, summaryBudget, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel, streamFn, runtime, charsPerToken, onInputTruncated, onPtlRetry)

package/dist/engine/harness/agent-harness.js

@@ -27,6 +27,7 @@ function createUserMessage(text, images, provenance) {
     };
 }
 const engineNotePayloads = new WeakMap();
+const ENGINE_NOTE_STEER_BACKLOG_CAP = 50;
 function createFailureMessage(model, error, aborted) {
     return {
         role: "assistant",
@@ -418,7 +419,13 @@ export class AgentHarness {
         };
     }
     async drainQueuedMessages(queue, mode) {
-        const messages = mode === "all" ? queue.splice(0) : queue.splice(0, 1);
+        let count = mode === "all" ? queue.length : 1;
+        if (mode !== "all" && queue.length > 1 && engineNotePayloads.has(queue[0])) {
+            count = 1;
+            while (count < queue.length && engineNotePayloads.has(queue[count]))
+                count++;
+        }
+        const messages = queue.splice(0, count);
         if (messages.length === 0) {
             return messages;
         }
@@ -713,6 +720,9 @@ export class AgentHarness {
     async enqueueInjection(queue, text, options) {
         if (AgentHarness.emptyInjection(text, options))
             return;
+        if (options?.enginePayload !== undefined && queue.filter((q) => engineNotePayloads.has(q)).length >= ENGINE_NOTE_STEER_BACKLOG_CAP) {
+            throw new AgentHarnessError("invalid_state", `engine-note backlog at cap (${ENGINE_NOTE_STEER_BACKLOG_CAP}) — park the payload for the session's next run`);
+        }
         const m = createUserMessage(text, options?.images, options);
         if (options?.enginePayload !== undefined)
             engineNotePayloads.set(m, options.enginePayload);

package/dist/engine/llm/validation.js

@@ -288,5 +288,15 @@ export function validateToolArguments(tool, toolCall) {
         .Errors(args)
         .map((error) => `  - ${formatValidationPath(error)}: ${error.message}`)
         .join("\n") || "Unknown validation error";
-    throw new Error(`Validation failed for tool "${toolCall.name}":\n${errors}\n\nReceived arguments:\n${JSON.stringify(toolCall.arguments, null, 2)}`);
+    const schemaJson = (() => {
+        try {
+            const s = JSON.stringify(tool.parameters);
+            return s.length > VALIDATION_ERROR_SCHEMA_MAX_CHARS ? `${s.slice(0, VALIDATION_ERROR_SCHEMA_MAX_CHARS)}… (schema truncated)` : s;
+        }
+        catch {
+            return "(schema not serializable)";
+        }
+    })();
+    throw new Error(`Validation failed for tool "${toolCall.name}":\n${errors}\n\nReceived arguments:\n${JSON.stringify(toolCall.arguments, null, 2)}\n\nExpected parameter schema:\n${schemaJson}`);
 }
+const VALIDATION_ERROR_SCHEMA_MAX_CHARS = 4_000;