s-app-scoder-agent 0.9.2 → 0.9.6

package/dist/{guardrails.js → agent/guardrails.js}

@@ -1,4 +1,4 @@
-import { claimsCompletion } from "./context.js";
+import { claimsCompletion } from "../context/context.js";
 /** Marker do system prompt quy ước: lượt chat thuần, không cần build. */
 export const CHAT_DONE_MARKER = "<<CHAT_DONE>>";
 export const DEFAULT_GUARDRAIL_OPTIONS = {

package/dist/agent/interaction.js

@@ -0,0 +1,70 @@
+export class InteractionBroker {
+    pendingPermissions = new Map();
+    questionHandler = null;
+    permissionSequence = 0;
+    questionSequence = 0;
+    setQuestionHandler(fn) {
+        this.questionHandler = fn;
+    }
+    ask(runtime, request) {
+        const handler = this.questionHandler;
+        if (!handler) {
+            return {
+                ok: false,
+                output: "ERROR: ask_user is unavailable — non-interactive session. Proceed with your best judgment or stop and report.",
+            };
+        }
+        const id = `q${Date.now()}_${++this.questionSequence}`;
+        runtime.emit({ type: "question_request", id, question: request.question, options: request.options, multiple: request.multiple, timeoutSecs: request.timeoutSecs ?? 120 });
+        return this.awaitQuestion(runtime, request, id, handler);
+    }
+    async awaitQuestion(runtime, request, id, handler) {
+        try {
+            const timeoutMs = (request.timeoutSecs ?? 120) * 1000;
+            const answer = await Promise.race([
+                handler({ ...request, id }),
+                new Promise((resolve) => setTimeout(() => resolve(null), timeoutMs)),
+            ]);
+            if (answer == null || (typeof answer === "string" && !answer.trim())) {
+                return { ok: false, output: "ERROR: ask_user timed out or was cancelled." };
+            }
+            runtime.logger.log({ type: "ask_user", question: request.question, answer: String(answer).slice(0, 500) });
+            return { ok: true, output: `User answered: ${answer}` };
+        }
+        catch (err) {
+            return { ok: false, output: `ERROR: ask_user failed: ${err.message.slice(0, 200)}` };
+        }
+    }
+    permissionPrompt(runtime, request) {
+        if (!runtime.hasEventSink())
+            return Promise.resolve("no");
+        const id = `perm-${++this.permissionSequence}`;
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                if (this.pendingPermissions.delete(id))
+                    resolve("no");
+            }, request.timeoutSecs * 1000);
+            this.pendingPermissions.set(id, (answer) => {
+                clearTimeout(timer);
+                resolve(answer);
+            });
+            runtime.emit({
+                type: "permission_request",
+                id,
+                kind: request.kind,
+                label: request.label,
+                ...(request.command !== undefined ? { command: request.command } : {}),
+                ...(request.diff !== undefined ? { diff: request.diff } : {}),
+                ...(request.alwaysAllowPrefix !== undefined ? { alwaysAllowPrefix: request.alwaysAllowPrefix } : {}),
+                timeoutSecs: request.timeoutSecs,
+            });
+        });
+    }
+    resolvePermission(id, answer) {
+        const resolver = this.pendingPermissions.get(id);
+        if (resolver) {
+            this.pendingPermissions.delete(id);
+            resolver(answer);
+        }
+    }
+}

package/dist/agent/mcp-bridge.js

