openhorse 0.2.11 → 0.2.13

package/dist/framework/query.js

@@ -10,12 +10,17 @@
  * chunks directly to stdout via the callback.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryLoopError = exports.DEFAULT_LOOP_BUDGET = exports.DEFAULT_MAX_MODEL_VISIBLE_TOOL_RESULT_BYTES = void 0;
+exports.createLocalFastPathLoopStats = createLocalFastPathLoopStats;
+exports.createFailedLoopStats = createFailedLoopStats;
 exports.query = query;
 const tool_1 = require("./tool");
 const strategy_tracker_1 = require("../core/strategy-tracker");
 const auto_compact_1 = require("../services/compact/auto-compact");
 const tool_scheduler_1 = require("./tool-scheduler");
 const token_estimate_1 = require("../utils/token-estimate");
+const tool_serializer_1 = require("./tool-serializer");
+exports.DEFAULT_MAX_MODEL_VISIBLE_TOOL_RESULT_BYTES = 4096;
 function isAborted(signal) {
     return signal?.aborted === true;
 }
@@ -26,6 +31,14 @@ function cancelledEvent(llm) {
         model: llm.getModel(),
     };
 }
+function cancelledCompleteEvent(llm, stats) {
+    return {
+        type: 'complete',
+        content: 'Operation cancelled.',
+        model: llm.getModel(),
+        stats: cloneLoopStats(stats, 'cancelled'),
+    };
+}
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -65,6 +78,326 @@ function parseBatchReadEvidenceSteps(result) {
             }];
     });
 }
