comisai 1.0.25 → 1.0.27

package/node_modules/@comis/agent/dist/context-engine/signature-replay-scrubber.d.ts

@@ -1,45 +1,67 @@
 /**
  * Signature replay scrubber context engine layer.
  *
- * Activates only when `getReplayDriftMode()` returns `{ drop: true }`. When
- * active, drops every `type:"thinking"` block (signed and redacted alike)
- * and strips `thoughtSignature` from every `type:"toolCall"` /
- * `type:"tool_call"` block across the whole history. Respects
- * `budget.cacheFenceIndex` exactly like `thinking-block-cleaner`: messages
- * at or below the fence are passed through unchanged.
+ * Always-on policy: strips signed `thinking` blocks entirely from EVERY
+ * assistant message (latest included) and strips `thoughtSignature` from
+ * `toolCall` / `tool_call` blocks in the same messages. `redacted_thinking`
+ * blocks are never modified, anywhere.
  *
- * Provider coverage rationale: the scrubber is NOT gated on `model.reasoning`
- * because Gemini's `thoughtSignature` lives on toolCall blocks even when the
- * model itself is not flagged as reasoning. Cost of running a no-op loop is
- * negligible vs the savings of preventing a 400-rejection round trip.
+ * Rationale: Anthropic's signed-thinking validation operates on the full
+ * (system + tools + history) prefix. After 8 quick tasks of progressively
+ * narrower drift detection (gj6 → kvl) we proved targeted detection is
+ * intractable; trace 679c8927 had stable tools (49138 bytes across 4 turns)
+ * but the system prompt grew +1824 bytes and the 400 fired anyway.
+ *
+ * 260428-lm6 introduced an unconditional drop that preserved the LATEST
+ * assistant message's signatures, on the theory that the immediate-next
+ * continuation could still validate them. 260428-nzp's repro proved that
+ * carve-out doesn't work: cross-turn signature validation covers the whole
+ * request body (system + tools + history) and comis's dynamic context
+ * guarantees the surrounding context changes turn-to-turn. So the latest's
+ * signatures get invalidated too. Drop them all.
+ *
+ * Provider coverage: NOT gated on `model.reasoning` because Gemini's
+ * `thoughtSignature` lives on toolCall blocks even when the model itself
+ * is not flagged as reasoning. Cost is one walk over assistant messages,
+ * no I/O.
  *
  * Immutability: never mutates input messages or arrays. Returns new arrays
- * and shallow-copied messages only when changes are needed. When drift is
- * detected but the history happens to contain no thinking blocks or signed
- * toolCalls (e.g. fresh session), returns the original `messages` reference
- * (zero allocation).
+ * and shallow-copied messages only when changes are needed. When the
+ * history contains zero touchable signed state (e.g., fresh session, or
+ * single-assistant turn) returns the original `messages` reference (zero
+ * allocation).
  *
  * @module
  */
+import type { ComisLogger } from "@comis/infra";
 import type { ContextLayer } from "./types.js";
 import type { DriftCheck } from "../executor/replay-drift-detector.js";
-/** Stats reported via the `onScrubbed` callback. */
-interface ScrubbedStats {
-    /** Number of thinking blocks dropped across the whole history. */
-    dropped: number;
-    /** Number of thoughtSignatures stripped from toolCall blocks. */
-    signaturesStripped: number;
-    /** Drift reason that triggered the scrub (forwarded for observability). */
-    reason?: string;
-}
 /** Dependencies for `createSignatureReplayScrubber`. */
 export interface SignatureReplayScrubberDeps {
-    /** Getter for the per-execute() memoized replay drift decision. The
-     *  layer no-ops when this returns undefined or `{ drop: false }`. */
-    getReplayDriftMode: () => DriftCheck | undefined;
-    /** Optional callback invoked exactly once at the end of `apply()` with
-     *  the scrub counts and drift reason. */
-    onScrubbed?: (stats: ScrubbedStats) => void;
+    /** Kept on the deps shape for back-compat with existing wiring; unused
+     *  by this layer. The thinking cleaner's keepTurns override in
+     *  executor-context-engine-setup.ts still consults the same closure for
+     *  unrelated reasons, so leaving the field plumbed avoids a chain of
+     *  unrelated edits in callers. */
+    getReplayDriftMode?: () => DriftCheck | undefined;
+    /** Optional callback invoked at the end of `apply()` with the scrub
+     *  counts. Fields preserve the legacy `dropped` / `signaturesStripped`
+     *  names so the context-engine snapshot consumer keeps working without
+     *  churn; the new explicit counter names are also included. */
+    onScrubbed?: (stats: {
+        scrubbedAssistantMessages: number;
+        blocksAffected: number;
+        toolCallsAffected: number;
+        latestAssistantIdx: number;
+        /** Alias of blocksAffected (legacy field name preserved). */
+        dropped: number;
+        /** Alias of toolCallsAffected (legacy field name preserved). */
+        signaturesStripped: number;
+        /** Legacy; always undefined now (no drift reason in the always-on path). */
+        reason?: string;
+    }) => void;
+    /** Required: per-execute INFO log emission. */
+    logger: ComisLogger;
 }
 /**
  * Create the signature-replay-scrubber pipeline layer.
@@ -48,4 +70,3 @@ export interface SignatureReplayScrubberDeps {
  * `signature-surrogate-guard` (and well before `reasoning-tag-stripper`).
  */
 export declare function createSignatureReplayScrubber(deps: SignatureReplayScrubberDeps): ContextLayer;