@@ -0,0 +1,136 @@
+import { saveApproval } from "../config/config.js";
+import { redactSecrets } from "../llm/llm.js";
+import { allToolSpecs } from "../tools/registry.js";
+import { applyToolFilter } from "./types.js";
+import { McpManager } from "../mcp/manager.js";
+import { validateSchema } from "../shared/json-schema.js";
+export function rebuildToolList(runtime) {
+    const manager = runtime.getMcp();
+    const mcpSpecs = manager ? [...manager.toToolSpecs(), ...manager.resourceToolSpecs()] : [];
+    let base = applyToolFilter(allToolSpecs(), runtime.primaryDef, runtime.reporter);
+    if (runtime.pendingAllowedTools && runtime.pendingAllowedTools.length > 0) {
+        const allow = new Set(runtime.pendingAllowedTools.map((tool) => tool.toLowerCase()));
+        base = base.filter((spec) => allow.has(spec.function.name.toLowerCase()));
+        runtime.setTools([...base, ...mcpSpecs.filter((spec) => allow.has(spec.function.name.toLowerCase()))]);
+    }
+    else {
+        runtime.setTools([...base, ...mcpSpecs]);
+    }
+}
+export async function connectMcp(runtime) {
+    const servers = runtime.config.mcpServers ?? {};
+    if (Object.keys(servers).length === 0)
+        return;
+    if (runtime.getMcp())
+        return;
+    if (runtime.config.permissionMode === "readonly") {
+        runtime.reporter.warn("readonly mode: MCP tools are disabled (they bypass the permission system)");
+    }
+    const manager = new McpManager(servers);
+    runtime.setMcp(manager);
+    manager.onStatus = (line) => {
+        runtime.logger.log({ type: "mcp_status", line });
+        runtime.emit({ type: "mcp_status", line });
+        runtime.reporter.info(line);
+    };
+    manager.onServerState = (name, state, detail) => {
+        const line = `MCP "${name}" ${state}${detail ? ` — ${detail}` : ""}`;
+        runtime.logger.log({ type: "mcp_status", line, server: name, state });
+        runtime.emit({ type: "mcp_status", line, server: name, state });
+    };
+    await manager.connectAll();
+    rebuildToolList(runtime);
+}
+export function shutdownMcp(runtime) {
+    runtime.getMcp()?.killAll();
+    runtime.setMcp(null);
+}
+export async function invokeMcpTool(runtime, name, args) {
+    const registration = runtime.getMcp()?.getTool(name);
+    if (!registration)
+        return { ok: false, output: `ERROR: unknown tool "${name}"` };
+    const schemaErrors = validateSchema(args, registration.def.inputSchema);
+    if (schemaErrors.length > 0) {
+        return { ok: false, output: `ERROR: invalid arguments for ${name}:\n${schemaErrors.join("\n")}` };
+    }
+    runtime.logger.log({
+        type: "mcp_audit",
+        tool: name,
+        server: registration.serverName,
+        args: redactSecrets(JSON.stringify(args)),
+        ts: new Date().toISOString(),
+    });
+    const result = await registration.conn.callTool(registration.toolName, args);
+    return {
+        ok: result.ok,
+        output: result.output.length > 20_000 ? result.output.slice(0, 20_000) + "\n... [truncated]" : result.output,
+        untrusted: true,
+    };
+}
+export async function mcpStatus(runtime) {
+    const configs = (runtime.config.mcpServers ?? {});
+    const target = (config) => config.url ?? config.command ?? "(unknown)";
+    const manager = runtime.getMcp();
+    if (!manager) {
+        return Object.entries(configs).map(([name, config]) => ({ name, command: target(config), connected: false, tools: [], serverInfo: {}, capabilities: {}, resourceCount: 0, promptCount: 0 }));
+    }
+    await connectMcp(runtime);
+    const states = manager.serverStates();
+    const stateMap = new Map(states.map((state) => [state.name, state]));
+    const byServer = new Map(manager.listToolsByServer().map((server) => [server.server, server.tools]));
+    return Object.entries(configs).map(([name, config]) => {
+        const state = stateMap.get(name);
+        return {
+            name,
+            command: target(config),
+            connected: state?.state === "ready",
+            tools: byServer.get(name) ?? [],
+            serverInfo: state?.serverInfo ?? {},
+            capabilities: state?.capabilities ?? {},
+            resourceCount: state?.resourceCount ?? 0,
+            promptCount: state?.promptCount ?? 0,
+        };
+    });
+}
+export async function callMcpTool(runtime, fullName, inputArgs) {
+    await connectMcp(runtime);
+    const manager = runtime.getMcp();
+    const registration = manager?.getTool(fullName);
+    if (!registration)
+        return { ok: false, output: `ERROR: unknown MCP tool "${fullName}" — run /mcp to list servers and tools.` };
+    const trust = runtime.config.mcpServers[registration.serverName]?.trust;
+    const decision = runtime.permissions.classifyMcpTool(fullName, trust) ??
+        (runtime.config.permissionMode === "readonly" ? { decision: "deny", reason: "readonly mode" } :
+            runtime.config.permissionMode === "ask" ? { decision: "ask", reason: "requires user confirmation" } :
+                { decision: "allow", reason: "auto mode" });
+    if (decision.decision === "deny")
+        return { ok: false, output: `ERROR: MCP tool denied (${decision.reason}).` };
+    if (decision.decision === "ask" && !runtime.config.yes && !(await runtime.confirmMcpTool(fullName))) {
+        return { ok: false, output: `ERROR: user denied permission to call MCP tool: ${fullName}` };
+    }
+    let args = inputArgs;
+    if ("__text" in args && typeof args.__text === "string") {
+        const properties = (registration.def.inputSchema?.properties ?? {});
+        const required = (registration.def.inputSchema?.required ?? []);
+        const target = required.find((key) => properties[key]?.type === "string") ?? Object.keys(properties).find((key) => properties[key]?.type === "string");
+        if (!target)
+            return { ok: false, output: `ERROR: "${fullName}" has no string parameter — pass JSON args instead.` };
+        args = { [target]: args.__text };
+    }
+    try {
+        return await registration.conn.callTool(registration.toolName, args);
+    }
+    catch (err) {
+        return { ok: false, output: `ERROR: ${err.message}` };
+    }
+}
+export async function confirmMcpTool(runtime, fullName) {
+    return runtime.permissions.confirmMcpTool(fullName, () => {
+        try {
+            saveApproval(runtime.config.workdir, { action: fullName, resource: "*", effect: "allow" });
+        }
+        catch {
+            // Persistence failure must not block the run.
+        }
+    });
+}