+exports.DEFAULT_LOOP_BUDGET = {
+    maxLlmRequestsPerUserTurn: 24,
+    maxToolCallsPerUserTurn: 120,
+    maxReadOnlyFragmentation: 3,
+    maxModelVisibleToolBytes: 64 * 1024,
+    profile: 'default',
+    baseProfile: 'default',
+    configOverride: false,
+};
+const COMPLEX_LOOP_BUDGET = {
+    maxLlmRequestsPerUserTurn: 48,
+    maxToolCallsPerUserTurn: 180,
+    maxModelVisibleToolBytes: 96 * 1024,
+};
+class QueryLoopError extends Error {
+    constructor(error, stats) {
+        super(error instanceof Error ? error.message : String(error));
+        this.name = 'QueryLoopError';
+        this.originalError = error;
+        this.stats = stats;
+    }
+}
+exports.QueryLoopError = QueryLoopError;
+function createLoopStats() {
+    return {
+        turnsStarted: 0,
+        llmRequests: 0,
+        toolCalls: 0,
+        readOnlyToolCalls: 0,
+        unsafeToolCalls: 0,
+        toolResultBytes: 0,
+        modelVisibleToolBytes: 0,
+        summarizedBytes: 0,
+        finishReason: 'running',
+        providerRetryCount: 0,
+        providerRetryDelayMs: 0,
+        providerRetryErrorTypes: [],
+        providerFallbackCount: 0,
+        providerUsingFallback: false,
+        singleReadOnlyStreak: 0,
+        batchReadSuggestionCount: 0,
+        localFastPathUsed: false,
+    };
+}
+function cloneLoopStats(stats, finishReason) {
+    return {
+        ...stats,
+        finishReason: finishReason ?? stats.finishReason,
+    };
+}
+function byteLength(text) {
+    return Buffer.byteLength(text, 'utf8');
+}
+function createLocalFastPathLoopStats(overrides = {}) {
+    return {
+        ...createLoopStats(),
+        turnsStarted: 1,
+        finishReason: 'completed',
+        localFastPathUsed: true,
+        ...overrides,
+    };
+}
+function createFailedLoopStats(options = {}) {
+    const { loopBudget, diagnostics, ...overrides } = options;
+    const stats = {
+        ...createLoopStats(),
+        turnsStarted: 1,
+        llmRequests: 1,
+        finishReason: 'failed',
+        ...overrides,
+    };
+    applyLoopBudgetStats(stats, resolveLoopBudget(loopBudget));
+    applyLlmRequestDiagnostics(stats, diagnostics);
+    return stats;
+}
+function isLoopBudgetSource(value) {
+    return value === 'default' || value === 'complex' || value === 'release' || value === 'config';
+}
+function isLoopBudgetBaseProfile(value) {
+    return value === 'default' || value === 'complex' || value === 'release';
+}
+function resolveLoopBudget(partial) {
+    const numericOverrides = Object.fromEntries(Object.entries(partial ?? {}).filter(([, value]) => typeof value === 'number' && Number.isFinite(value) && value > 0));
+    const hasNumericOverrides = Object.keys(numericOverrides).length > 0;
+    const hasExplicitProfile = partial?.profile !== undefined || partial?.baseProfile !== undefined;
+    const inferredConfigOverride = hasNumericOverrides && !hasExplicitProfile;
+    const configOverride = partial?.configOverride === true || inferredConfigOverride;
+    return {
+        ...exports.DEFAULT_LOOP_BUDGET,
+        ...numericOverrides,
+        profile: isLoopBudgetSource(partial?.profile)
+            ? partial.profile
+            : configOverride
+                ? 'config'
+                : exports.DEFAULT_LOOP_BUDGET.profile,
+        baseProfile: isLoopBudgetBaseProfile(partial?.baseProfile) ? partial.baseProfile : exports.DEFAULT_LOOP_BUDGET.baseProfile,
+        configOverride,
+    };
+}
+function applyLoopBudgetStats(stats, budget) {
+    stats.loopBudgetSource = budget.profile ?? 'default';
+    stats.loopBudgetBaseProfile = budget.baseProfile ?? (budget.profile === 'config' ? 'default' : budget.profile ?? 'default');
+    stats.loopBudgetMaxLlmRequests = budget.maxLlmRequestsPerUserTurn;
+    stats.loopBudgetMaxToolCalls = budget.maxToolCallsPerUserTurn;
+    stats.loopBudgetMaxReadOnlyFragmentation = budget.maxReadOnlyFragmentation;
+    stats.loopBudgetMaxModelVisibleBytes = budget.maxModelVisibleToolBytes;
+    stats.loopBudgetConfigOverride = budget.configOverride === true;
+}
+function shouldPromoteDefaultBudget(stats, budget) {
+    if (budget.configOverride === true || budget.profile !== 'default')
+        return false;
+    if (stats.llmRequests < budget.maxLlmRequestsPerUserTurn)
+        return false;
+    return stats.toolCalls >= 8
+        || stats.readOnlyToolCalls >= 6
+        || stats.modelVisibleToolBytes >= 16 * 1024;
+}
+function promoteDefaultBudgetToComplex(budget) {
+    return {
+        ...budget,
+        maxLlmRequestsPerUserTurn: Math.max(budget.maxLlmRequestsPerUserTurn, COMPLEX_LOOP_BUDGET.maxLlmRequestsPerUserTurn),
+        maxToolCallsPerUserTurn: Math.max(budget.maxToolCallsPerUserTurn, COMPLEX_LOOP_BUDGET.maxToolCallsPerUserTurn),
+        maxModelVisibleToolBytes: Math.max(budget.maxModelVisibleToolBytes, COMPLEX_LOOP_BUDGET.maxModelVisibleToolBytes),
+        profile: 'complex',
+        baseProfile: 'complex',
+        configOverride: false,
+    };
+}
+function getLlmRequestDiagnostics(llm) {
+    const diagnosticsReader = llm.getLastRequestDiagnostics;
+    return typeof diagnosticsReader === 'function' ? diagnosticsReader.call(llm) : undefined;
+}
+function applyLlmRequestDiagnostics(stats, diagnostics) {
+    if (!diagnostics)
+        return;
+    const existingTypes = stats.providerRetryErrorTypes ?? [];
+    const retryTypes = diagnostics.retryErrorTypes.filter((type, index, values) => !existingTypes.includes(type) && values.indexOf(type) === index);
+    stats.providerRetryCount = (stats.providerRetryCount ?? 0) + diagnostics.retryCount;
+    stats.providerRetryDelayMs = (stats.providerRetryDelayMs ?? 0) + diagnostics.retryDelayMs;
+    stats.providerRetryErrorTypes = [...existingTypes, ...retryTypes];
+    stats.providerLastRetryErrorType = diagnostics.lastRetryErrorType ?? stats.providerLastRetryErrorType;
+    stats.providerLastRetryStatus = diagnostics.lastRetryStatus ?? stats.providerLastRetryStatus;
+    stats.providerFinalModel = diagnostics.finalModel;
+    stats.providerUsingFallback = diagnostics.usingFallback;
+    if (diagnostics.fallbackTriggered) {
+        stats.providerFallbackCount = (stats.providerFallbackCount ?? 0) + 1;
+        stats.providerFallbackFromModel = diagnostics.fallbackFromModel;
+        stats.providerFallbackToModel = diagnostics.fallbackToModel;
+    }
+}
+function budgetExceededEvent(llm, stats, reason) {
+    const continuationActions = [
+        'reply_continue',
+        'narrow_instruction',
+        'inspect_loop_stats',
+        'raise_budget',
+    ];
+    const continuationHint = 'Reply `继续` to continue the same objective, give a narrower next step, inspect /loop-stats, or raise agentLoop.budget for intentional long work.';
+    return {
+        type: 'complete',
+        content: [
+            `Agent loop budget reached: ${reason}.`,
+            'I stopped this turn to avoid unnecessary model requests and preserved the current session state.',
+            'To continue the same objective, reply `继续` or provide the next concrete step.',
+            'Use /loop-stats to inspect request/tool counts. For intentional long work, raise agentLoop.budget in openhorse.json.',
+        ].join('\n'),
+        model: llm.getModel(),
+        stats: cloneLoopStats({
+            ...stats,
+            budgetExceededReason: reason,
+            continuationActions,
+            continuationHint,
+        }, 'budget_exceeded'),
+    };
+}
+function permissionBlockedEvent(llm, stats, toolName, error, source) {
+    const detail = error ? ` ${error}` : '';
+    const sourceText = source ? ` (${source})` : '';
+    return {
+        type: 'complete',
+        content: `Tool ${toolName} was not executed because permission was denied${sourceText}.${detail}`.trim(),
+        model: llm.getModel(),
+        stats: cloneLoopStats(stats, 'blocked'),
+    };
+}
+function compactPromptEvidence(items, maxItems = 12) {
+    return items.slice(0, maxItems).map(item => `${item.id}:${item.kind}:score=${item.score}:tokens=${item.tokens}`);
+}
+function takeUtf8Prefix(text, maxBytes) {
+    if (maxBytes <= 0)
+        return '';
+    let result = '';
+    let bytes = 0;
+    for (const char of text) {
+        const nextBytes = byteLength(char);
+        if (bytes + nextBytes > maxBytes)
+            break;
+        result += char;
+        bytes += nextBytes;
+    }
+    return result;
+}
+function takeUtf8Suffix(text, maxBytes) {
+    if (maxBytes <= 0)
+        return '';
+    let result = '';
+    let bytes = 0;
+    const chars = Array.from(text);
+    for (let index = chars.length - 1; index >= 0; index--) {
+        const char = chars[index];
+        const nextBytes = byteLength(char);
+        if (bytes + nextBytes > maxBytes)
+            break;
+        result = char + result;
+        bytes += nextBytes;
+    }
+    return result;
+}
+function truncateForModel(text, maxBytes) {
+    if (byteLength(text) <= maxBytes)
+        return text;
+    const marker = '\n...[truncated]';
+    if (maxBytes <= 128) {
+        return `${takeUtf8Prefix(text, Math.max(0, maxBytes - byteLength(marker)))}${marker}`;
+    }
+    const middle = `\n...[truncated ${byteLength(text)}B output for model context]...\n`;
+    const contentBudget = Math.max(0, maxBytes - byteLength(middle));
+    const headBytes = Math.floor(contentBudget * 0.65);
+    const tailBytes = contentBudget - headBytes;
+    return [
+        takeUtf8Prefix(text, headBytes),
+        middle,
+        takeUtf8Suffix(text, tailBytes),
+    ].join('');
+}
+function summarizeModelVisibleToolResult(executed, maxBytes) {
+    const rawBytes = byteLength(executed.result);
+    const fullOutputBytes = executed.outputBytes ?? rawBytes;
+    if (rawBytes <= maxBytes && !executed.artifactRef) {
+        return { result: executed.result, bytes: rawBytes, summarizedBytes: 0 };
+    }
+    const envelope = (0, tool_serializer_1.parseToolResultEnvelope)(executed.result);
+    const output = typeof envelope.output === 'string' ? envelope.output : executed.result;
+    const summary = executed.summary || envelope.summary;
+    const compactSummary = summary ? truncateForModel(summary, 192) : undefined;
+    const rawError = executed.error ?? envelope.error;
+    const compactError = rawError ? truncateForModel(rawError, 192) : undefined;
+    const artifactText = executed.artifactRef
+        ? ` Full output is available as artifact ${executed.artifactRef.id} (${executed.artifactRef.outputBytes}B).`
+        : '';
+    const serializeCompact = (compactOutput) => (0, tool_serializer_1.serializeToolResult)({
+        success: executed.success,
+        output: compactOutput,
+        error: compactError,
+        summary: compactSummary,
+        outputBytes: fullOutputBytes,
+        artifactRef: executed.artifactRef ?? envelope.artifactRef,
+        metadata: {
+            ...(envelope.metadata ?? {}),
+            modelVisibleCompressed: true,
+            originalResultBytes: rawBytes,
+        },
+    });
+    let outputBudget = Math.max(128, maxBytes - 768);
+    let compact = '';
+    for (let attempt = 0; attempt < 6; attempt++) {
+        compact = serializeCompact([
+            compactSummary ? `Summary: ${compactSummary}` : 'Tool output was summarized for model context.',
+            artifactText.trim(),
+            truncateForModel(output, outputBudget),
+        ].filter(Boolean).join('\n'));
+        const compactBytes = byteLength(compact);
+        if (compactBytes <= maxBytes || outputBudget <= 128)
+            break;
+        outputBudget = Math.max(128, outputBudget - Math.max(compactBytes - maxBytes, 128));
+    }
+    if (byteLength(compact) > maxBytes) {
+        compact = serializeCompact([
+            compactSummary ? `Summary: ${compactSummary}` : 'Tool output was summarized for model context.',
+            artifactText.trim(),
+            `Output body omitted from model context (${fullOutputBytes}B total).`,
+        ].filter(Boolean).join('\n'));
+    }
+    if (byteLength(compact) > maxBytes) {
+        compact = (0, tool_serializer_1.serializeToolResult)({
+            success: executed.success,
+            output: `Tool result omitted from model context (${fullOutputBytes}B total).`,
+            outputBytes: fullOutputBytes,
+            metadata: {
+                modelVisibleCompressed: true,
+                originalResultBytes: rawBytes,
+            },
+        });
+    }
+    const bytes = byteLength(compact);
+    return {
+        result: compact,
+        bytes,
+        summarizedBytes: Math.max(0, fullOutputBytes - bytes),
+    };
+}
+function omitModelVisibleToolResult(executed, maxAggregateBytes) {
+    const fullBytes = executed.outputBytes ?? byteLength(executed.result);
+    const compact = (0, tool_serializer_1.serializeToolResult)({
+        success: executed.success,
+        output: `Tool result omitted from model context because the per-turn model-visible tool budget (${maxAggregateBytes}B) was reached.`,
+        outputBytes: fullBytes,
+        artifactRef: executed.artifactRef,
+        metadata: {
+            modelVisibleCompressed: true,
+            modelVisibleBudgetExceeded: true,
+        },
+    });
+    const bytes = byteLength(compact);
+    return {
+        result: compact,
+        bytes,
+        summarizedBytes: Math.max(0, fullBytes - bytes),
+    };
+}
 // ============================================================================
 // query() — async generator
 // ============================================================================
