s-app-scoder-agent 0.9.8 → 0.9.9

package/dist/context/context.js

@@ -15,12 +15,38 @@ export const MAX_HISTORY_TOKENS = 90_000;
  * 0.8) so semantic compaction gets a chance to run first.
  */
 export const HISTORY_TRIM_FRACTION = 0.95;
-/** Mechanical trim budget for a given context window (floor 2k). */
-export function historyTokenBudget(contextWindow) {
-    return Math.max(2_000, Math.floor(contextWindow * HISTORY_TRIM_FRACTION));
+/** Sàn dưới của ngân sách history — window quá nhỏ thì history cũng phải còn đủ sống. */
+export const MIN_HISTORY_TOKENS = 2_000;
+/**
+ * Mechanical trim budget for a given context window (floor MIN_HISTORY_TOKENS).
+ *
+ * `fixedTokens` (P1-1/RC-4): phần prompt cố định KHÔNG nằm trong messages —
+ * quan trọng nhất là tool schema (~16k token với 46 tool MCP). `outputReserve`:
+ * chỗ trống cho reply (config.maxTokens). Với 1 tham số, hành vi giữ nguyên
+ * như trước (chỉ scale theo window) để tương thích test và rollback.
+ *
+ * Reply bị trần ở 25% phần còn lại: với window nhỏ (llama.cpp -c 16384) mà để
+ * maxTokens 8192 ăn hết thì ngân sách history rớt xuống sàn 2k → trim gần như
+ * mỗi bước, đúng cái mà P0-1 sinh ra để tránh.
+ */
+export function historyTokenBudget(contextWindow, fixedTokens = 0, outputReserve = 0) {
+    const usable = Math.floor(contextWindow * HISTORY_TRIM_FRACTION) - fixedTokens;
+    if (usable <= 0)
+        return MIN_HISTORY_TOKENS;
+    const reserve = Math.min(outputReserve, Math.floor(usable * 0.25));
+    return Math.max(MIN_HISTORY_TOKENS, Math.floor(usable - reserve));
 }
+/**
+ * P0-1 (hysteresis): khi trim đã cần thiết, cắt xuống còn fraction này của
+ * ngân sách thay vì đúng ngưỡng. Mỗi lần trim đều vô hiệu hoá KV-cache của
+ * toàn bộ prompt phía sau điểm cắt (llama.cpp/Ollama chỉ reuse prefix giống
+ * hệt từng token), nên mục tiêu là THỨA NHẤT trim, không phải trim "vừa đủ".
+ */
+export const TRIM_RECOVERY_FRACTION = 0.7;
 /** Tool results older than this many recent tool messages get pruned. */
 const KEEP_RECENT_TOOL_RESULTS = 20;
+/** Placeholder do prune thay vào — test và UI nhận diện chuỗi này. */
+export const PRUNED_TOOL_RESULT = "[pruned — old tool result]";
 /** Token count for one message (tool_calls arguments included). Never throws. */
 function messageTokens(m) {
     let text = m.content ?? "";
@@ -35,20 +61,71 @@ function messageTokens(m) {
     }
 }
 const historyTokens = (msgs) => msgs.reduce((n, m) => n + messageTokens(m), 0);
+/** Char count (content + tool_call args) — không tokenize. */
+function historyChars(msgs) {
+    let chars = 0;
+    for (const m of msgs) {
+        chars += m.content?.length ?? 0;
+        // ChatMessage dùng shape {name, arguments}; history dựng từ JSONL resume có
+        // thể mang shape OpenAI {function:{name,arguments}} — đọc cả hai, không crash.
+        for (const tc of m.tool_calls ?? []) {
+            const call = tc;
+            chars +=
+                (call.name?.length ?? 0) +
+                    (call.arguments?.length ?? 0) +
+                    (call.function?.name?.length ?? 0) +
+                    (call.function?.arguments?.length ?? 0);
+        }
+    }
+    return chars;
+}
+/**
+ * P0-1: áp lực history so với ngân sách token.
+ *
+ * Một token luôn dài ≥ 1 ký tự, nên `chars` là cận trên tuyệt đối của số
+ * token: nếu chars còn chưa vượt ngân sách thì chắc chắn UNDER — bỏ qua
+ * bước encode (O(n) trên toàn bộ history, tránh trả giá mỗi bước).
+ * Khi chars vượt ngân sách mới tokenize chính xác.
+ */
+export function historyPressure(messages, budget = MAX_HISTORY_TOKENS) {
+    const chars = historyChars(messages);
+    if (chars <= budget)
+        return { tokens: chars, budget, over: false };
+    const tokens = historyTokens(messages);
+    return { tokens, budget, over: tokens > budget };
+}
 /**
  * Trim message history to stay within a token budget. Layered strategy
  * (context engineering — inspired by compaction patterns, from scratch):
+ *   0. P0-1 fast path: dưới ngân sách thì TRẢ NGUYÊN MẢNG (identity).
  *   1. Message-count cap: keep system + newest MAX_MESSAGES-1.
- *   2. Token budget: drop the OLDEST WHOLE TURNS (from a user message up to
- *      the next user message) until under `maxTokens` — dropping whole
- *      turns never orphans an assistant tool_calls / tool result pair.
- *   3. Old tool results (outside the recent window) are pruned in place to a
- *      short placeholder — their content dominated the budget anyway.
+ *   2. Old tool results (outside the recent window) are pruned in ONE bulk
+ *      pass to a short placeholder — cheapest information loss.
+ *   3. Still over target: drop the OLDEST BLOCKS from the head (system được
+ *      bảo vệ; điểm cắt không bao giờ nằm sau một assistant có tool_calls)
+ *      until under the recovery target.
+ *
+ * Không bao giờ sửa nội dung lác đác ở giữa prompt: mỗi lần trim là một lần
+ * cắt gọn nhất có thể, để THỨA lần trim xảy ra.
  *
  * `maxTokens` defaults to the legacy 90k cap; callers with compaction enabled
  * pass `historyTokenBudget(contextWindow)` so trim runs *after* compaction.
+ *
+ * PERF CONTRACT (plan/performance-issue.md RC-1): hàm này KHÔNG được gọi mỗi
+ * bước. Trước đây nó chạy sau mỗi step và luôn luôn sửa in-place tool result
+ * ở giữa prompt (_boundary_ prune list dịch theo từng step) → mọi lượt gọi LLM
+ * đều re-prefill toàn bộ history. Session `20261106-023204-670b`: 1.58M input
+ * token, `cachedTokens: 0`, latency nhảy từ 11.9s → 141.3s/lượt. Chỉ gọi khi
+ * `historyPressure().over` (guardrail `history-trim`) hoặc khi compaction fail.
  */
 export function trimHistory(messages, maxTokens = MAX_HISTORY_TOKENS) {
+    // 0) Nothing over budget → trả về đúng mảng được truyền vào. Prefix của
+    //    prompt vì thế giữ nguyên từng byte giữa các lượt gọi LLM.
+    const overCount = messages.length > MAX_MESSAGES;
+    const overTokens = historyPressure(messages, maxTokens).over;
+    if (!overCount && !overTokens)
+        return messages;
+    const target = Math.max(1, Math.floor(maxTokens * TRIM_RECOVERY_FRACTION));
     let out = messages;
     // 1) Message-count cap
     if (out.length > MAX_MESSAGES) {
@@ -56,27 +133,53 @@ export function trimHistory(messages, maxTokens = MAX_HISTORY_TOKENS) {
         const rest = system ? out.slice(1) : out;
         out = system ? [system, ...rest.slice(-(MAX_MESSAGES - 1))] : rest.slice(-(MAX_MESSAGES - 1));
     }
-    // 2) Token budget — drop oldest whole turns, never the system message
-    while (out.length > 2 && historyTokens(out) > maxTokens) {
-        const firstIdx = out[0].role === "system" ? 1 : 0;
-        if (out[firstIdx]?.role !== "user")
-            break; // no clean turn boundary — stop
-        let next = firstIdx + 1;
-        while (next < out.length && out[next].role !== "user")
-            next++;
-        out = [...out.slice(0, firstIdx), ...out.slice(next)];
+    // 2) PRUNE tool result cũ TRƯỚC, một lô duy nhất: mất ít thông tin nhất
+    //    (khung hội thoại assistant↔tool vẫn nguyên, model vẫn biết đã gọi gì),
+    //    chỉ bỏ nội dung ngoài cửa sổ KEEP_RECENT_TOOL_RESULTS.
+    if (historyTokens(out) > target) {
+        const oldIdx = [];
+        for (let i = 0; i < out.length; i++)
+            if (out[i].role === "tool")
+                oldIdx.push(i);
+        const pruneBefore = oldIdx.length - KEEP_RECENT_TOOL_RESULTS;
+        if (pruneBefore > 0) {
+            const pruneSet = new Set(oldIdx.slice(0, pruneBefore));
+            out = out.map((m, i) => pruneSet.has(i) && (m.content?.length ?? 0) > 200 ? { ...m, content: PRUNED_TOOL_RESULT } : m);
+        }
     }
-    // 3) Prune old tool-result contents (safe: contents only, never removals —
-    // removing a tool message would orphan its assistant tool_calls entry).
-    const toolIdx = [];
-    for (let i = 0; i < out.length; i++)
-        if (out[i].role === "tool")
-            toolIdx.push(i);
-    const pruneBefore = toolIdx.length - KEEP_RECENT_TOOL_RESULTS;
-    if (pruneBefore > 0) {
-        out = out.map((m, i) => toolIdx.includes(i) && toolIdx.indexOf(i) < pruneBefore && (m.content?.length ?? 0) > 200
-            ? { ...m, content: "[pruned — old tool result]" }
-            : m);
+    // 3) Vẫn vượt target → BỎ block nguyên khối từ đầu, dừng ở `target`
+    //    (hysteresis) chứ không dừng ngay ngưỡng: số lần trim giảm ~3 lần, mỗi
+    //    lần vẫn phá KV-cache nhưng tổng thời gian re-prefill thấp hơn hẳn so với
+    //    phá cache mỗi bước. Điểm cắt PHẢI thoả cả hai điều kiện để không mồ côi:
+    //      (a) message ngay trước điểm cắt không phải assistant có tool_calls;
+    //      (b) message tại điểm cắt không phải role "tool" (cha nó đã bị bỏ).
+    //    System prompt + nhiệm vụ gốc (message user đầu) luôn được bảo vệ, nên
+    //    run MỘT task dài vẫn còn mục tiêu sau trim — logic "nguyên turn" cũ
+    //    (cắt từ user này tới user kế tiếp) không bỏ được gì trong case đó.
+    const keepsSystem = out[0]?.role === "system";
+    const keepsTask = out[keepsSystem ? 1 : 0]?.role === "user";
+    const head = (keepsSystem ? 1 : 0) + (keepsTask ? 1 : 0);
+    const perMessage = out.map(messageTokens);
+    let total = 0;
+    for (let i = 0; i < perMessage.length; i++)
+        total += perMessage[i];
+    if (total > target) {
+        let cut = head;
+        let dropped = 0;
+        for (let i = head; i < out.length; i++) {
+            if (total - dropped <= target)
+                break;
+            dropped += perMessage[i];
+            const prev = out[i];
+            const next = out[i + 1];
+            const safeCut = i + 1 <= out.length - 2 &&
+                !(prev.role === "assistant" && prev.tool_calls?.length) &&
+                next?.role !== "tool";
+            if (safeCut)
+                cut = i + 1;
+        }
+        if (cut > head)
+            out = [...out.slice(0, head), ...out.slice(cut)];
     }
     return out;
 }

package/dist/index.js

@@ -2,12 +2,23 @@
 /** LEGACY PUBLIC PATH — CLI implementation lives in ./cli/main.js. */
 import process from "node:process";
 import { pathToFileURL } from "node:url";
+import { realpathSync } from "node:fs";
 import * as ui from "./io/terminal.js";
 import { main } from "./cli/main.js";
 export { parseArgs } from "./cli/args.js";
 export { runInit } from "./cli/init.js";
 // Guard: only run when executed as entry point (not imported in tests).
-if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+const _argv1 = process.argv[1]
+    ? (() => {
+        try {
+            return realpathSync(process.argv[1]);
+        }
+        catch {
+            return process.argv[1];
+        }
+    })()
+    : null;
+if (_argv1 && import.meta.url === pathToFileURL(_argv1).href) {
     main().catch((err) => {
         ui.error(`fatal: ${err.stack ?? err.message}`);
         process.exit(2);

package/dist/llm/context-probe.js

@@ -0,0 +1,151 @@
+/**
+ * P1-1 (RC-4): lấy context window THẬT của engine đang phục vụ model.
+ *
+ * Vì sao cần: `contextWindowFor()` fallback 128k cho model lạ. Session
+ * `20261106-023204-670b` chạy `qwen3.6:35b` trên Ollama/llama.cpp — server
+ * thật chạy `num_ctx` nhỏ hơn nhiều. Agent tưởng còn 102k token để nén
+ * (0.8 × 128k) trong khi server chỉ còn vài nghìn → server tự cắt history,
+ * và mỗi lần server cắt là prefix đổi → mất KV-cache → re-prefill.
+ *
+ * Chiến lược (chỉ đọc, không gửi token nào):
+ *   1. llama.cpp server: GET {origin}/props → n_ctx.
+ *   2. Ollama: POST {origin}/api/show {model} → parameters "num_ctx N"
+ *      (runtime), nếu không có thì model_info "*ctx_length" (window khai
+ *      báo của model, floor theo catalog).
+ *   3. OpenAI-compatible có `max_model_len` (vLLM): GET {origin}/v1/models.
+ * Không chắc chắn → trả null, gọi giữ nguyên catalog fallback.
+ */
+/** Cache theo (origin, model) — một engine một window, không probe lại mỗi bước. */
+const cache = new Map();
+function originOf(baseUrl) {
+    try {
+        // baseUrl có thể có space thừa (" http://0.0.0.0:8080/v1" trong rc thật) —
+        // URL() tự trim, nên parse được cả khi user gõ dư khoảng trắng.
+        const u = new URL(baseUrl.trim());
+        return `${u.protocol}//${u.host}`;
+    }
+    catch {
+        return null;
+    }
+}
+function authHeaders(auth) {
+    const h = { ...(auth?.headers ?? {}) };
+    if (auth?.apiKey && !h.authorization && !h["x-api-key"])
+        h.authorization = `Bearer ${auth.apiKey}`;
+    return h;
+}
+async function jsonFetch(url, init, timeoutMs, auth) {
+    try {
+        const res = await fetch(url, {
+            ...init,
+            headers: { ...authHeaders(auth), ...(init.headers ?? {}) },
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (!res.ok)
+            return null; // 401 khi server bật --api-key: probe im lặng, giữ fallback
+        return await res.json();
+    }
+    catch {
+        return null; // offline / không có endpoint này
+    }
+}
+function asNumber(v) {
+    const n = typeof v === "string" ? Number(v) : v;
+    return typeof n === "number" && Number.isFinite(n) && n >= 1 ? Math.floor(n) : null;
+}
+/** "num_ctx 4096\nrope_freqscale 1" — chuỗi parameters của Ollama. */
+function numCtxFromParameters(parameters) {
+    if (typeof parameters === "string") {
+        const m = /(?:^|\s)num_ctx\s+(\d+)/i.exec(parameters);
+        if (m)
+            return Number(m[1]);
+    }
+    if (parameters && typeof parameters === "object") {
+        return asNumber(parameters.num_ctx);
+    }
+    return null;
+}
+function ctxLengthFromModelInfo(info) {
+    if (!info || typeof info !== "object")
+        return null;
+    let best = null;
+    for (const [k, v] of Object.entries(info)) {
+        if (!/ctx_length|context_length/i.test(k))
+            continue;
+        const n = asNumber(v);
+        if (n && (!best || n < best))
+            best = n; // window KHAI BÁO: lấy số nhỏ nhất (an toàn)
+    }
+    return best;
+}
+async function probeLlamaCpp(origin, timeoutMs, auth) {
+    const props = (await jsonFetch(`${origin}/props`, { method: "GET" }, timeoutMs, auth));
+    if (!props)
+        return null;
+    // llama.cpp hiện để window ở default_generation_settings.n_ctx (per-slot),
+    // KHÔNG ở top level; các build cũ hơn dùng n_ctx / n_ctx_slot / total_n_ctx.
+    const perSlot = asNumber(props.default_generation_settings?.n_ctx) ??
+        asNumber(props.default_generation_settings?.params?.n_ctx) ??
+        asNumber(props.n_ctx_slot) ??
+        asNumber(props.n_ctx);
+    // total_n_ctx = perSlot * total_slots: dùng perSlot vì MỘT hội thoại sống
+    // trong MỘT slot; lấy total sẽ phóng to window lên số lần sai.
+    const n = perSlot ?? asNumber(props.total_n_ctx);
+    if (!n)
+        return null;
+    const slots = asNumber(props.total_slots);
+    return {
+        tokens: n,
+        source: "llama.cpp",
+        detail: `GET /props n_ctx=${n}${slots && slots > 1 ? ` (server chia ${slots} slot — request rải nhau nên KV-cache ít được dùng lại hơn)` : ""}`,
+    };
+}
+async function probeOllama(origin, model, timeoutMs, auth) {
+    const show = (await jsonFetch(`${origin}/api/show`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ model }) }, timeoutMs, auth));
+    if (!show)
+        return null;
+    const runtime = numCtxFromParameters(show.parameters) ?? asNumber(show.context_window);
+    if (runtime)
+        return { tokens: runtime, source: "ollama", detail: `POST /api/show num_ctx=${runtime}` };
+    const declared = ctxLengthFromModelInfo(show.model_info);
+    if (declared)
+        return { tokens: declared, source: "ollama", detail: `model_info ctx_length=${declared} (server không đặt num_ctx)` };
+    return null;
+}
+async function probeVllm(baseUrl, origin, model, timeoutMs, auth) {
+    // baseUrl OpenAI-compatible thường đã gồm /v1 → GET {base}/models; thử thêm
+    // {origin}/v1/models cho server đặt root khác.
+    const trimmed = baseUrl.trim().replace(/\/+$/, "");
+    for (const url of [`${trimmed}/models`, `${origin}/v1/models`]) {
+        const list = (await jsonFetch(url, { method: "GET" }, timeoutMs, auth));
+        if (!list?.data?.length)
+            continue;
+        const entry = list.data.find((m) => m.id === model) ?? list.data[0];
+        const n = asNumber(entry?.max_model_len);
+        if (n)
+            return { tokens: n, source: "vllm", detail: `GET ${url} max_model_len=${n}` };
+    }
+    return null;
+}
+/**
+ * Probe window thật của (baseUrl, model). null = không xác định được (giữ
+ * cách xử lý cũ). Không bao giờ throw — agent vẫn chạy bình thường với server
+ * không expose metadata.
+ */
+export async function probeContextWindow(baseUrl, model, timeoutMs = 1_500, auth) {
+    const origin = originOf(baseUrl);
+    if (!origin)
+        return null;
+    const key = `${origin}|${model}`;
+    if (cache.has(key))
+        return cache.get(key) ?? null;
+    const found = (await probeOllama(origin, model, timeoutMs, auth)) ??
+        (await probeLlamaCpp(origin, timeoutMs, auth)) ??
+        (await probeVllm(baseUrl, origin, model, timeoutMs, auth));
+    cache.set(key, found);
+    return found;
+}
+/** Test hook: xoá cache trong tiến trình (không dùng trong code production). */
+export function resetContextProbeCache() {
+    cache.clear();
+}

package/dist/llm/llm.js

@@ -88,6 +88,24 @@ export function combinedSignal(external, timeoutMs) {
 // ---------------------------------------------------------------------------
 const SSE_PREFIX = "data: ";
 const SSE_DONE = "[DONE]";
+/**
+ * P1-3: chuẩn hoá usage từ OpenAI-compatible server.
+ *
+ * llama.cpp/Ollama báo số token lấy từ KV-cache ở `usage.prompt_tokens_details
+ * .cached_tokens` (kiểu OpenAI mới), không phải `cached_tokens` — nếu không
+ * map thì `scoder cost` hiện cached=0 dù server thật có reuse cache, tức là
+ * đúng cái metric cần để phát hiện "prefix bị đổi".
+ */
+export function normalizeUsage(usage) {
+    if (!usage)
+        return undefined;
+    const out = { ...usage };
+    const details = out.prompt_tokens_details;
+    if (typeof out.cached_tokens !== "number" && typeof details?.cached_tokens === "number") {
+        out.cached_tokens = details.cached_tokens;
+    }
+    return out;
+}
 /** Parse SSE chunks from an OpenAI-compatible stream. */
 function parseSSELine(line) {
     if (!line.startsWith(SSE_PREFIX))
@@ -188,14 +206,7 @@ export class LlmClient {
             throw new LlmError("LLM API returned no message in response");
         // Extract cached prompt tokens when the provider reports them
         // (OpenAI-style: usage.prompt_tokens_details.cached_tokens).
-        let usage;
-        if (data.usage) {
-            usage = { ...data.usage };
-            const details = usage.prompt_tokens_details;
-            if (usage.cached_tokens === undefined && typeof details?.cached_tokens === "number") {
-                usage.cached_tokens = details.cached_tokens;
-            }
-        }
+        const usage = normalizeUsage(data.usage);
         return {
             message: {
                 role: "assistant",
@@ -312,7 +323,7 @@ export class LlmClient {
                     // Usage-only final chunk: many providers send usage in a chunk with
                     // an empty choices array — must not be skipped.
                     if (chunkData.usage)
-                        finalUsage = { ...chunkData.usage };
+                        finalUsage = normalizeUsage(chunkData.usage);
                     const choice = chunkData.choices?.[0];
                     if (!choice)
                         continue;
@@ -369,7 +380,7 @@ export class LlmClient {
                                 tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
                                 reasoning: reasoningAccum || undefined,
                             },
-                            usage: chunkData.usage,
+                            usage: normalizeUsage(chunkData.usage),
                         };
                     }
                 }

package/dist/llm/prompt-metrics.js

@@ -0,0 +1,78 @@
+/**
+ * P1-3 (RC-1): đo "prefix" của prompt để phát hiện mất KV-cache.
+ *
+ * Engine cục bộ (llama.cpp / Ollama) chỉ reuse KV cache cho phần prefix GIỐNG
+ * HẸT từng token; một token ở giữa đổi ⇒ re-prefill toàn bộ phía sau. Session
+ * `20261106-023204-670b` đổi 11.9s → 141.3s/lượt đúng tại điểm prune đầu
+ * tiên. Câu hỏi cần trả lời được từ JSONL: "lượt này history có phải là append
+ * lên history của lượt trước không?"
+ *
+ * Cách đo: băm TỪNG message theo thứ tự, so mảng hash của lượt trước với lượt
+ * này. `prefixReused = true` khi mảng cũ là tiền tố của mảng mới (append-only)
+ * ⇒ toàn bộ prompt đã gửi trước đó vẫn nằm nguyên trong cache. Một message ở
+ * giữa bị sửa (prune/trim/compaction) ⇒ false. Đổi tool list cũng làm hỏng
+ * prefix (tool defs nằm ở vùng system) nên `promptHash` (gồm cả tools) được log
+ * kèm để phân biệt hai nguyên nhân.
+ */
+import { createHash } from "node:crypto";
+const short = (s) => createHash("sha1").update(s).digest("hex").slice(0, 12);
+/** Chuỗi đặc trưng cho một message (role + content + tool_calls). */
+function messageKey(m) {
+    let s = m.role + "\u0000" + (m.content ?? "");
+    for (const tc of m.tool_calls ?? []) {
+        const call = tc;
+        s += "\u0001" + (call.name ?? call.function?.name ?? "") + (call.arguments ?? call.function?.arguments ?? "");
+    }
+    if (m.tool_call_id)
+        s += "\u0002" + m.tool_call_id;
+    return s;
+}
+/** Serialize phần tools — đặc trưng và ổn định theo thứ tự khai báo. */
+export function serializeTools(tools) {
+    return (tools ?? [])
+        .map((t) => t.function.name + "\u0000" + (t.function.description ?? "") + "\u0000" + JSON.stringify(t.function.parameters ?? {}))
+        .join("\u0003");
+}
+export function messageHashes(messages) {
+    return (messages ?? []).map((m) => short(messageKey(m)));
+}
+/**
+ * So sánh: mảng hash của lượt trước có phải tiền tố của lượt này không.
+ * `commonPrefix` = số message đầu giống nhau.
+ */
+export function commonPrefixLength(prev, current) {
+    const previous = prev ?? [];
+    let i = 0;
+    while (i < previous.length && i < current.length && previous[i] === current[i])
+        i++;
+    return { reused: i === previous.length, commonPrefix: i };
+}
+/** Tính metrics cho một lượt gọi — O(kích thước prompt), chỉ chạy một lần/lượt. */
+export function promptMetrics(messages, tools, previous) {
+    const hashes = messageHashes(messages);
+    const historyText = hashes.join("");
+    const toolsText = serializeTools(tools);
+    const cmp = previous ? commonPrefixLength(previous.messageHashes, hashes) : null;
+    // Char thật của prompt (nội dung message + tool defs) — để trả lời "12k token
+    // này đến từ đâu". KHÔNG dùng historyText (chuỗi hash) ở đây.
+    let messageChars = 0;
+    for (const m of messages ?? []) {
+        messageChars += (m.content ?? "").length + (m.tool_call_id ?? "").length;
+        for (const tc of m.tool_calls ?? []) {
+            const call = tc;
+            messageChars += (call.name ?? call.function?.name ?? "").length + (call.arguments ?? call.function?.arguments ?? "").length;
+        }
+    }
+    return {
+        messages: hashes.length,
+        tools: (tools ?? []).length,
+        promptChars: messageChars + toolsText.length,
+        messageChars,
+        schemaChars: toolsText.length,
+        promptHash: short(toolsText + "\u0004" + historyText),
+        historyHash: short(historyText),
+        messageHashes: hashes,
+        prefixReused: cmp ? cmp.reused : null,
+        commonPrefixMessages: cmp ? cmp.commonPrefix : null,
+    };
+}

package/dist/mcp/manager.js

@@ -1,5 +1,6 @@
 import { redactSecrets } from "../llm/llm.js";
 import { MCP_RESOURCE_TOOL_NAMES, mcpToolKey } from "./types.js";
+import { filterToolNames } from "./tool-filter.js";
 import { McpConnection } from "./connection.js";
 const schemaObj = (properties, required) => ({
     type: "object",
@@ -174,25 +175,8 @@ export class McpManager {
     }
     /** MCP A: apply per-server tool include/exclude filters to a tool list. */
     filterToolDefs(name, defs) {
-        const filter = this.configs[name]?.tools;
-        if (!filter)
-            return defs;
-        const include = filter.include?.filter(Boolean) ?? [];
-        const exclude = new Set((filter.exclude ?? []).map((s) => s.toLowerCase()));
-        const match = (pat, n) => {
-            if (!pat.includes("*"))
-                return n === pat.toLowerCase();
-            const rx = new RegExp("^" + pat.split("*").map((s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*") + "$", "i");
-            return rx.test(n);
-        };
-        return defs.filter((t) => {
-            const n = t.name.toLowerCase();
-            if (include.length > 0 && !include.some((pat) => match(pat, n)))
-                return false;
-            if ([...exclude].some((e) => match(e, n)))
-                return false;
-            return true;
-        });
+        // P0-3: matcher dùng chung với bộ lọc toàn cục rc "mcpTools" (tool-filter.ts).
+        return filterToolNames(defs, (t) => t.name, this.configs[name]?.tools);
     }
     /** Replace một server's tool registrations (reconnect refresh) — honor config filters. */
     reregisterTools(name, conn, defs) {

package/dist/mcp/tool-filter.js

@@ -0,0 +1,34 @@
+/**
+ * P0-3 (RC-2): glob filter cho tên tool MCP.
+ *
+ * Tách khỏi McpManager để `agent/mcp-bridge.ts` lọc được DANH SÁCH TOOL ĐÃ
+ * QUẢNG CÁO (tên đầy đủ `mcp__<server>__<tool>`) bằng rc "mcpTools" — cùng cú
+ * pháp với `mcpServers.<name>.tools.include/exclude` (lọc theo server).
+ */
+/** Pattern không có `*` so khớp đúng tên (case-insensitive); có `*` → glob. */
+export function matchToolPattern(pattern, name) {
+    const p = pattern.toLowerCase();
+    const n = name.toLowerCase();
+    if (!p.includes("*"))
+        return n === p;
+    const rx = new RegExp("^" + p.split("*").map((s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*") + "$", "i");
+    return rx.test(n);
+}
+/** True khi `name` được phép theo filter (include rỗng = tất cả; exclude thắng). */
+export function toolAllowed(name, filter) {
+    if (!filter)
+        return true;
+    const include = (filter.include ?? []).filter(Boolean);
+    const exclude = (filter.exclude ?? []).filter(Boolean);
+    if (include.length > 0 && !include.some((pat) => matchToolPattern(pat, name)))
+        return false;
+    if (exclude.some((pat) => matchToolPattern(pat, name)))
+        return false;
+    return true;
+}
+/** Lọc một danh sách theo nhiều filter (giữ thứ tự khai báo). */
+export function filterToolNames(items, nameOf, filter) {
+    if (!filter || (!filter.include?.length && !filter.exclude?.length))
+        return items;
+    return items.filter((item) => toolAllowed(nameOf(item), filter));
+}

package/dist/tools/path-safety.js

@@ -5,11 +5,31 @@ export function setMaxOutputChars(n) {
     if (Number.isFinite(n) && n > 0)
         MAX_OUTPUT_CHARS = Math.floor(n);
 }
+/**
+ * P0-2 (RC-3): ngân sách ký tự cho MỘT tool result khi đẩy vào history.
+ *
+ * Khác MAX_OUTPUT_CHARS (chặn blob từ tool): con số này quyết định kích thước
+ * nội dung model nhìn thấy mỗi bước. Với local model, mỗi 6k ký tự đọc thêm
+ * ≈ 1.5k token và TOÀN BỘ số đó được re-prefill ở mọi lượt sau. read_file dùng
+ * giá trị này để cắt theo DÒNG kèm hướng dẫn đọc tiếp (xem read-file.ts).
+ */
+export let MAX_TOOL_OUTPUT_CHARS = 6_000;
+export function setMaxToolOutputChars(n) {
+    if (Number.isFinite(n) && n > 0)
+        MAX_TOOL_OUTPUT_CHARS = Math.floor(n);
+}
 export const MAX_FILE_SIZE_BYTES = 2 * 1024 * 1024; // refuse to read files > 2MB
-export function clamp(s, max = MAX_OUTPUT_CHARS) {
+/**
+ * Cắt chuỗi theo ký tự, thêm marker số lượng còn lại. `hint` (P0-2) được gắn
+ * vào marker để model biết CÁCH lấy phần còn lại (offset/limit) thay vì đoán —
+ * đây chính là điểm commit aec95ef đã sửa (trunc mù → agent đọc lại/đổi chiến
+ * lược, đốt thêm nhiều lượt).
+ */
+export function clamp(s, max = MAX_OUTPUT_CHARS, hint) {
     if (s.length <= max)
         return s;
-    return s.slice(0, max) + `\n... [truncated, ${s.length - max} more chars]`;
+    const tail = hint ? ` — ${hint}` : "";
+    return s.slice(0, max) + `\n... [truncated, ${s.length - max} more chars${tail}]`;
 }
 /** Resolve a user-supplied path inside workdir; reject escapes and symlink traversal. */
 export function safePath(workdir, p) {

package/dist/tools/read-file.js

@@ -1,7 +1,7 @@
 import { readFileSync, statSync, realpathSync } from "node:fs";
 import { relative } from "node:path";
 import { detectImageBytes } from "../media/image.js";
-import { clamp, MAX_FILE_SIZE_BYTES, safePath, toPosInt, toResult } from "./path-safety.js";
+import { clamp, MAX_FILE_SIZE_BYTES, MAX_OUTPUT_CHARS, MAX_TOOL_OUTPUT_CHARS, safePath, toPosInt, toResult } from "./path-safety.js";
 import { isProtectedEnvFile } from "./path-safety.js";
 export function toolReadFile(workdir, args) {
     return toResult(() => {
@@ -56,9 +56,29 @@ export function toolReadFile(workdir, args) {
         const offset = Math.min(toPosInt(args.offset, 1), total);
         const limit = Math.min(toPosInt(args.limit, total - offset + 1), 2000);
         const slice = lines.slice(offset - 1, offset - 1 + limit);
-        const numbered = slice.map((l, i) => `${offset + i}: ${l}`).join("\n");
-        const end = offset + slice.length - 1;
+        const numberedAll = slice.map((l, i) => `${offset + i}: ${l}`);
+        // P0-2 (RC-3): cắt theo DÒNG ngay tại ngân sách history (limits.toolOutputChars)
+        // và nói rõ phần còn lại nằm ở dòng nào + lấy tiếp bằng tham số nào. Trunc mù
+        // kiểu "... more chars" từng khiến agent đọc lại cả file bằng "cách khác".
+        const budget = Math.max(200, Math.min(MAX_TOOL_OUTPUT_CHARS, MAX_OUTPUT_CHARS));
+        const kept = [];
+        let used = 0;
+        for (const line of numberedAll) {
+            if (used + line.length + 1 > budget && kept.length > 0)
+                break;
+            kept.push(line);
+            used += line.length + 1;
+        }
+        const dropped = numberedAll.length - kept.length;
+        const end = offset + kept.length - 1;
         const header = offset > 1 || end < total ? `[lines ${offset}-${end} of ${total} — ${args.path}]\n` : "";
-        return { ok: true, output: clamp(header + numbered) };
+        const footer = dropped > 0
+            ? `\n... [${dropped} more line(s): ${end + 1}-${offset + slice.length - 1} of ${total}. ` +
+                `Read the next chunk with read_file({"path":"${args.path}","offset":${end + 1}}) — ` +
+                `do NOT re-read from the start.]`
+            : "";
+        // clamp cho dòng kếch xù (một dòng 40k ký tự vẫn phải nằm trong ngân sách).
+        const numbered = clamp(kept.join("\n"), budget);
+        return { ok: true, output: header + numbered + footer };
     });
 }