-export {};

package/node_modules/@comis/agent/dist/context-engine/signature-replay-scrubber.js

@@ -2,23 +2,35 @@
 /**
  * Signature replay scrubber context engine layer.
  *
- * Activates only when `getReplayDriftMode()` returns `{ drop: true }`. When
- * active, drops every `type:"thinking"` block (signed and redacted alike)
- * and strips `thoughtSignature` from every `type:"toolCall"` /
- * `type:"tool_call"` block across the whole history. Respects
- * `budget.cacheFenceIndex` exactly like `thinking-block-cleaner`: messages
- * at or below the fence are passed through unchanged.
+ * Always-on policy: strips signed `thinking` blocks entirely from EVERY
+ * assistant message (latest included) and strips `thoughtSignature` from
+ * `toolCall` / `tool_call` blocks in the same messages. `redacted_thinking`
+ * blocks are never modified, anywhere.
  *
- * Provider coverage rationale: the scrubber is NOT gated on `model.reasoning`
- * because Gemini's `thoughtSignature` lives on toolCall blocks even when the
- * model itself is not flagged as reasoning. Cost of running a no-op loop is
- * negligible vs the savings of preventing a 400-rejection round trip.
+ * Rationale: Anthropic's signed-thinking validation operates on the full
+ * (system + tools + history) prefix. After 8 quick tasks of progressively
+ * narrower drift detection (gj6 → kvl) we proved targeted detection is
+ * intractable; trace 679c8927 had stable tools (49138 bytes across 4 turns)
+ * but the system prompt grew +1824 bytes and the 400 fired anyway.
+ *
+ * 260428-lm6 introduced an unconditional drop that preserved the LATEST
+ * assistant message's signatures, on the theory that the immediate-next
+ * continuation could still validate them. 260428-nzp's repro proved that
+ * carve-out doesn't work: cross-turn signature validation covers the whole
+ * request body (system + tools + history) and comis's dynamic context
+ * guarantees the surrounding context changes turn-to-turn. So the latest's
+ * signatures get invalidated too. Drop them all.
+ *
+ * Provider coverage: NOT gated on `model.reasoning` because Gemini's
+ * `thoughtSignature` lives on toolCall blocks even when the model itself
+ * is not flagged as reasoning. Cost is one walk over assistant messages,
+ * no I/O.
  *
  * Immutability: never mutates input messages or arrays. Returns new arrays
- * and shallow-copied messages only when changes are needed. When drift is
- * detected but the history happens to contain no thinking blocks or signed
- * toolCalls (e.g. fresh session), returns the original `messages` reference
- * (zero allocation).
+ * and shallow-copied messages only when changes are needed. When the
+ * history contains zero touchable signed state (e.g., fresh session, or
+ * single-assistant turn) returns the original `messages` reference (zero
+ * allocation).
  *
  * @module
  */