@@ -89,25 +422,40 @@ async function* query(params) {
     harness, input, maxParallelToolCalls = 6, } = params;
     const openaiTools = (0, tool_1.toOpenAITools)(tools);
     let turn = 0;
+    const stats = createLoopStats();
+    let loopBudget = resolveLoopBudget(params.loopBudget);
+    applyLoopBudgetStats(stats, loopBudget);
+    const maxModelVisibleToolResultBytes = Math.max(512, params.maxModelVisibleToolResultBytes ?? exports.DEFAULT_MAX_MODEL_VISIBLE_TOOL_RESULT_BYTES);
+    const fragmentedReadOnlyTools = new Set(['read_file', 'glob', 'grep', 'list_files', 'git_status']);
     // 无限循环，依赖安全机制停止
     while (true) {
         turn++;
         // Check abort
         if (isAborted(abortSignal)) {
-            yield cancelledEvent(llm);
+            yield cancelledCompleteEvent(llm, stats);
             return;
         }
-        // Request start
-        yield { type: 'request_start', model: llm.getModel(), turn };
         // Safety valve: check maxTurns if specified (optional)
         if (maxTurns && turn > maxTurns) {
             yield {
                 type: 'complete',
                 content: `Reached maximum turns (${maxTurns}). Task may be incomplete.`,
                 model: llm.getModel(),
+                stats: cloneLoopStats(stats, 'max_turns'),
             };
             return;
         }
+        if (shouldPromoteDefaultBudget(stats, loopBudget)) {
+            loopBudget = promoteDefaultBudgetToComplex(loopBudget);
+            applyLoopBudgetStats(stats, loopBudget);
+        }
+        if (stats.llmRequests >= loopBudget.maxLlmRequestsPerUserTurn) {
+            yield budgetExceededEvent(llm, stats, `LLM request budget ${loopBudget.maxLlmRequestsPerUserTurn} reached`);
+            return;
+        }
+        // Request start
+        yield { type: 'request_start', model: llm.getModel(), turn };
+        stats.turnsStarted = turn;
         const autoCompact = (0, auto_compact_1.getAutoCompact)({
             modelId: llm.getModel(),
             getContextCapsule: harness ? () => harness.getCapsule() : undefined,
@@ -122,34 +470,64 @@ async function* query(params) {
         const predictedTokens = (0, token_estimate_1.estimateMessagesTokens)(requestMessages);
         const preCompacted = await autoCompact.checkPredictiveAndCompact(messages, predictedTokens);
         if (preCompacted !== messages) {
+            stats.compactTrigger = 'pre_turn';
             messages.length = 0;
             messages.push(...preCompacted);
             requestMessages = harness
                 ? harness.assembleMessages(messages, { input, tools: tools.map(tool => ({ name: tool.name, description: tool.description })) })
                 : messages;
         }
+        const assemblyStats = harness?.toJSON().promptAssemblyStats;
+        if (assemblyStats) {
+            yield {
+                type: 'prompt_assembly',
+                modelId: assemblyStats.modelId,
+                estimatedTokens: assemblyStats.estimatedTokens,
+                budgetTokens: assemblyStats.budgetTokens,
+                coreTokens: assemblyStats.coreTokens,
+                evidenceBudgetTokens: assemblyStats.evidenceBudgetTokens,
+                recentTurnBudgetTokens: assemblyStats.recentTurnBudgetTokens,
+                sections: assemblyStats.sections.slice(0, 12),
+                includedEvidence: compactPromptEvidence(assemblyStats.includedEvidence),
+                omittedEvidence: compactPromptEvidence(assemblyStats.omittedEvidence, 8),
+                includedEvidenceCount: assemblyStats.includedEvidence.length,
+                omittedEvidenceCount: assemblyStats.omittedEvidence.length,
+            };
+        }
         if (isAborted(abortSignal)) {
-            yield cancelledEvent(llm);
+            yield cancelledCompleteEvent(llm, stats);
             return;
         }
-        const response = await llm.chatStream(requestMessages, streamCallbacks, openaiTools, { abortSignal });
+        let response;
+        try {
+            stats.llmRequests++;
+            response = await llm.chatStream(requestMessages, streamCallbacks, openaiTools, { abortSignal });
+            applyLlmRequestDiagnostics(stats, getLlmRequestDiagnostics(llm));
+        }
+        catch (error) {
+            applyLlmRequestDiagnostics(stats, getLlmRequestDiagnostics(llm));
+            throw new QueryLoopError(error, cloneLoopStats(stats, 'failed'));
+        }
         if (isAborted(abortSignal)) {
-            yield cancelledEvent(llm);
+            yield cancelledCompleteEvent(llm, stats);
             return;
         }
-        // Save assistant message to history
-        const assistantMsg = {
-            role: 'assistant',
-            content: response.content,
-        };
-        if (response.toolCalls) {
-            assistantMsg.tool_calls = response.toolCalls;
-        }
-        messages.push(assistantMsg);
-        harness?.recordAssistantResponse(response);
         // Handle tool calls
         if (response.toolCalls && response.toolCalls.length > 0) {
             const toolCalls = response.toolCalls;
+            if (stats.toolCalls + toolCalls.length > loopBudget.maxToolCallsPerUserTurn) {
+                yield budgetExceededEvent(llm, stats, `tool call budget ${loopBudget.maxToolCallsPerUserTurn} would be exceeded by ${toolCalls.length} requested tools`);
+                return;
+            }
+            // Save assistant tool-call message only after budget checks, so future
+            // requests never inherit unresolved tool calls if this turn is stopped.
+            const assistantMsg = {
+                role: 'assistant',
+                content: response.content,
+                tool_calls: toolCalls,
+            };
+            messages.push(assistantMsg);
+            harness?.recordAssistantResponse(response);
             yield {
                 type: 'assistant_tool_calls',
                 content: response.content,
@@ -169,6 +547,21 @@ async function* query(params) {
                 harnessDriftCheck: harness ? ({ name, args }) => harness.beforeToolUse({ name, args }) : undefined,
                 harnessBlockedResult: harness ? (drift) => harness.asToolBlockedResult(drift) : undefined,
             });
+            stats.toolCalls += preparedCalls.length;
+            for (const prepared of preparedCalls) {
+                if (prepared.tool?.isReadOnly?.(prepared.args) === true) {
+                    stats.readOnlyToolCalls++;
+                }
+                else {
+                    stats.unsafeToolCalls++;
+                }
+            }
+            const singleFragmentedReadOnlyCall = preparedCalls.length === 1
+                && preparedCalls[0].tool?.isReadOnly?.(preparedCalls[0].args) === true
+                && fragmentedReadOnlyTools.has(preparedCalls[0].tc.function.name);
+            stats.singleReadOnlyStreak = singleFragmentedReadOnlyCall
+                ? stats.singleReadOnlyStreak + 1
+                : 0;
             for (const prepared of preparedCalls) {
                 yield {
                     type: 'tool_call',
@@ -189,11 +582,18 @@ async function* query(params) {
                 maxParallelToolCalls,
             })) {
                 if (isAborted(abortSignal)) {
-                    yield cancelledEvent(llm);
+                    yield cancelledCompleteEvent(llm, stats);
                     return;
                 }
                 const { prepared } = executed;
                 const { tc, args, attemptId } = prepared;
+                const remainingModelVisibleBytes = loopBudget.maxModelVisibleToolBytes - stats.modelVisibleToolBytes;
+                const modelVisible = remainingModelVisibleBytes < 512
+                    ? omitModelVisibleToolResult(executed, loopBudget.maxModelVisibleToolBytes)
+                    : summarizeModelVisibleToolResult(executed, Math.min(maxModelVisibleToolResultBytes, remainingModelVisibleBytes));
+                stats.toolResultBytes += executed.outputBytes ?? byteLength(executed.result);
+                stats.modelVisibleToolBytes += modelVisible.bytes;
+                stats.summarizedBytes += modelVisible.summarizedBytes;
                 strategyTracker.recordResult(attemptId, executed.strategyResult, executed.strategyError, executed.duration);
                 harness?.recordToolResult({
                     name: tc.function.name,
@@ -222,12 +622,24 @@ async function* query(params) {
                         });
                     }
                 }
+                if (executed.permissionDecision) {
+                    yield {
+                        type: 'permission_decision',
+                        name: tc.function.name,
+                        args,
+                        callId: tc.id,
+                        decision: executed.permissionDecision,
+                        batchCount: toolCalls.length,
+                        batchIndex: prepared.index,
+                    };
+                }
                 yield {
                     type: 'tool_result',
                     name: tc.function.name,
                     args,
                     callId: tc.id,
                     result: executed.result,
+                    modelVisibleResult: modelVisible.result,
                     duration: executed.duration,
                     success: executed.success,
                     artifactRef: executed.artifactRef,
@@ -239,9 +651,13 @@ async function* query(params) {
                 };
                 messages.push({
                     role: 'tool',
-                    content: executed.result,
+                    content: modelVisible.result,
                     tool_call_id: tc.id,
                 });
+                if (executed.permissionDecision?.approved === false) {
+                    yield permissionBlockedEvent(llm, stats, tc.function.name, executed.error, executed.permissionDecision.source);
+                    return;
+                }
                 if (strategyTracker.isExhausted()) {
                     const suggestion = strategyTracker.suggestAlternative();
                     if (suggestion) {
@@ -254,13 +670,31 @@ async function* query(params) {
                     }
                 }
             }
+            if (stats.singleReadOnlyStreak >= loopBudget.maxReadOnlyFragmentation) {
+                messages.push({
+                    role: 'system',
+                    content: [
+                        '[OpenHorse loop hint]',
+                        `You have made ${stats.singleReadOnlyStreak} consecutive turns with a single read-only local tool call.`,
+                        'For independent local exploration, prefer batch_read with up to 8 steps using git_status, list_files, glob, grep, and read_file.',
+                    ].join(' '),
+                });
+                stats.batchReadSuggestionCount++;
+            }
             // Continue to next turn
             continue;
         }
+        const assistantMsg = {
+            role: 'assistant',
+            content: response.content,
+        };
+        messages.push(assistantMsg);
+        harness?.recordAssistantResponse(response);
         // No tool calls — done, unless the harness requires one more pass.
         const completionGate = harness?.beforeComplete();
         if (completionGate && !completionGate.canComplete) {
             messages.push(harness.asCompletionBlockedMessage(completionGate));
+            stats.finishReason = 'completion_gate';
             continue;
         }
         yield { type: 'message', role: 'assistant', content: response.content };
@@ -278,6 +712,7 @@ async function* query(params) {
         });
         const compacted = await autoCompact.checkAndCompact(messages, totalTokens);
         if (compacted !== messages) {
+            stats.compactTrigger = stats.compactTrigger ?? 'post_turn';
             messages.length = 0;
             messages.push(...compacted);
         }
@@ -286,6 +721,7 @@ async function* query(params) {
             content: response.content,
             usage: response.usage,
             model: response.model,
+            stats: cloneLoopStats(stats, 'completed'),
         };
         return;
     }