package/dist/agent/prompt-context.js

@@ -0,0 +1,83 @@
+import { discoverAgents } from "../context/agents.js";
+import { buildAgentGuideBlock } from "../context/agents-guide.js";
+import { buildRepoMap } from "../context/repo-map.js";
+import { buildSystemPrompt, buildEnvInfo, buildSkillsBlock, buildAgentsBlock, buildMcpBlock } from "../context/prompt-builder.js";
+import { discoverSkills, findSkill } from "../context/skills.js";
+import { formatWorkingMemory, memoryIsMeaningful } from "../context/memory.js";
+/** Compaction prompt fragment that preserves the working-memory ledger. */
+export function memoryBlock(memory, taskNote) {
+    if (!memoryIsMeaningful(memory))
+        return { instruction: "", suffix: "" };
+    const ledger = formatWorkingMemory(memory);
+    return {
+        instruction: `\n\nWorking memory ledger accumulated so far (keep ALL of it in the summary):\n${ledger}`,
+        suffix: `\n\n${ledger}${taskNote ?? ""}`,
+    };
+}
+/** Build the first system/user message batch without changing prompt composition or order. */
+export function buildRunMessages(input) {
+    const { config, primaryDef, skills, buildCmd, task, pendingContext } = input;
+    const skillsBlock = buildSkillsBlock(skills);
+    const agentsGuideBlock = buildAgentGuideBlock(config.workdir, task);
+    const repoMapBlock = config.repoMap === false ? "" : `\n\n${buildRepoMap(config.workdir)}`;
+    const baseOverride = primaryDef?.prompt?.trim() ? primaryDef.prompt : undefined;
+    return [
+        {
+            role: "system",
+            content: buildSystemPrompt({
+                workdir: config.workdir,
+                buildCmd,
+                envInfo: buildEnvInfo(config.workdir),
+                skillsBlock,
+                mcpBlock: buildMcpBlock(config),
+                agentsGuideBlock,
+                repoMapBlock,
+                base: baseOverride,
+                promptVersion: config.promptVersion,
+            }) + buildAgentsBlock(discoverAgents(config.workdir), config.allowSubagents !== false),
+        },
+        ...pendingContext.map((content) => ({ role: "user", content })),
+        { role: "user", content: task },
+    ];
+}
+/** Project/global skills plus the one-shot context staged by `/skill`. */
+export class PromptContext {
+    workdir;
+    skills;
+    pendingContext = [];
+    pendingAllowedTools = null;
+    constructor(workdir) {
+        this.workdir = workdir;
+        this.skills = discoverSkills(workdir);
+    }
+    getSkills() {
+        return this.skills;
+    }
+    reloadSkills() {
+        this.skills = discoverSkills(this.workdir);
+    }
+    skillCount() {
+        return this.skills.length;
+    }
+    stageSkill(name) {
+        const skill = findSkill(this.workdir, name);
+        if (!skill) {
+            const names = this.skills.map((item) => item.name).join(", ");
+            return { ok: false, message: `skill "${name}" not found${names ? ` — available: ${names}` : " — no skills discovered (try /skill)"}` };
+        }
+        this.pendingContext.push(`[User loaded skill "${skill.name}" — follow these instructions for the upcoming task]\n\n${skill.body}`);
+        this.pendingAllowedTools = skill.allowedTools?.length ? skill.allowedTools : null;
+        return { ok: true, message: `skill "${skill.name}" staged — it will apply to your next task` };
+    }
+    pendingTools() {
+        return this.pendingAllowedTools;
+    }
+    clearPendingTools() {
+        this.pendingAllowedTools = null;
+    }
+    takePendingContext() {
+        const pending = this.pendingContext;
+        this.pendingContext = [];
+        return pending;
+    }
+}