@@ -32,16 +44,22 @@ export function createSignatureReplayScrubber(deps) {
     return {
         name: "signature-replay-scrubber",
         async apply(messages, budget) {
-            const drift = deps.getReplayDriftMode();
-            if (!drift || !drift.drop) {
-                // Gate closed → no-op, return same reference (zero allocation).
+            if (messages.length === 0)
                 return messages;
+            // Find the latest assistant message index. If none, no scrub.
+            let latestIdx = -1;
+            for (let i = 0; i < messages.length; i++) {
+                // eslint-disable-next-line security/detect-object-injection -- numeric index
+                const m = messages[i];
+                if (m && m.role === "assistant")
+                    latestIdx = i;
             }
-            if (messages.length === 0)
+            if (latestIdx < 0)
                 return messages;
+            let scrubbedAssistantMessages = 0;
+            let blocksAffected = 0;
+            let toolCallsAffected = 0;
             let anyChanged = false;
-            let dropped = 0;
-            let signaturesStripped = 0;
             const result = new Array(messages.length);
             for (let i = 0; i < messages.length; i++) {
                 // eslint-disable-next-line security/detect-object-injection -- numeric index
@@ -58,39 +76,73 @@ export function createSignatureReplayScrubber(deps) {
                     result[i] = original;
                     continue;
                 }
+                // Assistant message past the fence — walk content blocks. Latest
+                // included: cross-turn signature validation invalidates it too.
                 const content = msg.content;
                 let messageChanged = false;
-                const newContent = [];
+                const newContent = new Array(content.length);
                 for (let j = 0; j < content.length; j++) {
                     // eslint-disable-next-line security/detect-object-injection -- numeric index
                     const block = content[j];
                     if (!block || typeof block !== "object") {
-                        newContent.push(block);
+                        // eslint-disable-next-line security/detect-object-injection -- numeric index
+                        newContent[j] = block;
                         continue;
                     }
                     const b = block;
                     if (b.type === "thinking") {
-                        // Drop signed AND redacted alike — drift mode invalidates the
-                        // entire prefix, so retaining redacted thinking just keeps a
-                        // surface that the next replay can still reject.
-                        dropped++;
-                        messageChanged = true;
+                        // redacted_thinking: never modified.
+                        if (b.redacted === true) {
+                            // eslint-disable-next-line security/detect-object-injection -- numeric index
+                            newContent[j] = block;
+                            continue;
+                        }
+                        // Signed thinking: strip the block entirely. Clearing the
+                        // signature to "" was previously attempted but Anthropic only
+                        // tolerates it while the prompt cache covers the prefix. On
+                        // cache eviction the full request is re-validated and a modified
+                        // thinkingSignature triggers a 400 ("thinking blocks cannot be
+                        // modified"). Stripping the block avoids this: Anthropic accepts
+                        // conversations where thinking blocks are absent from historical
+                        // turns. Reasoning-token continuity is lost, but that is
+                        // strictly better than a hard 400 that kills the session.
+                        if (typeof b.thinkingSignature === "string" && b.thinkingSignature.length > 0) {
+                            // Mark as null — filtered out below.
+                            // eslint-disable-next-line security/detect-object-injection -- numeric index
+                            newContent[j] = null;
+                            blocksAffected++;
+                            messageChanged = true;
+                            continue;
+                        }
+                        // eslint-disable-next-line security/detect-object-injection -- numeric index
+                        newContent[j] = block;
                         continue;
                     }
-                    if ((b.type === "toolCall" || b.type === "tool_call") && b.thoughtSignature !== undefined) {
-                        // Shallow-copy and drop only the thoughtSignature property.
+                    if ((b.type === "toolCall" || b.type === "tool_call") &&
+                        b.thoughtSignature !== undefined &&
+                        b.thoughtSignature !== null &&
+                        !(typeof b.thoughtSignature === "string" && b.thoughtSignature.length === 0)) {
                         const copy = { ...b };
                         delete copy.thoughtSignature;
-                        newContent.push(copy);
-                        signaturesStripped++;
+                        // eslint-disable-next-line security/detect-object-injection -- numeric index
+                        newContent[j] = copy;
+                        toolCallsAffected++;
                         messageChanged = true;
                         continue;
                     }
-                    newContent.push(block);
+                    // eslint-disable-next-line security/detect-object-injection -- numeric index
+                    newContent[j] = block;
                 }
                 if (messageChanged) {
+                    const filtered = newContent.filter((b) => b !== null);
+                    // Safety: if stripping thinking blocks emptied the content, keep
+                    // a minimal text block so the message structure stays valid.
+                    const safeContent = filtered.length > 0
+                        ? filtered
+                        : [{ type: "text", text: "" }];
                     // eslint-disable-next-line security/detect-object-injection -- numeric index
-                    result[i] = { ...msg, content: newContent };
+                    result[i] = { ...msg, content: safeContent };
+                    scrubbedAssistantMessages++;
                     anyChanged = true;
                 }
                 else {
@@ -98,9 +150,30 @@ export function createSignatureReplayScrubber(deps) {
                     result[i] = original;
                 }
             }
-            // Always notify so observers see the drift reason even on zero-touch
-            // histories (drift fired but no signed state in the conversation yet).
-            deps.onScrubbed?.({ dropped, signaturesStripped, reason: drift.reason });
+            // Always invoke onScrubbed so the context-engine snapshot stays
+            // consistent on zero-touch turns (e.g., a single assistant message
+            // history). Legacy aliases preserved for the existing snapshot
+            // consumer at context-engine.ts ~lines 718–725.
+            deps.onScrubbed?.({
+                scrubbedAssistantMessages,
+                blocksAffected,
+                toolCallsAffected,
+                latestAssistantIdx: latestIdx,
+                dropped: blocksAffected,
+                signaturesStripped: toolCallsAffected,
+                reason: undefined,
+            });
+            // Emit INFO once per execute() when at least one assistant message
+            // was actually scrubbed. Pino object-first; no string interp.
+            if (scrubbedAssistantMessages > 0) {
+                deps.logger.info({
+                    module: "agent.context-engine.signature-replay-scrub",
+                    scrubbedAssistantMessages,
+                    blocksAffected,
+                    toolCallsAffected,
+                    latestAssistantIdx: latestIdx,
+                }, "Dropped thinking signatures from all assistant messages (cross-turn replay)");
+            }
             // Zero-allocation early return when nothing was actually changed.
             if (!anyChanged)
                 return messages;

package/node_modules/@comis/agent/dist/executor/executor-context-engine-setup.js

@@ -46,6 +46,9 @@ export function setupContextEngine(params) {
     // Memoized per-execute() so all pipeline runs in a single execute() see a
     // consistent decision (cleaner + scrubber must agree). The closure reads
     // the latest model identity each time (handles cycleModel mid-execute).
+    // Returns the identity/idle drift only — the kvl tool-defs dimension was
+    // removed in 260428-lm6 in favor of the unconditional latest-message
+    // preserving scrub in signature-replay-scrubber.
     let memoizedDrift;
     const computeDriftIfNeeded = () => {
         if (memoizedDrift !== undefined)
@@ -58,7 +61,7 @@ export function setupContextEngine(params) {
             // Derive currentApi from model.api when present; otherwise fall back to
             // the provider family (resolveProviderFamily strips -bedrock / -vertex).
             const currentApi = model?.api ?? resolveProviderFamily(config.provider);
-            memoizedDrift = shouldDropSignedFields({
+            const existingDrift = shouldDropSignedFields({
                 // Cast: shouldDropSignedFields tolerates malformed entries internally.
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 fileEntries: fileEntries,
@@ -69,6 +72,7 @@ export function setupContextEngine(params) {
                 },
                 idleMs,
             });
+            memoizedDrift = existingDrift;
             return memoizedDrift;
         }
         catch (err) {

package/node_modules/@comis/agent/dist/executor/executor-post-execution.js

@@ -193,30 +193,28 @@ export async function postExecution(params) {
             });
         }
     }
-    // SEP: Attach planner metrics to result
+    // SEP: Attach planner metrics to result (observability-only post-L4).
+    // Uses actual tool-call count instead of prose-extracted step count to
+    // avoid over-counting (the LLM's numbered plan often has 2-3× more
+    // items than logical steps — e.g., "11 steps" for a 4-tool task).
     if (executionPlanRef.current?.active) {
         const plan = executionPlanRef.current;
+        const toolCalls = result.stepsExecuted ?? 0;
         result.plannerMetrics = {
-            stepsPlanned: plan.steps.length,
-            stepsCompleted: plan.completedCount,
-            stepsSkipped: plan.steps.filter(s => s.status === "skipped").length,
-            nudgeTriggered: plan.nudged,
+            stepsPlanned: toolCalls,
+            stepsCompleted: toolCalls,
+            stepsSkipped: 0,
             planExtractionTurn: 1,
         };
-        // Emit plan_completed if all steps resolved
-        const allResolved = plan.steps.every(s => s.status === "done" || s.status === "skipped");
-        if (allResolved) {
-            deps.eventBus.emit("sep:plan_completed", {
-                agentId: agentId ?? "default",
-                sessionKey: formattedKey,
-                stepsPlanned: plan.steps.length,
-                stepsCompleted: plan.completedCount,
-                stepsSkipped: plan.steps.filter(s => s.status === "skipped").length,
-                nudgeTriggered: plan.nudged,
-                durationMs: Date.now() - plan.createdAtMs,
-                timestamp: Date.now(),
-            });
-        }
+        deps.eventBus.emit("sep:plan_completed", {
+            agentId: agentId ?? "default",
+            sessionKey: formattedKey,
+            stepsPlanned: toolCalls,
+            stepsCompleted: toolCalls,
+            stepsSkipped: 0,
+            durationMs: Date.now() - plan.createdAtMs,
+            timestamp: Date.now(),
+        });
     }
     // Record timestamp after successful execution for TTL guard.
     // Uses the stream-setup captured retention (same ref the wrapper chain captured)
@@ -292,7 +290,11 @@ export async function postExecution(params) {
         ...(result.plannerMetrics && {
             sepStepsPlanned: result.plannerMetrics.stepsPlanned,
             sepStepsCompleted: result.plannerMetrics.stepsCompleted,
-            sepNudgeTriggered: result.plannerMetrics.nudgeTriggered,
+        }),
+        ...(result.continuationMetrics && {
+            postBatchContinuationFired: result.continuationMetrics.fired,
+            postBatchContinuationAttempts: result.continuationMetrics.attempts,
+            postBatchContinuationOutcome: result.continuationMetrics.outcome,
         }),
         // 1.5 + 3.2: Thinking token tracking (conditional -- only when thinking tokens detected)
         ...(bridgeResult.thinkingTokens != null && bridgeResult.thinkingTokens > 0 && {

package/node_modules/@comis/agent/dist/executor/executor-prompt-runner.d.ts

@@ -24,6 +24,7 @@ import type { ExecutionResult, ExecutionOverrides } from "./types.js";
 import type { ExecutionPlan } from "../planner/types.js";
 import type { AuthRotationAdapter } from "../model/auth-rotation-adapter.js";
 import type { ProviderHealthMonitor } from "../safety/provider-health-monitor.js";
+import type { LastKnownModelTracker } from "../model/last-known-model.js";
 import type { EnvelopeConfig } from "@comis/core";
 /** Bridge interface used by the prompt runner (minimal getResult). */
 export interface PromptRunnerBridge {
@@ -89,6 +90,7 @@ export interface RunPromptParams {
         fallbackModels?: string[];
         modelRegistry: ModelRegistry;
         providerHealth?: ProviderHealthMonitor;
+        lastKnownModel?: LastKnownModelTracker;
         envelopeConfig?: EnvelopeConfig;
         outputGuard?: OutputGuardPort;
         canaryToken?: string;

package/node_modules/@comis/agent/dist/executor/executor-prompt-runner.js

@@ -19,13 +19,15 @@ import { fromPromise } from "@comis/shared";
 import { parseUserTokenBudget } from "../commands/budget-command.js";
 import { createTurnBudgetTracker } from "../budget/turn-budget-tracker.js";
 import { wrapInEnvelope } from "../envelope/message-envelope.js";
-import { runWithModelRetry } from "./model-retry.js";
+import { runWithModelRetry, isAuthError } from "./model-retry.js";
+import { normalizeModelId } from "../provider/model-id-normalize.js";
 import { withPromptTimeout, PromptTimeoutError } from "./prompt-timeout.js";
 import { classifyError, classifyPromptTimeout } from "./error-classifier.js";
 import { scrubSignedReplayStateInPlace } from "./signature-block-scrubber.js";
 import { createOverflowRecoveryWrapper } from "./overflow-recovery.js";
 import { isContextOverflowError } from "../safety/context-truncation-recovery.js";
-import { scanWithOutputGuard, recoverEmptyFinalResponse, extractExecutionPlan, generateCompletenessNudge, } from "./executor-response-filter.js";
+import { scanWithOutputGuard, recoverEmptyFinalResponse, extractExecutionPlan, } from "./executor-response-filter.js";
+import { runPostBatchContinuation } from "./post-batch-continuation.js";
 import { getVisibleAssistantText } from "./phase-filter.js";
 import { CHARS_PER_TOKEN_RATIO } from "../context-engine/constants.js";
 import { resolveModelPricing } from "../model/model-catalog.js";
@@ -179,11 +181,16 @@ export async function runPrompt(params) {
                 agentId,
                 sessionKey: formatSessionKey(sessionKey),
                 providerHealth: deps.providerHealth,
+                lastKnownModel: deps.lastKnownModel,
                 onResetTimer: (fn) => { onResetTimer(fn); },
             },
         });
         promptSucceeded = retryResult.succeeded;
         promptError = retryResult.error;
+        // Record successful model for last-known-working tracker
+        if (retryResult.succeeded && retryResult.effectiveModel) {
+            deps.lastKnownModel?.recordSuccess(agentId ?? "default", retryResult.effectiveModel.provider, retryResult.effectiveModel.model);
+        }
     }
     // Detect zero-LLM-call stuck session.
     // When session.prompt() succeeds but the agent loop made zero LLM calls
@@ -304,6 +311,7 @@ export async function runPrompt(params) {
                                 agentId,
                                 sessionKey: formatSessionKey(sessionKey),
                                 providerHealth: deps.providerHealth,
+                                lastKnownModel: deps.lastKnownModel,
                                 onResetTimer: (fn) => { onResetTimer(fn); },
                             },
                         });
@@ -429,6 +437,7 @@ export async function runPrompt(params) {
                                 agentId,
                                 sessionKey: formatSessionKey(sessionKey),
                                 providerHealth: deps.providerHealth,
+                                lastKnownModel: deps.lastKnownModel,
                                 onResetTimer: (fn) => { onResetTimer(fn); },
                             },
                         });
@@ -451,6 +460,62 @@ export async function runPrompt(params) {
                                         ? ` — ${retryBridgeResult.lastLlmErrorMessage}`
                                         : "";
                                     promptError = new Error(`Silent LLM failure: ${retryBridgeResult.llmCalls} LLM call(s) produced empty response after retry (finishReason: ${retryBridgeResult.finishReason ?? "unknown"})${llmDetail}`);
+                                    // LKW silent-failure fallback: some providers return 403 as
+                                    // an empty response (SDK doesn't throw), so model-retry's LKW
+                                    // block never fires. Detect auth errors here and try the LKW
+                                    // model as a final attempt before giving up.
+                                    const silentAuthErr = retryBridgeResult.lastLlmErrorMessage ?? "";
+                                    if (isAuthError(new Error(silentAuthErr)) && deps.lastKnownModel) {
+                                        const lkw = deps.lastKnownModel.getLastKnown(agentId ?? "") ??
+                                            deps.lastKnownModel.getAnyKnown(config.provider);
+                                        if (lkw && (lkw.provider !== config.provider || lkw.model !== config.model)) {
+                                            deps.logger.info({ lkwProvider: lkw.provider, lkwModel: lkw.model, silentAuthErr }, "Silent auth failure — attempting last-known-working model");
+                                            try {
+                                                const normalizedLkw = normalizeModelId(lkw.provider, lkw.model);
+                                                const lkwModelObj = deps.modelRegistry.find(lkw.provider, normalizedLkw.modelId);
+                                                if (lkwModelObj) {
+                                                    await session.setModel(lkwModelObj);
+                                                }
+                                                // Strip trailing empty assistant turns before the LKW attempt
+                                                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                                                const lkwMsgs = session.messages ?? [];
+                                                for (let li = lkwMsgs.length - 1; li >= 0; li--) {
+                                                    const lm = lkwMsgs[li]; // eslint-disable-line security/detect-object-injection
+                                                    if (lm?.role !== "assistant")
+                                                        break;
+                                                    const lBlocks = Array.isArray(lm.content) ? lm.content : [];
+                                                    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- SDK interop boundary
+                                                    const lHasText = lBlocks.some((b) => b.type === "text" && typeof b.text === "string" && b.text.trim() !== "");
+                                                    if (!lHasText)
+                                                        lkwMsgs.splice(li, 1);
+                                                    else
+                                                        break;
+                                                }
+                                                await withPromptTimeout(session.prompt(messageText, { expandPromptTemplates: false, images: promptImages }), effectiveTimeout.retryPromptTimeoutMs, () => session.abort());
+                                                const lkwText = getVisibleAssistantText(session);
+                                                if (lkwText !== "") {
+                                                    promptSucceeded = true;
+                                                    promptError = undefined;
+                                                    deps.lastKnownModel.recordSuccess(agentId ?? "default", lkw.provider, lkw.model);
+                                                    deps.logger.info({ lkwProvider: lkw.provider, lkwModel: lkw.model }, "LKW silent-failure fallback succeeded");
+                                                }
+                                                else {
+                                                    deps.logger.warn({
+                                                        lkwProvider: lkw.provider, lkwModel: lkw.model,
+                                                        hint: "LKW model also produced empty response",
+                                                        errorKind: "dependency",
+                                                    }, "LKW silent-failure fallback produced empty response");
+                                                }
+                                            }
+                                            catch (lkwErr) {
+                                                deps.logger.warn({
+                                                    err: lkwErr, lkwProvider: lkw.provider, lkwModel: lkw.model,
+                                                    hint: "LKW model threw during silent-failure fallback",
+                                                    errorKind: "dependency",
+                                                }, "LKW silent-failure fallback failed");
+                                            }
+                                        }
+                                    }
                                 }
                             }
                         }
@@ -632,20 +697,45 @@ export async function runPrompt(params) {
         if (sepEnabled && !executionPlanRef.current && extractedResponse && toolCallCount === 0) {
             deps.logger.debug({ agentId }, "SEP extraction skipped: no tool calls in execution (likely conversational response)");
         }
-        // SEP: Completeness nudge (extracted to executor-response-filter.ts)
-        if (executionPlanRef.current?.active && !executionPlanRef.current.nudged) {
-            const nudgeText = generateCompletenessNudge({
-                plan: executionPlanRef.current,
-                verificationNudge: config.sep?.verificationNudge !== false,
+        // L4: Post-batch continuation (replaces the deleted SEP one-shot nudge).
+        // Detects empty final assistant turn after a successful tool batch within
+        // the current execution window and fires a directive followUp with multi-
+        // shot retry. Falls through to L3 synthesis (recoverEmptyFinalResponse) on
+        // exhaustion. SEP plan extraction + step counting remain intact for
+        // observability — see pi-event-bridge.ts:949-1024.
+        {
+            const continuationConfig = config.contextEngine?.postBatchContinuation
+                ?? { enabled: true, maxRetries: 2 };
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const sessionMessages = session.messages ?? [];
+            const continuationResult = await runPostBatchContinuation({
+                session,
+                messages: sessionMessages,
+                config: continuationConfig,
+                logger: deps.logger,
+                agentId,
+                getVisibleAssistantText,
             });
-            if (nudgeText) {
-                executionPlanRef.current.nudged = true;
-                deps.logger.info({ agentId, remainingSteps: executionPlanRef.current.steps.filter(s => s.status === "pending" || s.status === "in_progress").length }, "SEP completeness nudge triggered");
-                await session.followUp(nudgeText);
-                const nudgeResponse = getVisibleAssistantText(session);
-                if (nudgeResponse) {
-                    result.response = nudgeResponse;
+            if (continuationResult.ok) {
+                const v = continuationResult.value;
+                if (v.recovered && v.response) {
+                    result.response = v.response;
                 }
+                // Stash outcome metrics for executor-post-execution.ts to emit in the
+                // Execution complete log.
+                result.continuationMetrics = {
+                    fired: v.outcome !== "no_match" && v.outcome !== "disabled",
+                    attempts: v.attempts,
+                    outcome: v.outcome,
+                };
+            }
+            else {
+                deps.logger.warn({
+                    err: continuationResult.error.cause,
+                    hint: "Post-batch continuation followUp failed; preserving response collected so far",
+                    errorKind: "internal",
+                }, "Post-batch continuation error");
+                result.continuationMetrics = { fired: false, attempts: 0, outcome: "still_empty" };
             }
         }
         // Budget-driven continuation loop
@@ -764,7 +854,13 @@ export async function runPrompt(params) {
             const classified = promptError instanceof PromptTimeoutError
                 ? classifyPromptTimeout(promptError.timeoutMs)
                 : classifyError(promptError);
-            result.response = classified.userMessage;
+            // Enrich auth_invalid messages with the failing provider name
+            if (classified.category === "auth_invalid") {
+                result.response = `The AI service could not authenticate with the "${config.provider}" provider. Please check the API key or notify the system administrator.`;
+            }
+            else {
+                result.response = classified.userMessage;
+            }
             result.errorContext = {
                 errorType: promptError instanceof PromptTimeoutError ? "PromptTimeout" : "PromptFailure",
                 retryable: classified.retryable,