@sema-agent/core 5.55.0 → 5.56.0

package/dist/engine/compaction/compaction.js

@@ -2,7 +2,7 @@ import { resolveAgentCoreCompleteFn, } from "../loop/runtime-deps.js";
 import { asAgentMessage, convertToLlm, createCompactionSummaryMessage, createCustomMessage, } from "../harness/messages.js";
 import { buildSessionContext } from "../session/session.js";
 import { CompactionError, err, ok, } from "../harness/types.js";
-import { budgetInvokedSkillsRetention, computeFileLists, createFileOps, extractFileOpsFromMessage, extractInvokedSkills, extractPersistedOutputRefs, formatFileOperations, formatPersistedOutputRefs, PERSISTED_OUTPUT_REFS_MAX_ENTRIES, readElidedMessages, readPersistedOutputRefs, readRetainedInvokedSkills, replaceInvokedSkillBodiesForSummary, serializeConversation, stripFileOperationsFooter, } from "./utils.js";
+import { budgetInvokedSkillsRetention, computeFileLists, createFileOps, extractFileOpsFromMessage, extractInvokedSkills, extractPersistedOutputRefs, formatFileOperations, formatPersistedOutputRefs, PERSISTED_OUTPUT_REFS_MAX_ENTRIES, readElidedMessages, readPersistedOutputRefs, readRetainedInvokedSkills, readUnsummarizedMessages, replaceInvokedSkillBodiesForSummary, serializeConversation, stripFileOperationsFooter, } from "./utils.js";
 function safeJsonStringify(value) {
     try {
         return JSON.stringify(value) ?? "undefined";
@@ -434,6 +434,58 @@ Then, after </analysis>, write the summary. Your summary should include the foll
 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.
    If there is a next step, include direct quotes from the most recent conversation showing exactly what task you were working on and where you left off. This should be verbatim to ensure there's no drift in task interpretation.
 
+Here's an example of how your output should be structured:
+
+<example>
+<analysis>
+[Your thought process, ensuring all points are covered thoroughly and accurately]
+</analysis>
+
+<summary>
+1. Primary Request and Intent:
+   [Detailed description]
+
+2. Key Technical Concepts:
+   - [Concept 1]
+   - [Concept 2]
+   - [...]
+
+3. Files and Code Sections:
+   - [File Name 1]
+      - [Summary of why this file is important]
+      - [Summary of the changes made to this file, if any]
+      - [Important Code Snippet]
+   - [File Name 2]
+      - [Important Code Snippet]
+   - [...]
+
+4. Errors and fixes:
+    - [Detailed description of error 1]:
+      - [How you fixed the error]
+      - [User feedback on the error if any]
+    - [...]
+
+5. Problem Solving:
+   [Description of solved problems and ongoing troubleshooting]
+
+6. All user messages:
+    - [Detailed non tool use user message]
+    - [...]
+
+7. Pending Tasks:
+   - [Task 1]
+   - [Task 2]
+   - [...]
+
+8. Current Work:
+   [Precise description of current work]
+
+9. Optional Next Step:
+   [Optional Next step to take]
+
+</summary>
+</example>
+
 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.`;
@@ -617,13 +669,28 @@ function splitMessageGroups(messages) {
     }
     return groups;
 }
+const SUMMARY_SCRATCH_PREFIX_RE = /^\s*<analysis>[\s\S]*?<\/analysis>\s*/i;
+const SUMMARY_ENVELOPE_RE = /^<summary>([\s\S]*)<\/summary>$/i;
+function stripSummaryEnvelope(text) {
+    const scratch = SUMMARY_SCRATCH_PREFIX_RE.exec(text);
+    const head = scratch === null ? "" : scratch[0];
+    const m = SUMMARY_ENVELOPE_RE.exec(text.slice(head.length).trim());
+    if (m === null)
+        return text;
+    return head + (m[1] ?? "").trim();
+}
 async function summarizeWithPtlRetry(req) {
-    const disclose = (droppedChars, keptChars) => {
+    const disclose = (droppedChars, keptChars, droppedMessages) => {
         if (droppedChars <= 0) {
             return;
         }
         try {
-            req.onInputTruncated?.({ label: req.truncationLabel, droppedChars, keptChars });
+            req.onInputTruncated?.({
+                label: req.truncationLabel,
+                droppedChars,
+                keptChars,
+                ...(droppedMessages !== undefined && droppedMessages > 0 ? { droppedMessages } : {}),
+            });
         }
         catch {
         }
@@ -659,7 +726,11 @@ async function summarizeWithPtlRetry(req) {
             thrown = e;
         }
         if (!didThrow && result && result.ok) {
-            return result;
+            const unwrapped = stripSummaryEnvelope(result.value);
+            if (unwrapped.trim() === "") {
+                return err(markEmptySummaryClass(new CompactionError("summarization_failed", `${req.label} produced an empty summary (the response was an empty <summary> envelope)`)));
+            }
+            return ok(unwrapped);
         }
         const failureMessage = didThrow
             ? thrown instanceof Error
@@ -688,12 +759,14 @@ async function summarizeWithPtlRetry(req) {
         const beforeChars = serialized.length;
         const rollbackTargetChars = Math.max(SUMMARY_INPUT_MIN_KEEP_CHARS, beforeChars - Math.max(gapChars, 1));
         let remainingChars = beforeChars;
+        let droppedMessages = 0;
         while (groups.length > 1 && remainingChars > rollbackTargetChars) {
             const dropped = groups.shift();
+            droppedMessages += dropped.length;
             remainingChars -= serializeConversation(dropped).length + 2;
         }
         droppedForRetry = true;
-        disclose(beforeChars - Math.max(remainingChars, 0), Math.max(remainingChars, 0));
+        disclose(beforeChars - Math.max(remainingChars, 0), Math.max(remainingChars, 0), droppedMessages);
     }
 }
 function markEmptySummaryClass(e) {
@@ -896,6 +969,9 @@ export function prepareCompaction(pathEntries, settings, charsPerToken = DEFAULT
         ? readElidedMessages(pathEntries[prevCompactionIndex].details)
         : undefined;
     const elidedMessages = (prevElided ?? 0) + messagesToSummarize.length + turnPrefixMessages.length;
+    const carriedUnsummarizedMessages = prevCompactionIndex >= 0 && !pathEntries[prevCompactionIndex].fromHook
+        ? readUnsummarizedMessages(pathEntries[prevCompactionIndex].details)
+        : undefined;
     const [summarizeReady, prefixReady] = replaceInvokedSkillBodiesForSummary([messagesToSummarize, turnPrefixMessages], new Set(invokedSkills.map((s) => s.name)));
     return ok({
         firstKeptEntryId,
@@ -908,6 +984,9 @@ export function prepareCompaction(pathEntries, settings, charsPerToken = DEFAULT
         invokedSkills,
         persistedOutputRefs,
         elidedMessages,
+        ...(carriedUnsummarizedMessages !== undefined && carriedUnsummarizedMessages > 0
+            ? { carriedUnsummarizedMessages }
+            : {}),
         settings,
     });
 }
@@ -927,7 +1006,14 @@ 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, forkContext) {
-    const { firstKeptEntryId, messagesToSummarize, turnPrefixMessages, isSplitTurn, tokensBefore, previousSummary, fileOps, invokedSkills, persistedOutputRefs, elidedMessages, settings, } = preparation;
+    const { firstKeptEntryId, messagesToSummarize, turnPrefixMessages, isSplitTurn, tokensBefore, previousSummary, fileOps, invokedSkills, persistedOutputRefs, elidedMessages, carriedUnsummarizedMessages, settings, } = preparation;
+    let uncoveredThisPass = 0;
+    const observeInputTruncated = (info) => {
+        if (info.droppedMessages !== undefined && info.droppedMessages > 0) {
+            uncoveredThisPass += info.droppedMessages;
+        }
+        onInputTruncated?.(info);
+    };
     if (!firstKeptEntryId) {
         return err(new CompactionError("invalid_session", "First kept entry has no UUID - session may need migration"));
     }
@@ -957,10 +1043,10 @@ export async function compact(preparation, model, apiKey, headers, customInstruc
     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)
+                ? generateSummary(messagesToSummarize, model, summaryBudget, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel, streamFn, runtime, charsPerToken, observeInputTruncated, onPtlRetry)
                 :
                     Promise.resolve(ok(previousSummary ? stripFileOperationsFooter(previousSummary) : "No prior history.")),
-            generateTurnPrefixSummary(turnPrefixMessages, model, summaryBudget, apiKey, headers, signal, customInstructions, thinkingLevel, streamFn, runtime, charsPerToken, onInputTruncated, onPtlRetry),
+            generateTurnPrefixSummary(turnPrefixMessages, model, summaryBudget, apiKey, headers, signal, customInstructions, thinkingLevel, streamFn, runtime, charsPerToken, observeInputTruncated, onPtlRetry),
         ]);
         if (!historyResult.ok) {
             return err(historyResult.error);
@@ -971,7 +1057,7 @@ export async function compact(preparation, model, apiKey, headers, customInstruc
         summary = `${historyResult.value}\n\n---\n\n**Turn Context (split turn):**\n\n${turnPrefixResult.value}`;
     }
     else {
-        const summaryResult = await generateSummary(messagesToSummarize, model, summaryBudget, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel, streamFn, runtime, charsPerToken, onInputTruncated, onPtlRetry);
+        const summaryResult = await generateSummary(messagesToSummarize, model, summaryBudget, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel, streamFn, runtime, charsPerToken, observeInputTruncated, onPtlRetry);
         if (!summaryResult.ok) {
             return err(summaryResult.error);
         }
@@ -991,6 +1077,9 @@ export async function compact(preparation, model, apiKey, headers, customInstruc
             ...(invokedSkills !== undefined && invokedSkills.length > 0 ? { invokedSkills } : {}),
             ...(persistedOutputRefs !== undefined && persistedOutputRefs.length > 0 ? { persistedOutputRefs } : {}),
             ...(elidedMessages !== undefined && elidedMessages > 0 ? { elidedMessages } : {}),
+            ...((carriedUnsummarizedMessages ?? 0) + uncoveredThisPass > 0
+                ? { unsummarizedMessages: (carriedUnsummarizedMessages ?? 0) + uncoveredThisPass }
+                : {}),
         },
     });
 }

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

@@ -94,6 +94,10 @@ export declare function extractPersistedOutputRefs(messages: AgentMessage[], int
  *  safe integer, else absent (pre-field sessions / foreign shapes yield undefined ⇒ no wrapper
  *  disclosure — the byte-identical legacy render). */
 export declare function readElidedMessages(details: unknown): number | undefined;
+/** Defensive reader for persisted `CompactionDetails.unsummarizedMessages` (PTL-shortfall accounting): same contract as
+ *  {@link readElidedMessages} — a non-negative safe integer, else absent (pre-field sessions /
+ *  foreign shapes ⇒ no uncovered-scale clause, byte-identical wrapper). */
+export declare function readUnsummarizedMessages(details: unknown): number | undefined;
 /** Defensive reader for persisted `CompactionDetails.activeTools` (RB-402, blackboard [2132]③c/
  *  [2133]): the ToolSearch activation snapshot each landed compaction restates. details is
  *  `unknown` on the wire — pre-field sessions and foreign shapes yield an empty list; non-string/

package/dist/engine/compaction/utils.js

@@ -205,6 +205,12 @@ export function readElidedMessages(details) {
     const raw = details.elidedMessages;
     return typeof raw === "number" && Number.isSafeInteger(raw) && raw >= 0 ? raw : undefined;
 }
+export function readUnsummarizedMessages(details) {
+    if (details === null || typeof details !== "object")
+        return undefined;
+    const raw = details.unsummarizedMessages;
+    return typeof raw === "number" && Number.isSafeInteger(raw) && raw >= 0 ? raw : undefined;
+}
 export function readCompactionActiveTools(details) {
     if (details === null || typeof details !== "object")
         return [];

package/dist/engine/harness/agent-harness.d.ts

@@ -38,6 +38,15 @@ export interface UserMessageProvenance {
      *  projection point `projectHumanInput`) BEFORE the frame wrapping — the harness never rewrites
      *  text, so annotation stays adjacent to the frame it attributes. */
     actor?: ActorAssertion;
+    /** backlog #389 — an OPAQUE record the caller rides on a CALLER-AUTHORED queued frame so a durable
+     *  park can carry the instruction across the suspend instead of losing it. Same sidecar posture as
+     *  {@link UserMessageProvenance.enginePayload} (a WeakMap entry, never a message field, never
+     *  serialized, never interpreted here) but a different lane and a different fate: an engine payload
+     *  is handed back for per-session redelivery, a park record is handed to the checkpoint mint through
+     *  {@link AgentHarness.readParkableUserInputs}. The harness holds the FRAMED text; the record is what
+     *  the parked-steer queue needs (pre-framing text + trust + inputId), which only the minting seam
+     *  knows — hence opaque. */
+    parkRecord?: unknown;
 }
 /**
  * Harness-level recovery wiring (design/118 ④b/⑤). The loop's prompt-too-long seam wants a
@@ -80,6 +89,23 @@ export declare class AgentHarness<TSkill extends Skill = Skill, TPromptTemplate
      *  boundary so the loop exits CLEANLY (emit `agent_end` + return) WITHOUT an abort/interrupt — the path a
      *  resource-slice suspend needs (an abort would trip the orphan-[INTERRUPTED] reconcile = corrupt resume). */
     private _stopAfterTurn;
+    /** backlog #389 — one-way latch set by {@link abort}. Read by `drainQueuedMessages`: no boundary may
+     *  hand a queued frame to the model once the run is unwinding, and — crucially — none may SPLICE one
+     *  out of the queue either (that would delete the terminal undrained account the abort path owes it). */
+    private aborting;
+    /** backlog #389 (codex adversarial r1, HIGH-1) — frames a boundary has REMOVED from a queue but that
+     *  have not yet entered the model's context.
+     *
+     *  The abort latch alone leaves a real window: `drainQueuedMessages` splices first and then awaits
+     *  `emitQueueUpdate`, and even after it returns the loop has one more decision point before it injects
+     *  anything. An `abort()` landing in either gap finds both queues empty, so the terminal account —
+     *  which reads the queues — reports zero for a frame that will never reach the model. That is the very
+     *  silent loss this ticket exists to close, one layer deeper.
+     *
+     *  A frame sits here from the splice until its `message_end` (the moment it is in the transcript);
+     *  the terminal account, the abort snapshot and the durable-park migration all read it alongside the
+     *  queues, so "accepted" is covered end to end rather than only while it happens to be in an array. */
+    private drainedPendingInjection;
     private runAbortController?;
     private runPromise?;
     private pendingSessionWrites;
@@ -189,6 +215,11 @@ export declare class AgentHarness<TSkill extends Skill = Skill, TPromptTemplate
     private createContext;
     private createStreamFn;
     private drainQueuedMessages;
+    /** #389 — drop these frames from the in-flight account (they went back on a queue, or they landed). */
+    private unbookInFlight;
+    /** #389 — a queued frame has reached the transcript: it is delivered, so it leaves the in-flight
+     *  account and gives up its park record (a suspend must never re-park what the model has read). */
+    private settleInjectedFrame;
     private createLoopConfig;
     /**
      * design/118 ④b/⑤: wire (or clear) the loop's recovery chains. The runner calls this after
@@ -279,6 +310,59 @@ export declare class AgentHarness<TSkill extends Skill = Skill, TPromptTemplate
      * the queue is empty.
      */
     flushQueuedSessionWrites(): Promise<void>;
+    /**
+     * backlog #389 — the accepted-but-undelivered CALLER frames a durable suspend can carry forward,
+     * in delivery order (steer before followUp, each queue forward — the order the live loop serves).
+     * NON-DESTRUCTIVE by design: the mint that reads this may still fail to commit, and a frame dropped
+     * for a checkpoint that never landed would be lost twice over. {@link dropParkedUserInputs} is the
+     * second half, called only once the checkpoint is durably committed.
+     *
+     * Only frames carrying a park record are returned — engine-authored notes have their own lossless
+     * lane (`onUndrainedEngineNotes` → pend per session) and must not be parked twice.
+     */
+    readParkableUserInputs(): unknown[];
+    /**
+     * backlog #389 — the COMMIT half of {@link readParkableUserInputs}: the named records are now durable
+     * on a checkpoint, so their live frames leave the queues (identity-matched on the sidecar). Dropping
+     * them here is what keeps the terminal `#259` account honest — a migrated instruction is not "accepted
+     * then lost", and one this is never called for (a failed commit) still gets its loud undrained notice.
+     * Returns the per-lane drop counts so the caller can subtract them from an account already taken.
+     */
+    dropParkedUserInputs(records: readonly unknown[]): {
+        steer: number;
+        followUp: number;
+    };
+    /**
+     * backlog #389 (CC 2.1.223 `control_request:"interrupt"`, `CC:1064478-1064513`) — an interrupt does
+     * NOT destroy accepted user input. CC's default keeps the queue and answers `still_queued`; only an
+     * explicit `cancel_queued` cancels, with a per-uuid `cancelled` receipt. This harness had the opposite
+     * polarity: both queues were emptied unconditionally and the contents handed back on a result object
+     * with ZERO readers in the repo — so the #259 "accepted then never consumed must be LOUD" account (run
+     * at `agent_end`) counted the emptied queues and found nothing to announce. An input accepted one
+     * millisecond before `interrupt()` therefore vanished behind its own `queued` receipt.
+     *
+     * The queues are now LEFT STANDING. The abort latch above stops any surviving boundary from draining
+     * (or silently splicing) them, and the terminal `agent_end` account — the one disclosure leg, unchanged
+     * — reports them through `onUndrainedUserInputs` + the `settled` frame, exactly as it does for a run
+     * that ended naturally with input still queued. Engine notes keep their own lossless recovery sweep,
+     * which must still run HERE: it is the one path `agent_end` cannot cover on its own (this sweep also
+     * serves a `waitForIdle` that never reaches `agent_end`).
+     *
+     * A sema `interrupt()` ends the RUN (CC's ends a turn inside a living session), so there is no state in
+     * which "still queued" means "will run next" — hence no `cancel_queued` opt-in: its two settings would
+     * be indistinguishable at the package face, which is the dead-knob shape this same ticket family flags
+     * elsewhere. The CC-shaped "survives the pause" seat is the DURABLE PARK, served by
+     * {@link readParkableUserInputs}.
+     *
+     * RECORDED, because the two halves must not be read as contradicting each other (adversarial r2
+     * MEDIUM-6): the #259 notice says a stranded input is "NOT redelivered", and that is a statement about
+     * the RUNNER's contract — a `TaskStream.steer` is never served to a later run, because the Runner
+     * builds one harness per run and prompts it exactly once. A host driving `AgentHarness` DIRECTLY (it is
+     * not on the package export surface) and re-prompting the same instance WILL see the leftovers served,
+     * both the queued ones (true before this ticket too) and the in-flight ones the next `prompt()`
+     * restores. Clearing them here instead is not available: the durable-park migration reads them AFTER
+     * this method returns, so an abort that empties the queues would take the park's payload with it.
+     */
     abort(): Promise<AbortResult>;
     waitForIdle(): Promise<void>;
     subscribe(listener: (event: AgentHarnessEvent<TSkill, TPromptTemplate>, signal?: AbortSignal) => Promise<void> | void): () => void;

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

@@ -35,6 +35,8 @@ function createUserMessage(text, images, provenance) {
 }
 const engineNotePayloads = new WeakMap();
 const engineAuthoredInjections = new WeakSet();
+const userInputParkRecords = new WeakMap();
+const drainedFromLane = new WeakMap();
 function isEngineAuthoredInjection(options) {
     if (options === undefined)
         return false;
@@ -160,6 +162,8 @@ export class AgentHarness {
     session;
     phase = "idle";
     _stopAfterTurn = false;
+    aborting = false;
+    drainedPendingInjection = [];
     runAbortController;
     runPromise;
     pendingSessionWrites = [];
@@ -170,7 +174,7 @@ export class AgentHarness {
     onEngineNoteConsumed;
     engineInjectionsHeld;
     recoverUndrainedEngineNotes() {
-        this.sweepUndrainedEngineNotes([this.nextTurnQueue, this.steerQueue, this.followUpQueue]);
+        this.sweepUndrainedEngineNotes([this.drainedPendingInjection, this.nextTurnQueue, this.steerQueue, this.followUpQueue]);
     }
     sweepUndrainedEngineNotes(queues) {
         const undrained = [];
@@ -193,9 +197,10 @@ export class AgentHarness {
         }
     }
     announceUndrainedUserInputs() {
+        const inFlight = (lane) => this.drainedPendingInjection.filter((m) => !engineAuthoredInjections.has(m) && drainedFromLane.get(m) === lane).length;
         const counts = {
-            steer: this.steerQueue.filter((m) => !engineAuthoredInjections.has(m)).length,
-            followUp: this.followUpQueue.filter((m) => !engineAuthoredInjections.has(m)).length,
+            steer: this.steerQueue.filter((m) => !engineAuthoredInjections.has(m)).length + inFlight("steer"),
+            followUp: this.followUpQueue.filter((m) => !engineAuthoredInjections.has(m)).length + inFlight("followUp"),
         };
         if ((counts.steer > 0 || counts.followUp > 0) && this.onUndrainedUserInputs) {
             try {
@@ -452,6 +457,8 @@ export class AgentHarness {
     }
     async drainQueuedMessages(queue, mode) {
         let messages;
+        if (this.aborting)
+            return [];
         if (this.engineInjectionsHeld?.() === true) {
             messages = [];
             const limit = mode === "all" ? Number.POSITIVE_INFINITY : 1;
@@ -474,6 +481,12 @@ export class AgentHarness {
         if (messages.length === 0) {
             return messages;
         }
+        const lane = queue === this.steerQueue ? "steer" : queue === this.followUpQueue ? "followUp" : undefined;
+        if (lane !== undefined) {
+            for (const m of messages)
+                drainedFromLane.set(m, lane);
+            this.drainedPendingInjection.push(...messages);
+        }
         try {
             await this.emitQueueUpdate();
             for (const m of messages) {
@@ -485,15 +498,28 @@ export class AgentHarness {
                     catch {
                     }
                 }
-                engineNotePayloads.delete(m);
             }
             return messages;
         }
         catch (error) {
             queue.unshift(...messages);
+            this.unbookInFlight(messages);
             throw normalizeHookError(error);
         }
     }
+    unbookInFlight(messages) {
+        if (messages.length === 0 || this.drainedPendingInjection.length === 0)
+            return;
+        const gone = new Set(messages);
+        this.drainedPendingInjection = this.drainedPendingInjection.filter((m) => !gone.has(m));
+    }
+    settleInjectedFrame(message) {
+        if (!this.drainedPendingInjection.includes(message))
+            return;
+        this.unbookInFlight([message]);
+        userInputParkRecords.delete(message);
+        engineNotePayloads.delete(message);
+    }
     createLoopConfig(getTurnState, setTurnState) {
         const turnState = getTurnState();
         const self = this;
@@ -633,6 +659,7 @@ export class AgentHarness {
             let entryId;
             if (!isEmptyFailureAssistant(event.message)) {
                 entryId = await this.session.appendMessage(event.message);
+                this.settleInjectedFrame(event.message);
             }
             await this.emitAny(entryId !== undefined ? { ...event, entryId } : event, signal);
             return;
@@ -656,7 +683,7 @@ export class AgentHarness {
         }
         if (event.type === "agent_end") {
             await this.flushPendingSessionWrites();
-            this.sweepUndrainedEngineNotes([this.nextTurnQueue, this.steerQueue, this.followUpQueue]);
+            this.sweepUndrainedEngineNotes([this.drainedPendingInjection, this.nextTurnQueue, this.steerQueue, this.followUpQueue]);
             const undrainedUser = this.announceUndrainedUserInputs();
             this.phase = "idle";
             await this.emitAny(event, signal);
@@ -757,6 +784,19 @@ export class AgentHarness {
             throw new AgentHarnessError("busy", "AgentHarness is busy");
         }
         this._stopAfterTurn = false;
+        this.aborting = false;
+        if (this.drainedPendingInjection.length > 0) {
+            const stranded = this.drainedPendingInjection;
+            this.drainedPendingInjection = [];
+            for (let i = stranded.length - 1; i >= 0; i--) {
+                const frame = stranded[i];
+                const lane = drainedFromLane.get(frame);
+                if (lane === "steer")
+                    this.steerQueue.unshift(frame);
+                else if (lane === "followUp")
+                    this.followUpQueue.unshift(frame);
+            }
+        }
         this.phase = "turn";
         const finishRunPromise = this.startRunPromise();
         try {
@@ -786,6 +826,8 @@ export class AgentHarness {
             engineNotePayloads.set(m, options.enginePayload);
         if (isEngineAuthoredInjection(options))
             engineAuthoredInjections.add(m);
+        if (options?.parkRecord !== undefined)
+            userInputParkRecords.set(m, options.parkRecord);
         queue.push(m);
         await this.emitQueueUpdate();
     }
@@ -938,12 +980,41 @@ export class AgentHarness {
             throw normalizeHarnessError(error, "session");
         }
     }
+    readParkableUserInputs() {
+        const out = [];
+        for (const q of [this.drainedPendingInjection, this.steerQueue, this.followUpQueue]) {
+            for (const m of q) {
+                const record = userInputParkRecords.get(m);
+                if (record !== undefined)
+                    out.push(record);
+            }
+        }
+        return out;
+    }
+    dropParkedUserInputs(records) {
+        const dropped = { steer: 0, followUp: 0 };
+        if (records.length === 0)
+            return dropped;
+        const migrated = new Set(records);
+        for (const q of [this.drainedPendingInjection, this.steerQueue, this.followUpQueue]) {
+            const fixedLane = q === this.steerQueue ? "steer" : q === this.followUpQueue ? "followUp" : undefined;
+            for (let i = 0; i < q.length; i++) {
+                const frame = q[i];
+                const record = userInputParkRecords.get(frame);
+                if (record === undefined || !migrated.has(record))
+                    continue;
+                const lane = fixedLane ?? drainedFromLane.get(frame);
+                userInputParkRecords.delete(frame);
+                q.splice(i, 1);
+                i--;
+                if (lane !== undefined)
+                    dropped[lane] += 1;
+            }
+        }
+        return dropped;
+    }
     async abort() {
-        this.sweepUndrainedEngineNotes([this.nextTurnQueue, this.steerQueue, this.followUpQueue]);
-        const clearedSteer = [...this.steerQueue];
-        const clearedFollowUp = [...this.followUpQueue];
-        this.steerQueue = [];
-        this.followUpQueue = [];
+        this.aborting = true;
         this.runAbortController?.abort();
         const errors = [];
         try {
@@ -958,8 +1029,13 @@ export class AgentHarness {
         catch (error) {
             errors.push(toError(error));
         }
+        this.sweepUndrainedEngineNotes([this.drainedPendingInjection, this.nextTurnQueue, this.steerQueue, this.followUpQueue]);
+        const userAuthored = (m) => !engineAuthoredInjections.has(m);
+        const inFlightOf = (lane) => this.drainedPendingInjection.filter((m) => userAuthored(m) && drainedFromLane.get(m) === lane);
+        const undrainedSteer = [...inFlightOf("steer"), ...this.steerQueue.filter(userAuthored)];
+        const undrainedFollowUp = [...inFlightOf("followUp"), ...this.followUpQueue.filter(userAuthored)];
         try {
-            await this.emitOwn({ type: "abort", clearedSteer, clearedFollowUp });
+            await this.emitOwn({ type: "abort", undrainedSteer, undrainedFollowUp });
         }
         catch (error) {
             errors.push(toError(error));
@@ -968,7 +1044,7 @@ export class AgentHarness {
             const cause = errors.length === 1 ? errors[0] : new AggregateError(errors, "Abort completed with errors");
             throw normalizeHarnessError(cause, "hook");
         }
-        return { clearedSteer, clearedFollowUp };
+        return { undrainedSteer, undrainedFollowUp };
     }
     async waitForIdle() {
         await this.runPromise;

package/dist/engine/harness/messages.d.ts

@@ -10,8 +10,10 @@ export declare const COMPACTION_SUMMARY_SUFFIX = "\n</summary>\n\nRecent message
 export declare function bashExecutionToText(msg: BashExecutionMessage): string;
 /** Build a persisted compaction summary message from the repository timestamp string.
  *  `elidedMessages` (RB-398-b①): the render-time count of messages this summary stands in for —
- *  drives the wrapper's scale disclosure; omitted ⇒ the wrapper stays byte-identical. */
-export declare function createCompactionSummaryMessage(summary: string, tokensBefore: number, timestamp: string, elidedMessages?: number): CompactionSummaryMessage;
+ *  drives the wrapper's scale disclosure; omitted ⇒ the wrapper stays byte-identical.
+ *  `unsummarizedMessages` (PTL-shortfall accounting): how many of those the summary does NOT cover
+ *  (input shed by a reactive prompt-too-long retry); omitted / 0 ⇒ no uncovered clause. */
+export declare function createCompactionSummaryMessage(summary: string, tokensBefore: number, timestamp: string, elidedMessages?: number, unsummarizedMessages?: number): CompactionSummaryMessage;
 /** Build a custom transcript message that can be shown and replayed into context. */
 export declare function createCustomMessage(customType: string, content: string | (TextContent | ImageContent)[], display: boolean, details: unknown, timestamp: string): CustomMessage;
 /** Prefix stamped on a salvaged block so readers (model, summaries, humans) see it is a normalization

package/dist/engine/harness/messages.js

@@ -36,13 +36,14 @@ export function bashExecutionToText(msg) {
     }
     return text;
 }
-export function createCompactionSummaryMessage(summary, tokensBefore, timestamp, elidedMessages) {
+export function createCompactionSummaryMessage(summary, tokensBefore, timestamp, elidedMessages, unsummarizedMessages) {
     return {
         role: "compactionSummary",
         summary,
         tokensBefore,
         timestamp: requireSessionTimestampMs(timestamp, "compaction summary timestamp"),
         ...(elidedMessages !== undefined ? { elidedMessages } : {}),
+        ...(unsummarizedMessages !== undefined ? { unsummarizedMessages } : {}),
     };
 }
 export function createCustomMessage(customType, content, display, details, timestamp) {
@@ -131,10 +132,14 @@ export function convertToLlm(messages) {
             }
             case "compactionSummary": {
                 const n = message.elidedMessages;
+                const uncovered = message.unsummarizedMessages;
+                const uncoveredClause = n !== undefined && n > 0 && uncovered !== undefined && uncovered > 0
+                    ? ` ${Math.min(uncovered, n)} of them could not be included in the summarization input and are NOT covered by this summary.`
+                    : "";
                 const disclosure = n !== undefined && n > 0
                     ? `\n\n(For scale: this summary stands in for ${n} earlier message${n === 1 ? "" : "s"}${message.tokensBefore > 0
                         ? ` — approximately ${message.tokensBefore} tokens of context before compaction`
-                        : ""}.)`
+                        : ""}.${uncoveredClause})`
                     : "";
                 return {
                     role: "user",

package/dist/engine/harness/types.d.ts

@@ -889,8 +889,12 @@ export interface SavePointEvent {
 }
 export interface AbortEvent {
     type: "abort";
-    clearedSteer: AgentMessage[];
-    clearedFollowUp: AgentMessage[];
+    /** backlog #389 — the caller frames still QUEUED when the abort fired. They are no longer cleared by
+     *  `abort()` (CC keeps its queue on interrupt): the terminal `agent_end` account announces them, so
+     *  this list is the same set that reaches `onUndrainedUserInputs`, observed one step earlier. */
+    undrainedSteer: AgentMessage[];
+    /** backlog #389 — the follow-up half of {@link AbortEvent.undrainedSteer}. */
+    undrainedFollowUp: AgentMessage[];
 }
 export interface SettledEvent {
     type: "settled";
@@ -1044,10 +1048,12 @@ export type AgentHarnessEventResultMap = {
     abort: undefined;
     settled: undefined;
 };
-/** Queued messages removed by an abort operation. */
+/** backlog #389 — what an abort found still QUEUED (it no longer removes caller frames; see
+ *  {@link AgentHarness.abort}). Engine-note frames are absent: their own sweep recovered them for
+ *  per-session redelivery before this snapshot was taken. */
 export interface AbortResult {
-    clearedSteer: AgentMessage[];
-    clearedFollowUp: AgentMessage[];
+    undrainedSteer: AgentMessage[];
+    undrainedFollowUp: AgentMessage[];
 }
 /** Compaction data supplied by hooks or returned from compaction preparation. */
 export interface CompactResult {

package/dist/engine/loop/types.d.ts

@@ -489,6 +489,13 @@ export interface CompactionSummaryMessage {
      *  (`convertToLlm`); absent (directly constructed messages, older render paths) ⇒ the wrapper is
      *  byte-identical to the historical constant. */
     elidedMessages?: number;
+    /** PTL-shortfall accounting: how many of those {@link elidedMessages} the summary does NOT cover — messages a reactive
+     *  prompt-too-long retry shed from the summarization input after the cut was already committed.
+     *  Sourced from the compaction entry's own write-side accounting
+     *  (`CompactionDetails.unsummarizedMessages`), same reason as its sibling. Absent (the lossless
+     *  common case, directly constructed messages, pre-field entries) ⇒ no uncovered clause, wrapper
+     *  byte-identical. */
+    unsummarizedMessages?: number;
     /** Optional estimated context tokens after compaction. */
     tokensAfter?: number;
     /** Optional first retained entry id from the compaction range. */

package/dist/engine/session/import-validate.js

@@ -183,6 +183,16 @@ export class StreamingImportValidator {
             if (elided !== undefined && !(typeof elided === "number" && Number.isSafeInteger(elided) && elided >= 0)) {
                 throw new SessionError("invalid_session", `compaction "${e.id}" carries a structurally invalid elidedMessages count (non-negative integer)`);
             }
+            const uncovered = e.details?.unsummarizedMessages;
+            if (uncovered !== undefined) {
+                if (!(typeof uncovered === "number" && Number.isSafeInteger(uncovered) && uncovered >= 0)) {
+                    throw new SessionError("invalid_session", `compaction "${e.id}" carries a structurally invalid unsummarizedMessages count (non-negative integer)`);
+                }
+                if (uncovered > 0 && !(typeof elided === "number" && elided >= uncovered)) {
+                    throw new SessionError("invalid_session", `compaction "${e.id}" carries unsummarizedMessages ${uncovered} without an elidedMessages count at least that ` +
+                        `large (uncovered messages are a subset of the folded ones)`);
+                }
+            }
             const refs = e.details?.persistedOutputRefs;
             if (refs !== undefined) {
                 if (!Array.isArray(refs) || refs.length > PERSISTED_OUTPUT_REFS_MAX_ENTRIES) {