package/dist/agent/run-loop.js

@@ -0,0 +1,318 @@
+import { trimHistory, summariseOutput, MAX_HISTORY_TOKENS, historyTokenBudget } from "../context/context.js";
+import { CHAT_DONE_MARKER } from "./guardrails.js";
+import { parseDiagnostics, formatDiagnostics, classifyError } from "../workspace/diagnostics.js";
+import { shouldCompact, estimateTokens, extractSummaryInput, COMPACTION_INSTRUCTION, applyCompaction } from "../context/compaction.js";
+import { redactSecrets } from "../llm/llm.js";
+import { memoryIsMeaningful, formatWorkingMemory, scanDecisions } from "../context/memory.js";
+import { READONLY_TOOLS } from "./tool-executor.js";
+/** The shared autonomous loop; it intentionally retains the existing event and persistence ordering. */
+export async function runAgentLoop(runtime, startSteps, buildCmd, initialBuild = null) {
+    let steps = startSteps;
+    let lastBuild = initialBuild;
+    // G1: guardrail tracker state (textOnlyStreak, sigRepeat, toolError*,
+    // lowTokenStreak, wrapUpInjected) sống trong GuardrailEngine — reset mỗi run.
+    runtime.guardrails.reset();
+    // H-10 compaction config (false = disabled → mechanical trim only).
+    // I-02: contextWindow từ model catalog (lookup sync, cache/fallback) thay
+    // vì default 128k cứng — compaction trigger chính xác theo model.
+    const compactionCfg = runtime.config.compaction === false ? null : runtime.compactionSettings();
+    // Compaction-aware trim: mechanical trim scales with the model window and
+    // starts AFTER compaction (95% vs 80% trigger). Disabled compaction keeps
+    // the legacy conservative 90k cap.
+    const trimBudget = compactionCfg
+        ? historyTokenBudget(compactionCfg.contextWindow)
+        : MAX_HISTORY_TOKENS;
+    // When a run ends early (guardrail finish/build verification) compaction is
+    // skipped, so never leave a near-full window for the next turn.
+    const safeTrimBudget = Math.min(trimBudget, MAX_HISTORY_TOKENS);
+    while (steps < runtime.config.maxSteps && !runtime.aborted) {
+        // ── Safe step boundary: deliver steered user input (H-08) ────────────
+        const steered = runtime.drainSteerInbox();
+        if (steered.length > 0) {
+            for (const s of steered) {
+                runtime.messages.push({ role: "user", content: s });
+                runtime.events.append({ type: "message.added", message: { role: "user", content: s } });
+            }
+            // One allowance reset for the whole steering batch (opencode behavior)
+            // — engine exposes a hook so the runLoop doesn't touch tracker state.
+            runtime.guardrails.notifySteered();
+            runtime.emit({ type: "steer_delivered", count: steered.length });
+            runtime.emit({ type: "queue", ...runtime.steerCounts() });
+            runtime.reporter.info(`steer: +${steered.length} user message(s) delivered`);
+        }
+        // v2 (3.4): fold the ledger into the conversation every 6 steps.
+        if (steps > 0 && steps % 6 === 0 && memoryIsMeaningful(runtime.memory)) {
+            runtime.messages.push({ role: "user", content: formatWorkingMemory(runtime.memory) });
+        }
+        steps++;
+        runtime.reporter.step(steps, runtime.config.maxSteps, "thinking...");
+        runtime.events.claimExecution(steps);
+        runtime.emit({ type: "step", step: steps, maxSteps: runtime.config.maxSteps });
+        // Metrics: thời gian phần LLM của bước này (điều chỉnh chất lượng +
+        // so sánh provider; hiển thị trong `scoder cost`).
+        const stepStart = Date.now();
+        const { message, usage, incomplete } = await runtime.chatWithStream().catch((err) => {
+            // SIGINT during the LLM call — stop gracefully instead of crashing
+            if (runtime.aborted) {
+                return {
+                    message: { role: "assistant", content: null, tool_calls: undefined },
+                    usage: undefined,
+                    incomplete: undefined,
+                };
+            }
+            throw err;
+        });
+        if (runtime.aborted)
+            break;
+        runtime.recordLlmUsage(usage);
+        runtime.emitContextEvent();
+        runtime.logger.log({ type: "step", step: steps, durationMs: Date.now() - stepStart, toolCalls: message.tool_calls?.length ?? 0 });
+        // H-09: after an interrupted stream, nudge the model to continue rather
+        // than restart (synthetic continuation instruction, opencode pattern).
+        if (incomplete) {
+            runtime.messages.push({
+                role: "user",
+                content: "[system] The previous response was cut off mid-stream. The tool call(s) above were received in full — continue exactly where you left off; do not repeat completed work.",
+            });
+            runtime.events.append({ type: "retry.scheduled", reason: "incomplete-stream continuation" });
+        }
+        // ── Chuẩn bị context cho Guardrail Engine ─────────────────────────────
+        // Chat marker được làm sạch ở đây để rule nhận text đã chuẩn hoá.
+        const hasToolCalls = !!message.tool_calls && message.tool_calls.length > 0;
+        let text = message.content ?? "";
+        let chatDone = false;
+        if (!hasToolCalls && text.includes(CHAT_DONE_MARKER)) {
+            chatDone = true;
+            text = text.split(CHAT_DONE_MARKER)[0].trim();
+        }
+        if (!hasToolCalls) {
+            runtime.messages.push({ role: "assistant", content: text });
+            runtime.events.append({ type: "message.added", message: { role: "assistant", content: text } });
+            runtime.reporter.llm("agent", text);
+            scanDecisions(runtime.memory, text);
+        }
+        else {
+            runtime.messages.push({
+                role: "assistant",
+                content: message.content ?? null,
+                tool_calls: message.tool_calls,
+            });
+            runtime.events.append({ type: "message.added", message: runtime.messages[runtime.messages.length - 1] });
+            if (typeof message.content === "string")
+                scanDecisions(runtime.memory, message.content);
+        }
+        // v2 (3.3): soft guardrail — editing without a plan gets a reminder.
+        const batchMayWriteEarly = (message.tool_calls ?? []).some((tc) => tc.name === "write_file" || tc.name === "edit_file" || tc.name === "apply_patch");
+        if (batchMayWriteEarly && runtime.plan.length === 0 && !runtime.planNudged) {
+            runtime.planNudged = true;
+            runtime.messages.push({
+                role: "user",
+                content: "[system] You modified files without a plan. Call write_todos now with the full remaining plan " +
+                    "(steps with verify + acceptance), then continue. One step in_progress at a time.",
+            });
+        }
+        // Execute each tool call (validate args before running)
+        const stepToolResults = new Map();
+        // H-11: checkpoint before any batch that may write files.
+        const batchMayWrite = (message.tool_calls ?? []).some((tc) => tc.name === "write_file" || tc.name === "edit_file" || tc.name === "apply_patch");
+        if (batchMayWrite)
+            runtime.snapshots.capture(`step ${steps}: ${(message.tool_calls ?? []).map((t) => t.name).join(",")}`);
+        // I-09: parallelize read-only tool calls (concurrency cap 4); mutating
+        // calls (and any batch containing an ask-gated call) run sequentially.
+        const calls = message.tool_calls ?? [];
+        const needsAsk = calls.some((tc) => {
+            if (tc.name !== "run_command")
+                return false;
+            try {
+                const a = JSON.parse(tc.arguments || "{}");
+                if (typeof a.command !== "string")
+                    return false;
+                const d = runtime.permissions.classifyShell(a.command);
+                return d.decision === "ask" || d.decision === "deny";
+            }
+            catch {
+                return true;
+            }
+        });
+        if (calls.length > 1 && !needsAsk) {
+            const readOnly = calls.every((tc) => READONLY_TOOLS.has(tc.name));
+            if (readOnly) {
+                const executor = runtime.toolExecutor();
+                const results = await executor.parallelMap(calls, (tc) => executor.executeToolCall(tc, steps, stepToolResults), Math.max(1, runtime.config.limits?.toolConcurrency ?? 4));
+                for (const r of results) {
+                    if (r.post)
+                        r.post();
+                }
+            }
+            else {
+                for (const tc of calls) {
+                    if (runtime.aborted)
+                        break;
+                    const r = await runtime.toolExecutor().executeToolCall(tc, steps, stepToolResults);
+                    if (r.post)
+                        r.post();
+                }
+            }
+        }
+        else {
+            for (const tc of calls) {
+                if (runtime.aborted)
+                    break;
+                const r = await runtime.toolExecutor().executeToolCall(tc, steps, stepToolResults);
+                if (r.post)
+                    r.post();
+            }
+        }
+        // ── Guardrail Engine — đánh giá toàn bộ rule sau khi tools chạy xong ──
+        // Thông tin build stop condition: có tool call nào chạy ĐÚNG buildCmd?
+        // Match theo arguments đã parse (đúng hơn substring: "npm run build && rm -rf /"
+        // vẫn tính là build call, nhưng lệnh echo chứa chuỗi buildCmd thì không).
+        const buildCall = hasToolCalls
+            ? (message.tool_calls ?? []).find((tc) => tc.name === "run_command" &&
+                (() => {
+                    try {
+                        const a = JSON.parse(tc.arguments || "{}");
+                        return typeof a.command === "string" && a.command.includes(buildCmd);
+                    }
+                    catch {
+                        return false;
+                    }
+                })())
+            : undefined;
+        let buildPassedThisStep = false;
+        if (buildCall) {
+            const r = stepToolResults.get(buildCall.id);
+            if (r && r.ok)
+                buildPassedThisStep = true;
+        }
+        const decisions = await runtime.guardrails.evaluate({
+            step: steps,
+            maxSteps: runtime.config.maxSteps,
+            text,
+            message,
+            hasToolCalls,
+            toolResults: stepToolResults,
+            buildPassedThisStep,
+            buildCallPresent: !!buildCall,
+            filesModified: runtime.filesModified,
+            chatDone,
+            outputTokensThisStep: usage?.completion_tokens,
+            totalTokensIn: runtime.usageTotals.inputTokens, // G6 budget rule
+            totalTokensOut: runtime.usageTotals.outputTokens,
+        });
+        // Áp dụng decision: finish đầu tiên thắng; inject gom lại đẩy một lần.
+        const reminders = [];
+        let doTrim = false;
+        for (const d of decisions) {
+            const a = d.action;
+            if (a.kind === "inject") {
+                if (d.rule === "wrap-up")
+                    runtime.guardrails.markWrapUpInjected(); // chỉ inject một lần / run
+                reminders.push(a.reminder);
+                continue;
+            }
+            if (a.kind === "trim") {
+                doTrim = true;
+                continue;
+            }
+            if (a.kind === "verify-build") {
+                // Xác minh độc lập với lời của model (async — loop tự chạy verify).
+                lastBuild = await runtime.verifyAll(buildCmd);
+                if (lastBuild.success) {
+                    // v2: self-review the diff before calling it done.
+                    const reviewNote = await runtime.selfReviewGate();
+                    if (reviewNote) {
+                        reminders.push(`[self-review] blocking findings — fix these, then verify again:\n${reviewNote}`);
+                        continue;
+                    }
+                    if (doTrim)
+                        runtime.messages = trimHistory(runtime.messages, safeTrimBudget);
+                    return runtime.finish(true, steps, buildCmd, a.successSummary);
+                }
+                // Structured diagnostics + error class instead of a raw log tail.
+                const diags = parseDiagnostics(lastBuild.output);
+                const errClass = classifyError(lastBuild.output);
+                const signature = runtime.failureSignature(lastBuild.output);
+                runtime.verifyStrikes = signature === runtime.lastVerifySignature ? runtime.verifyStrikes + 1 : 1;
+                runtime.lastVerifySignature = signature;
+                const failBlock = diags.length > 0 ? formatDiagnostics(diags) : summariseOutput(lastBuild.output);
+                reminders.push(`${a.failReminder}\n${failBlock}\nError class: ${errClass.kind} — ${errClass.strategy}\nFix and continue.`);
+                if (runtime.verifyStrikes >= 4) {
+                    for (const r of reminders)
+                        runtime.messages.push({ role: "user", content: r });
+                    if (doTrim)
+                        runtime.messages = trimHistory(runtime.messages, safeTrimBudget);
+                    return runtime.finish(false, steps, buildCmd, `Verification failed the same way ${runtime.verifyStrikes} times — stopping. Last error class: ${errClass.kind}.`);
+                }
+                if (runtime.verifyStrikes >= 2) {
+                    reminders.push("<system-reminder>The SAME verification failed repeatedly. Stop retrying the identical approach — change strategy fundamentally, or report the blocker in your final message.</system-reminder>");
+                }
+                continue;
+            }
+            if (a.kind === "finish") {
+                // Giữ nguyên thứ tự tin nhắn như bản inline cũ: reminder (wrap-up)
+                // đã đẩy trước khi kết thúc.
+                if (a.success && runtime.filesModified && !a.chatOnly && !runtime.selfReviewDone && runtime.config.selfReview !== false) {
+                    const reviewNote = await runtime.selfReviewGate();
+                    if (reviewNote) {
+                        reminders.push(`[self-review] blocking findings — fix these, then verify again:\n${reviewNote}`);
+                        continue;
+                    }
+                }
+                for (const r of reminders)
+                    runtime.messages.push({ role: "user", content: r });
+                if (doTrim)
+                    runtime.messages = trimHistory(runtime.messages, safeTrimBudget);
+                return runtime.finish(a.success, steps, buildCmd, a.summary, a.chatOnly ?? false);
+            }
+        }
+        for (const r of reminders)
+            runtime.messages.push({ role: "user", content: r });
+        // H-10: LLM compaction when history approaches the context window.
+        // Runs BEFORE mechanical trim: trim drops whole turns, which could push
+        // the history below the trigger before compaction ever sees it.
+        if (compactionCfg && shouldCompact(runtime.messages, compactionCfg)) {
+            try {
+                runtime.reporter.info("compaction: summarizing older history…");
+                const tokensBefore = estimateTokens(runtime.messages);
+                const summaryInput = extractSummaryInput(runtime.currentTask, runtime.messages);
+                const mem = runtime.memoryBlock();
+                const summaryRes = await runtime.client.chat([
+                    ...runtime.messages,
+                    { role: "user", content: `${summaryInput}\n\n${COMPACTION_INSTRUCTION}${mem.instruction}` },
+                ], [], // no tools for the summarizer call
+                { signal: runtime.runSignal.signal });
+                runtime.recordLlmUsage(summaryRes.usage);
+                const summary = redactSecrets(summaryRes.message.content ?? "History summarized.") + mem.suffix;
+                runtime.messages = applyCompaction(runtime.messages, summary, compactionCfg);
+                const tokensAfter = estimateTokens(runtime.messages);
+                runtime.events.append({
+                    type: "compaction.ran",
+                    tokensBefore,
+                    tokensAfter,
+                    summary: summary.slice(0, 2000),
+                });
+                runtime.snapshotMemory("compaction");
+                runtime.reporter.info(`compaction: done (${tokensBefore} → ${tokensAfter} tokens, history now ${runtime.messages.length} messages)`);
+                runtime.emit({ type: "compaction", tokensBefore, tokensAfter, manual: false });
+                runtime.emitContextEvent(true);
+            }
+            catch (err) {
+                // Compaction is best-effort — mechanical trim stays as fallback.
+                runtime.reporter.warn(`compaction failed (${err.message.slice(0, 100)}) — using mechanical trim`);
+                // Fallback uses the legacy conservative cap: the next LLM call must
+                // not leave a near-full window if summarization failed.
+                runtime.messages = trimHistory(runtime.messages, safeTrimBudget);
+            }
+        }
+        if (doTrim)
+            runtime.messages = trimHistory(runtime.messages, trimBudget);
+        // Persist session state after every step (enables resume after crash/SIGINT)
+        runtime.saveSession(steps, buildCmd, lastBuild);
+        runtime.events.releaseExecution(steps);
+    }
+    // Max steps reached or aborted
+    const reason = runtime.aborted ? "interrupted by user (SIGINT)" : `reached max steps (${runtime.config.maxSteps})`;
+    runtime.saveSession(steps, buildCmd, lastBuild);
+    return runtime.finish(false, steps, buildCmd, `Agent stopped: ${reason}`);
+}