mixdog 0.9.12 → 0.9.14

package/src/runtime/agent/orchestrator/session/compact/budget.mjs

@@ -39,68 +39,6 @@ const PRUNE_TAIL_TURNS = 2;
 export const MIN_PRESERVE_RECENT_TOKENS = 2_000;
 export const PRESERVED_FACTS_MAX_CHARS = 600;
 
-// Count raw (unchunked) pending rows still present in a dump_session_roots
-// payload. recall-fasttrack must keep cycle1-chunking until this reaches 0 so
-// the injected root is the chunked summary, not the raw transcript tail.
-export function countRawPendingRows(dumpText) {
-    const text = String(dumpText || '');
-    const matches = text.match(/(?:^|\n)# raw_pending\s+\d+\s+id=/gi);
-    return matches ? matches.length : 0;
-}
-
-// Drain a single session's cycle1 in fixed window×concurrency units, looping
-// until no raw rows remain (or a pass stops making progress / the deadline
-// elapses). This replaces the previous single-pass cycle1 so large sessions
-// get fully chunked before their root is injected into the compacted context.
-export async function drainSessionCycle1(runTool, { sessionId, cycleArgs = {}, dumpArgs, maxPasses = 0, deadlineMs = 0 } = {}) {
-    if (typeof runTool !== 'function') throw new Error('drainSessionCycle1: runTool is required');
-    if (!sessionId) throw new Error('drainSessionCycle1: sessionId is required');
-    if (!dumpArgs) throw new Error('drainSessionCycle1: dumpArgs is required');
-    const startedAt = Date.now();
-    const hardPasses = Math.max(1, Number(maxPasses) || 50);
-    const lines = [];
-    let cycle1Error = null;
-    let recallText = await runTool('memory', dumpArgs);
-    let rawRemaining = countRawPendingRows(recallText);
-    let pass = 0;
-    while (rawRemaining > 0 && pass < hardPasses) {
-        if (deadlineMs > 0 && (Date.now() - startedAt) >= deadlineMs) break;
-        pass += 1;
-        const passDeadline = deadlineMs > 0
-            ? Math.max(1, deadlineMs - (Date.now() - startedAt))
-            : 0;
-        let passText = '';
-        try {
-            passText = await runTool('memory', {
-                action: 'cycle1',
-                sessionId,
-                ...cycleArgs,
-                ...(passDeadline > 0 ? { _callerDeadlineMs: passDeadline } : {}),
-            });
-        } catch (err) {
-            cycle1Error = err?.message ? String(err.message) : String(err);
-            lines.push(`cycle1 pass=${pass} error=${cycle1Error}`);
-            break;
-        }
-        if (passText) lines.push(`cycle1 pass=${pass}: ${String(passText).trim()}`);
-        recallText = await runTool('memory', dumpArgs);
-        const nextRaw = countRawPendingRows(recallText);
-        // No forward progress (raw not shrinking) — stop instead of spinning.
-        if (nextRaw >= rawRemaining) {
-            rawRemaining = nextRaw;
-            break;
-        }
-        rawRemaining = nextRaw;
-    }
-    return {
-        recallText,
-        cycle1Text: lines.join('\n'),
-        passes: pass,
-        rawRemaining,
-        error: cycle1Error,
-    };
-}
-
 function preservedFactHints() {
     return String(process.env.MIXDOG_COMPACT_FACT_HINTS || '')
         .split(/[\n,;]+/u)

package/src/runtime/agent/orchestrator/session/compact.mjs

@@ -37,8 +37,6 @@ export { redactToolCallSecretsInMessages } from './compact/text-utils.mjs';
 
 export {
     effectiveBudget,
-    countRawPendingRows,
-    drainSessionCycle1,
     pruneToolOutputs,
     pruneToolOutputsUnanchored,
 } from './compact/budget.mjs';

package/src/runtime/agent/orchestrator/session/loop/completion-guards.mjs

@@ -1,5 +1,5 @@
 // Completion-first loop guards: escalation ladder (level-2 steering),
-// cross-turn identical read-only call dedup, and worker soft-cap wrap-up.
+// cross-turn identical read-only call dedup, and hard-cap refusal stubs.
 // Pure string/signature helpers extracted from loop.mjs so the loop body only
 // wires state + messages. No provider/manager coupling.
 
@@ -41,21 +41,24 @@ export function isEditProgressTool(name, isEager) {
 // `readOnlyRole` swaps the edit-oriented directive for a report-oriented one:
 // read-permission sessions (reviewer-style) cannot apply_patch, so telling
 // them to edit is self-contradictory and pushes premature termination.
-export function level2SteerMessage(n, readOnlyRole = false) {
+const LEVEL2_DIMINISHING_RETURNS = ' Further reads add cost, not evidence.';
+
+export function level2SteerMessage(n, readOnlyRole = false, level2Fires = 1) {
+    const tail = Number(level2Fires) >= 2 ? LEVEL2_DIMINISHING_RETURNS : '';
     if (readOnlyRole) {
-        return `<system-reminder>\nYou have received this batching reminder ${n} times. Converge now: report your findings from what you have already read, or state exactly what information is missing for a verdict. A partial report with named gaps is a valid, successful completion — continued exploration is not.\n</system-reminder>`;
+        return `<system-reminder>\nEnough evidence gathered — report findings now; name any gaps.${tail}\n</system-reminder>`;
     }
-    return `<system-reminder>\nYou have received this batching reminder ${n} times without making any edit. Stop exploring now: either apply_patch with what you already know, or return a blocked report stating exactly what is missing. A blocked report is a valid, successful completion — continued exploration is not.\n</system-reminder>`;
+    return `<system-reminder>\nStop exploring — apply the edit you know, or report blocked with what's missing.${tail}\n</system-reminder>`;
 }
 
 // Step 2 — cross-turn dedup stub. `stuck` appends the escalation tail at the
 // 5th+ dedup stub in the session.
 export function crossTurnDedupStub(name, firstIteration, stuck) {
-    let s = `[cross-turn-dedup] identical read-only \`${name}\` call already executed in iteration ${firstIteration}; its result is unchanged and already in context. Use it, or change path/offset/pattern for new information.`;
-    if (stuck) s += ` Repeated identical calls indicate you are stuck — apply what you know or return blocked.`;
+    let s = `[cross-turn-dedup] \`${name}\` already ran in iteration ${firstIteration}; result unchanged, already in context.`;
+    if (stuck) s += ` You appear stuck — use what you have or report blocked.`;
     return s;
 }
 
-// Step 3 — worker soft-cap wrap-up assistant-visible directive + refusal stub.
-export const SOFT_CAP_WRAPUP_MESSAGE = `MAXIMUM EXPLORATION BUDGET REACHED. Tools are now disabled. Respond with text only: summarize work completed so far, list remaining/incomplete items, and state what is blocking or what should be done next. This overrides all other instructions.`;
-export const SOFT_CAP_REFUSAL_STUB = `Tools are disabled: exploration budget reached. Provide your final text summary.`;
+// Hard iteration-cap final turn: model may still emit tool calls after tools
+// are stripped from the send; refuse without executing.
+export const ITERATION_CAP_REFUSAL_STUB = `Iteration cap reached — tools disabled; reply with your final text only.`;

package/src/runtime/agent/orchestrator/session/loop/pre-dispatch-deny.mjs

@@ -13,6 +13,7 @@
 // command injection), or host input injection. Explicit name list (no imports)
 // keeps this hot-path gate dependency-free; add new owner/channel tools here.
 import { isAgentOwner } from '../../agent-owner.mjs';
+import { recursiveWrapperToolNameForPublicAgent } from '../manager/tool-resolution.mjs';
 
 const WORKER_DENIED_TOOLS = new Set([
     // session control-plane — unified into the single `agent` tool
@@ -34,6 +35,17 @@ function _preDispatchDeny(call, toolKind, sessionRef) {
     if (_agentOwned && _controlPlaneTool) {
         return `Error: control-plane tool "${name}" is Lead-only and not available to agent workers.`;
     }
+    // Anti-recursion break, moved OFF the schema so the read-only tool bundle
+    // stays bit-identical across every read role (explore ships in the schema
+    // for all of them, incl. the explore agent itself — one cache group).
+    // A public agent that IS a recursive wrapper (e.g. explore) must not call
+    // its own wrapper tool; reject it here at call time instead.
+    if (_agentOwned) {
+        const selfWrapper = recursiveWrapperToolNameForPublicAgent(sessionRef?.agent || null);
+        if (selfWrapper && name.toLowerCase() === selfWrapper.toLowerCase()) {
+            return `Error: tool "${name}" is not available inside agent "${sessionRef.agent}" (would recurse into its own wrapper). Return the answer directly.`;
+        }
+    }
     const noToolAgent = sessionRef?.agent === 'cycle1-agent' || sessionRef?.agent === 'cycle2-agent';
     if (noToolAgent) {
         return `Error: tool "${name}" is not available in agent "${sessionRef.agent}". Re-emit the answer as pipe-separated text per the agent's output format (first character a digit, NO tool_use blocks, NO JSON, NO prose, NO apology).`;

package/src/runtime/agent/orchestrator/session/loop/recall-fasttrack.mjs

@@ -1,19 +1,15 @@
-// Recall-fasttrack compaction pipeline, extracted from loop.mjs.
+// Recall-fasttrack compaction pipeline (digest injection).
 // Hydrates the session transcript into the memory pipeline (ingest_session),
-// dumps chunked/raw roots, drains cycle1 until no raw rows remain, and folds
-// the combined recall text back into a compacted message array capped at
-// CONTEXT_SHARE_RATIO of the model context window. No behavior change: this is
-// the same body that lived inline in loop.mjs, re-exported via the facade so
-// existing importers keep working.
+// then injects a small newest-first digest + recall pointer into the
+// compacted messages. The former full-dump path (dump_session_roots +
+// synchronous cycle1 drain) was removed 2026-07: the drain ran memory-
+// pipeline LLM chunking calls inside the compaction (11.9s of a measured
+// 12.9s compact) and still left raw rows behind; background cycle1 already
+// chunks ingested rows on its own schedule, and recall serves the rest.
 import { createHash } from 'crypto';
 import { executeInternalTool } from '../../internal-tools.mjs';
-import { loadConfig as loadOrchestratorConfig } from '../../config.mjs';
 import {
     recallFastTrackCompactMessages,
-    CONTEXT_SHARE_RATIO,
-    RECALL_TOKEN_CAP_FLOOR_TOKENS,
-    drainSessionCycle1,
-    countRawPendingRows,
 } from '../compact.mjs';
 import {
     compactDiagnosticError,
@@ -23,23 +19,23 @@ import {
 import { positiveTokenInt } from './env.mjs';
 import { TOOL_OUTPUT_MAX_BYTES } from '../../tools/builtin/tool-output-limit.mjs';
 
-// ── Digest mode (compaction.recallDigest=true) ─────────────────────────────
-// Instead of folding the FULL chunked session dump into the compacted
-// messages (heavy: cycle1 drain + up to CONTEXT_SHARE_RATIO of the context
-// window), inject a small newest-first digest plus an instruction telling the
-// model to pull details lazily via recall(sessionId/query/period). The memory
-// DB already holds the full session (ingest_session below runs in both
-// modes), and raw rows are embedded synchronously at ingest, so recall serves
-// everything the big injection used to carry.
+// ── Digest injection ────────────────────────────────────────────────────────
+// Inject a small newest-first digest plus an instruction telling the model to
+// pull details lazily via recall(sessionId/query/period). The memory DB holds
+// the full session (ingest_session below), and raw rows are embedded
+// synchronously at ingest, so recall serves everything the old full-dump
+// injection used to carry.
 // Default digest cap = the SHARED tool-output limit (TOOL_OUTPUT_MAX_BYTES,
 // 50KB default, env MIXDOG_TOOL_OUTPUT_MAX_BYTES) — the digest injection is
 // budgeted like any other tool result, not a special context share.
 // compaction.recallDigestMaxKb still overrides per-session.
-const DIGEST_DEFAULT_MAX_KB = Math.max(1, Math.floor(TOOL_OUTPUT_MAX_BYTES / 1024));
+export const DIGEST_DEFAULT_MAX_KB = Math.max(1, Math.floor(TOOL_OUTPUT_MAX_BYTES / 1024));
 
 // Byte-capped line-boundary truncation. Digest source is newest-first, so
 // keeping the HEAD keeps the newest turns.
-function truncateToKb(text, maxKb) {
+// Exported for manager/compaction-runner.mjs (manual//clear digest path) so
+// both digest producers share one cap implementation.
+export function truncateToKb(text, maxKb) {
     const maxBytes = Math.max(1, maxKb) * 1024;
     const s = String(text || '');
     if (Buffer.byteLength(s, 'utf8') <= maxBytes) return s;
@@ -120,156 +116,51 @@ export async function runRecallFastTrackCompact({ sessionRef, messages, compactB
     } finally {
         diagnostics.ingestMs = Date.now() - t0;
     }
-    // ── Digest mode: skip the dump + cycle1 drain entirely. Pull a small
-    // newest-first session browse (recall path: roots + raw fallback merged
-    // chronologically), cap it at recallDigestMaxKb, and inject it with a
-    // recall-usage instruction. The model pulls older/topical detail lazily.
-    const digestMode = sessionRef?.compaction?.recallDigest === true;
-    if (digestMode) {
-        const digestMaxKb = positiveTokenInt(sessionRef?.compaction?.recallDigestMaxKb) || DIGEST_DEFAULT_MAX_KB;
-        let digestBody = '';
-        t0 = Date.now();
-        try {
-            const browsed = await executeInternalTool('memory', {
-                action: 'search',
-                sessionId,
-                limit: positiveTokenInt(sessionRef?.compaction?.recallDigestLimit) || 30,
-                includeMembers: true,
-            }, callerCtx);
-            digestBody = typeof browsed === 'string' ? browsed : String(browsed?.text ?? browsed ?? '');
-        } catch (err) {
-            diagnostics.cycle1Error = compactDiagnosticError(err);
-            try { process.stderr.write(`[loop] recall-digest browse failed (sess=${sessionId || 'unknown'}): ${err?.message || err}\n`); } catch {}
-        }
-        diagnostics.initialDumpMs = Date.now() - t0;
-        diagnostics.cycle1Skipped = true;
-        diagnostics.cycle1SkipReason = 'digest mode';
-        diagnostics.cycle1Passes = 0;
-        const digestText = buildRecallDigestText(sessionId, digestBody, digestMaxKb);
-        diagnostics.finalRecallChars = digestText.length;
-        diagnostics.finalRecallBytes = compactByteLength(digestText);
-        const result = recallFastTrackCompactMessages(messages, compactBudgetTokens, {
-            reserveTokens: compactPolicy.reserveTokens,
-            force: true,
-            recallText: digestText,
-            query,
-            querySha,
-            allowEmptyRecall: true,
-            tailTurns: compactPolicy.tailTurns,
-            keepTokens: compactPolicy.keepTokens,
-            preserveRecentTokens: compactPolicy.preserveRecentTokens,
-        });
-        diagnostics.totalMs = Date.now() - startedAt;
-        if (result && typeof result === 'object') {
-            result.diagnostics = { ...(result.diagnostics || {}), pipeline: { ...diagnostics, digestMode: true } };
-        }
-        compactDebugLog('recall-digest pipeline', diagnostics);
-        return result;
-    }
-    const dumpArgs = {
-        action: 'dump_session_roots',
-        sessionId,
-        includeRaw: true,
-        limit: positiveTokenInt(sessionRef?.compaction?.recallChunkLimit ?? sessionRef?.compaction?.recallLimit) || hydrateLimit,
-    };
-    const runTool = (name, args) => executeInternalTool(name, args, callerCtx);
+    // ── Digest injection (the only mode) ──────────────────────────────────
+    // The old full-dump path (dump_session_roots + synchronous cycle1 drain)
+    // is gone: the drain ran memory-pipeline LLM chunking calls INSIDE the
+    // compaction (measured 11.9s of a 12.9s compact) and still often left
+    // rawRemaining>0. Instead inject a small newest-first digest plus a
+    // recall pointer; ingest_session above already put the full transcript
+    // in the memory DB, and background cycle1 chunks it on its own schedule.
+    const digestMaxKb = positiveTokenInt(sessionRef?.compaction?.recallDigestMaxKb) || DIGEST_DEFAULT_MAX_KB;
+    let digestBody = '';
     t0 = Date.now();
-    let recallText = await executeInternalTool('memory', dumpArgs, callerCtx);
-    diagnostics.initialDumpMs = Date.now() - t0;
-    diagnostics.initialDumpChars = String(recallText || '').length;
-    diagnostics.initialDumpBytes = compactByteLength(recallText);
-    diagnostics.initialRawPending = countRawPendingRows(recallText);
-    let cycle1Text = '';
-    const hasRawRows = /(?:^|\n)# raw_pending\s+\d+\s+id=/i.test(String(recallText || ''));
-    // Recap off = NO memory-pipeline LLM calls: skip the cycle1 drain entirely
-    // and let the dump's raw transcript lines (includeRaw:true above) ride into
-    // the injected summary as-is. Poll-on-use: re-read the flag per compact so
-    // a runtime toggle applies without restart. Default on if config read fails.
-    let recapOn = true;
-    try { recapOn = loadOrchestratorConfig({ secrets: false })?.recap?.enabled !== false; } catch { /* default on */ }
-    if (hasRawRows && !recapOn) {
-        diagnostics.cycle1Skipped = true;
-        diagnostics.cycle1SkipReason = 'recap disabled';
-        diagnostics.cycle1Passes = 0;
-        diagnostics.cycle1RawRemaining = countRawPendingRows(recallText);
-        cycle1Text = 'cycle1: skipped (recap disabled — raw transcript lines kept as-is)';
-    } else if (hasRawRows) {
-        t0 = Date.now();
-        try {
-            // Drain this session's cycle1 in window×concurrency units until no
-            // raw rows remain, so the injected root is fully chunked rather than
-            // carrying the unprocessed transcript tail (single-pass left raw in).
-            const drained = await drainSessionCycle1(runTool, {
-                sessionId,
-                dumpArgs,
-                deadlineMs: positiveTokenInt(sessionRef?.compaction?.recallCycle1DeadlineMs) || 120_000,
-                maxPasses: positiveTokenInt(sessionRef?.compaction?.recallCycle1MaxPasses) || 0,
-                cycleArgs: {
-                    min_batch: 1,
-                    session_cap: 1,
-                    batch_size: positiveTokenInt(sessionRef?.compaction?.recallCycle1BatchSize) || 100,
-                    rows_per_session: positiveTokenInt(sessionRef?.compaction?.recallRowsPerSession) || 100,
-                    window_size: positiveTokenInt(sessionRef?.compaction?.recallWindowSize) || 20,
-                    concurrency: positiveTokenInt(sessionRef?.compaction?.recallConcurrency) || 5,
-                },
-            });
-            recallText = drained.recallText;
-            cycle1Text = drained.cycle1Text;
-            diagnostics.cycle1Passes = drained.passes;
-            diagnostics.cycle1RawRemaining = drained.rawRemaining;
-            diagnostics.cycle1TextBytes = compactByteLength(cycle1Text);
-            if (drained.error) {
-                diagnostics.cycle1Error = drained.error;
-                try { process.stderr.write(`[loop] recall-fasttrack cycle1 error (sess=${sessionId || 'unknown'}): ${drained.error}\n`); } catch {}
-            }
-            if (drained.rawRemaining > 0) {
-                try { process.stderr.write(`[loop] recall-fasttrack drained passes=${drained.passes} rawRemaining=${drained.rawRemaining} (sess=${sessionId || 'unknown'})\n`); } catch {}
-            }
-        } catch (err) {
-            diagnostics.cycle1Error = compactDiagnosticError(err);
-            try { process.stderr.write(`[loop] recall-fasttrack cycle1 skipped (sess=${sessionId || 'unknown'}): ${err?.message || err}\n`); } catch {}
-        } finally {
-            diagnostics.cycle1Ms = Date.now() - t0;
-        }
-    } else {
-        diagnostics.cycle1Skipped = true;
-        diagnostics.cycle1SkipReason = 'session chunks already hydrated';
-        diagnostics.cycle1Passes = 0;
-        diagnostics.cycle1RawRemaining = 0;
-        cycle1Text = 'cycle1: skipped (session chunks already hydrated)';
+    try {
+        const browsed = await executeInternalTool('memory', {
+            action: 'search',
+            sessionId,
+            limit: positiveTokenInt(sessionRef?.compaction?.recallDigestLimit) || 30,
+            includeMembers: true,
+            includeRaw: true,
+        }, callerCtx);
+        digestBody = typeof browsed === 'string' ? browsed : String(browsed?.text ?? browsed ?? '');
+    } catch (err) {
+        diagnostics.cycle1Error = compactDiagnosticError(err);
+        try { process.stderr.write(`[loop] recall-digest browse failed (sess=${sessionId || 'unknown'}): ${err?.message || err}\n`); } catch {}
     }
-    const combinedRecallText = [`session_id=${sessionId}`, cycle1Text, recallText].map(v => String(v || '').trim()).filter(Boolean).join('\n\n');
-    diagnostics.finalRecallChars = combinedRecallText.length;
-    diagnostics.finalRecallBytes = compactByteLength(combinedRecallText);
-    // Recall injection (chunked-summary + raw-fallback text, combined above)
-    // never exceeds CONTEXT_SHARE_RATIO (5%) of the model context window
-    // (floor RECALL_TOKEN_CAP_FLOOR_TOKENS); the rest of the budget belongs to
-    // live conversation. Same unified 5% as the compact target ratio
-    // (compact-policy.mjs COMPACT_TARGET_RATIO). Omitted when contextWindow is
-    // unknown/0 so current no-cap behavior is preserved.
-    const _recallCapWindow = Number(compactPolicy.contextWindow) || 0;
-    const recallTokenCap = _recallCapWindow > 0
-        ? Math.max(RECALL_TOKEN_CAP_FLOOR_TOKENS, Math.floor(_recallCapWindow * CONTEXT_SHARE_RATIO))
-        : undefined;
+    diagnostics.initialDumpMs = Date.now() - t0;
+    diagnostics.cycle1Skipped = true;
+    diagnostics.cycle1SkipReason = 'digest mode';
+    diagnostics.cycle1Passes = 0;
+    const digestText = buildRecallDigestText(sessionId, digestBody, digestMaxKb);
+    diagnostics.finalRecallChars = digestText.length;
+    diagnostics.finalRecallBytes = compactByteLength(digestText);
     const result = recallFastTrackCompactMessages(messages, compactBudgetTokens, {
         reserveTokens: compactPolicy.reserveTokens,
         force: true,
-        recallText: combinedRecallText,
+        recallText: digestText,
         query,
         querySha,
         allowEmptyRecall: true,
         tailTurns: compactPolicy.tailTurns,
         keepTokens: compactPolicy.keepTokens,
         preserveRecentTokens: compactPolicy.preserveRecentTokens,
-        recallTokenCap,
     });
     diagnostics.totalMs = Date.now() - startedAt;
     if (result && typeof result === 'object') {
-        result.diagnostics = {
-            ...(result.diagnostics || {}),
-            pipeline: diagnostics,
-        };
+        result.diagnostics = { ...(result.diagnostics || {}), pipeline: { ...diagnostics, digestMode: true } };
     }
-    compactDebugLog('recall-fasttrack pipeline', diagnostics);
+    compactDebugLog('recall-digest pipeline', diagnostics);
     return result;
 }

package/src/runtime/agent/orchestrator/session/loop/steering-ladder.mjs

@@ -8,14 +8,10 @@ import { appendAgentTrace } from '../../agent-trace.mjs';
 import { level2SteerMessage } from './completion-guards.mjs';
 import { isEagerDispatchable } from './tool-helpers.mjs';
 
-// Consecutive ignored level-2 steers (zero edits) that force the wrap-up early.
-export const EARLY_SOFT_CAP_LEVEL2_FIRES = 3;
-
 // Build the completion-first steering-ladder controller. `ctx` supplies live
 // accessors so every read reflects the loop's current mutable state:
 //   - messages, sessionId, sessionAgent, tools           (stable refs/values)
 //   - getIterations()                                    (current iteration)
-//   - softCapEnabled                                     (constant per loop)
 //   - getEditCount()                                     (mutated by the loop)
 //   - pushSystemReminder(text)  → push a meta:'hook' user message
 //   - pushUserMessage(msg)      → push a raw user message (level-2 latch text)
@@ -25,14 +21,13 @@ export function createSteeringLadder(ctx) {
         sessionAgent,
         tools,
         getIterations,
-        softCapEnabled,
         getEditCount,
     } = ctx;
     const pushSystemReminder = ctx.pushSystemReminder;
     const pushUserMessage = ctx.pushUserMessage;
     // Permission-based role detection (agent names are user-definable):
     // read-permission sessions legitimately never edit, so they get the
-    // report-oriented level-2 text and never arm the early soft-cap.
+    // report-oriented level-2 text.
     const readOnlyRole = ctx.readOnlyRole === true;
 
     // Step 1: escalation ladder. _level1FireCount is CUMULATIVE (never reset)
@@ -54,8 +49,6 @@ export function createSteeringLadder(ctx) {
     // grep on that path; any other tool/path resets it.
     let _sameFileGrepStreak = 0;
     let _sameFileGrepPath = null;
-    // Early soft-cap: N ignored level-2 steers with zero edits forces the
-    // wrap-up early; any edit disarms it (level-2 requires editCount === 0).
     let _level2FireCount = 0;
 
     // Level-2 steering emitter shared by both ladder paths (single-call
@@ -65,10 +58,7 @@ export function createSteeringLadder(ctx) {
         const iterations = getIterations();
         _level2LatchAtIteration = iterations;
         _level2FireCount += 1;
-        // When this fire arms the early soft-cap, the wrap-up injected at the
-        // next loop head supersedes the level-2 text — skip the redundant hint.
-        const _armsEarlyCap = !readOnlyRole && softCapEnabled && _level2FireCount >= EARLY_SOFT_CAP_LEVEL2_FIRES && getEditCount() === 0;
-        if (!_armsEarlyCap) pushUserMessage({ role: 'user', content: level2SteerMessage(_level1FireCount, readOnlyRole), meta: 'hook' });
+        pushUserMessage({ role: 'user', content: level2SteerMessage(_level1FireCount, readOnlyRole, _level2FireCount), meta: 'hook' });
         try {
             appendAgentTrace({
                 sessionId,
@@ -81,21 +71,14 @@ export function createSteeringLadder(ctx) {
     };
 
     return {
-        // Loop head reads: is the early soft-cap armed?
-        get level2FireCount() { return _level2FireCount; },
-        earlySoftCapArmed() {
-            return !readOnlyRole && _level2FireCount >= EARLY_SOFT_CAP_LEVEL2_FIRES && getEditCount() === 0;
-        },
-        // Post-batch steering hint gate. `hintAlreadyFired` seeds the once-per-
-        // turn latch (soft-cap active suppresses all hints). Returns nothing;
+        // Post-batch steering hint gate. `hintAlreadyFired` seeds the once-per-turn
+        // latch. Returns nothing;
         // pushes at most one steering message via the ctx push callbacks.
         emitPostBatchSteering(calls, hintAlreadyFired) {
             const iterations = getIterations();
             const editCount = getEditCount();
-            // Steering hint gate: at most ONE hint per turn (priority: soft-cap >
-            // level-2 > same-file grep > level-1), and none once the soft-cap
-            // wrap-up is active — its "text only" directive must not share a send
-            // with a "keep exploring" hint.
+            // Steering hint gate: at most ONE hint per turn (priority:
+            // level-2 > same-file grep > level-1).
             let _hintFiredThisTurn = hintAlreadyFired;
             // Missed-parallelism steering: 3+ consecutive turns of a single
             // read-only tool call suggest the model isn't batching independent

package/src/runtime/agent/orchestrator/session/loop/termination.mjs

@@ -17,8 +17,6 @@ export const INCOMPLETE_STOP_REASONS = new Set([
 // branch in agentLoop does (trimmed string content, or any reasoning content).
 export function classifyTerminationReason(response, {
     terminatedByCap,
-    terminatedBySoftCap,
-    softCapActive,
     sessionAgent,
 } = {}) {
     const _finalHasContent = (typeof response?.content === 'string' && response.content.trim().length > 0)
@@ -31,17 +29,6 @@ export function classifyTerminationReason(response, {
         // on its own contract.
         return 'iteration_cap';
     }
-    if (terminatedBySoftCap || softCapActive) {
-        // Worker soft-cap wrap-up path: non-lead session hit the exploration
-        // budget and was steered to a text-only finish. Distinct from the hard
-        // cap (iteration_cap) — this is an expected, budget-driven termination,
-        // not a runaway. Covers BOTH the grace-exhausted path
-        // (terminatedBySoftCap) AND the compliant path where the model emitted
-        // the final text with no more tool calls while the soft cap was active
-        // (loop ends via the no-tool-call break, so terminatedBySoftCap stays
-        // false but softCapActive is still true).
-        return 'soft_cap_wrapup';
-    }
     if (!_finalHasContent && _finalIncompleteStop) {
         // Cut short mid-synthesis (token cap / provider pause). Real problem
         // for hidden agents too.