s-app-scoder-agent 0.6.0 → 0.8.0

package/dist/agents.js

@@ -0,0 +1,70 @@
+/**
+ * Agents (I-06) — .scoder/agents/<name>.md definitions + built-ins.
+ *
+ * Frontmatter semantics from opencode /v2/docs/agents (concept only —
+ * prompt bodies are scoder's own). An agent def is: description, mode
+ * (primary|subagent|all), model override, steps, prompt body.
+ */
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { parseFrontmatter } from "./skills.js";
+/** Built-in agents — lowest priority; .md files override by name. */
+export const BUILTIN_AGENTS = [
+    {
+        name: "build",
+        description: "General coding agent (default) — edits code and runs the build until it passes.",
+        mode: "all",
+        prompt: "", // empty = use the default system prompt unchanged
+    },
+    {
+        name: "plan",
+        description: "Read-only planner — investigates and proposes an implementation plan, never edits code.",
+        mode: "primary",
+        prompt: "You are a planning agent. Investigate the codebase (read files, search, list) and produce a concrete, step-by-step implementation plan. You MUST NOT modify any files or run mutating commands — report the plan and stop. Structure: goal, findings (files/lines), plan steps ordered, risks, and the exact first step to take.",
+    },
+    {
+        name: "explore",
+        description: "Read-only subagent — searches and summarizes the codebase, returns findings.",
+        mode: "subagent",
+        prompt: "You are an exploration subagent. Answer the given question about this codebase using read-only tools (list_files, read_file, run_command with read-only commands). Be terse and factual; cite file paths. Do not modify anything.",
+    },
+];
+/** Scan .scoder/agents/*.md (project) + ~/.scoder/agents/*.md (global). */
+export function discoverAgents(workdir) {
+    const out = new Map();
+    for (const b of BUILTIN_AGENTS)
+        out.set(b.name, { ...b });
+    // Global overrides builtins; project overrides global.
+    for (const root of [join(homedir(), ".scoder", "agents"), join(workdir, ".scoder", "agents")]) {
+        if (!existsSync(root))
+            continue;
+        for (const f of readdirSync(root)) {
+            if (!f.endsWith(".md"))
+                continue;
+            try {
+                const { meta, body } = parseFrontmatter(readFileSync(join(root, f), "utf8"));
+                const name = f.replace(/\.md$/, "");
+                const mode = meta.mode === "primary" || meta.mode === "subagent" ? meta.mode : "all";
+                out.set(name, {
+                    name,
+                    description: meta.description ?? "",
+                    mode: mode,
+                    model: meta.model || undefined,
+                    steps: meta.steps ? Number(meta.steps) || undefined : undefined,
+                    prompt: body,
+                    hidden: meta.hidden === "true",
+                    disabled: meta.disabled === "true",
+                });
+            }
+            catch {
+                // skip malformed
+            }
+        }
+    }
+    return [...out.values()].filter((a) => !a.disabled);
+}
+/** Find one agent by name (built-ins included). */
+export function findAgent(workdir, name) {
+    return discoverAgents(workdir).find((a) => a.name === name) ?? null;
+}

package/dist/compaction.js

@@ -0,0 +1,114 @@
+import { encode } from "gpt-tokenizer";
+export const DEFAULT_COMPACTION = {
+    trigger: 0.8,
+    keep: 0.15,
+    buffer: 0.15,
+    contextWindow: 128_000,
+};
+/**
+ * Token-accurate count (I-10): gpt-tokenizer (offline, MIT) thay heuristic
+ * ~4 chars/token. Fallback char/4 nếu encode lỗi (never throw).
+ */
+export function estimateTokens(messages) {
+    let chars = 0;
+    const texts = [];
+    for (const m of messages) {
+        if (m.content)
+            texts.push(m.content);
+        if (m.tool_calls) {
+            for (const tc of m.tool_calls)
+                texts.push(tc.name + tc.arguments);
+        }
+    }
+    try {
+        return encode(texts.join("\n")).length + texts.length;
+    }
+    catch {
+        for (const t of texts)
+            chars += t.length;
+        return Math.ceil(chars / 4);
+    }
+}
+/** True when the history should be compacted now. */
+export function shouldCompact(messages, cfg) {
+    const budget = cfg.contextWindow * cfg.trigger;
+    return estimateTokens(messages) >= budget;
+}
+/** Index where the verbatim tail begins (never inside a tool_calls/tool pair). */
+export function findCutIndex(messages, cfg) {
+    const total = estimateTokens(messages);
+    if (total <= 0)
+        return messages.length;
+    const tailBudget = (cfg.keep + cfg.buffer) * total;
+    let acc = 0;
+    // Walk from the tail, stopping at a user-message boundary.
+    let i = messages.length - 1;
+    while (i > 0) {
+        acc += estimateTokens([messages[i]]);
+        if (acc >= tailBudget && messages[i].role === "user") {
+            return i;
+        }
+        i--;
+    }
+    return messages.length; // nothing to compact
+}
+/** Extract a compact text digest from messages (task + files touched + asks). */
+export function extractSummaryInput(task, messages) {
+    const lines = [`Original task: ${task}`];
+    const files = new Set();
+    for (const m of messages) {
+        if (m.tool_calls) {
+            for (const tc of m.tool_calls) {
+                try {
+                    const args = JSON.parse(tc.arguments);
+                    const p = args.path ?? args.file_path ?? args.file;
+                    if (typeof p === "string")
+                        files.add(p);
+                    if (tc.name === "run_command" && typeof args.command === "string") {
+                        lines.push(`- ran: ${args.command.slice(0, 120)}`);
+                    }
+                }
+                catch { /* skip malformed args */ }
+            }
+        }
+        if (m.role === "user" && m.content && !m.content.startsWith("[system]")) {
+            lines.push(`- user said: ${m.content.slice(0, 200)}`);
+        }
+    }
+    if (files.size > 0)
+        lines.push(`Files modified: ${[...files].join(", ")}`);
+    return lines.join("\n");
+}
+/** Message sent to the summarizer LLM. */
+export const COMPACTION_INSTRUCTION = "Summarize the conversation above for a coding agent that will CONTINUE this task. " +
+    "Include: (1) the original task, (2) what has been done so far and why, " +
+    "(3) files created/modified, (4) current build/test state, (5) exact next steps. " +
+    "Be factual and terse. Max 300 words.";
+/** Build the post-compaction message list. */
+export function applyCompaction(messages, summary, cfg) {
+    const cut = findCutIndex(messages, cfg);
+    const system = messages[0]?.role === "system" ? messages[0] : null;
+    const tail = messages.slice(cut);
+    // I4: giữ lại "khung" tool-call các turn đã compact — skeleton (name + args
+    // truncated) của tool_calls bị cắt, để model biết nó đã thử gì mà không
+    // phải trả giá token của output đầy đủ.
+    const skeletons = [];
+    for (const m of messages.slice(system ? 1 : 0, cut)) {
+        if (m.role === "assistant" && m.tool_calls?.length) {
+            skeletons.push({
+                role: "assistant",
+                content: null,
+                tool_calls: m.tool_calls.map((tc) => ({
+                    id: tc.id,
+                    name: tc.name,
+                    arguments: tc.arguments.length > 120 ? tc.arguments.slice(0, 120) + "…" : tc.arguments,
+                })),
+            });
+        }
+    }
+    const summaryMsg = {
+        role: "user",
+        content: `[system] Session summary (auto-compact). Earlier history was summarized:\n\n${summary}\n\nContinue the task from here.`,
+    };
+    return [...(system ? [system] : []), summaryMsg, ...skeletons, ...tail];
+}

package/dist/config.js

@@ -1,23 +1,85 @@
-import { readFileSync, existsSync } from "node:fs";
-import { resolve } from "node:path";
+import { readFileSync, existsSync, mkdirSync, writeFileSync, renameSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve, dirname } from "node:path";
+import { parseCustomProviders, resolveProvider, splitProviderModel } from "./provider-registry.js";
 const DEFAULT_BASE_URL = "https://api.openai.com/v1";
 const DEFAULT_MODEL = "gpt-4o-mini";
 const ANTHROPIC_BASE_URL = "https://api.anthropic.com/v1";
 const ANTHROPIC_DEFAULT_MODEL = "claude-sonnet-4-5";
-function loadRcFile(workdir) {
+/**
+ * G7: parse + validate rc "limits" — số nguyên dương; giá trị sai bỏ qua
+ * (dùng default). Defaults là nguồn sự thật duy nhất (resolveLimits).
+ */
+export const LIMIT_DEFAULTS = { requestTimeoutMs: 120_000, maxOutputChars: 20_000, toolConcurrency: 4, renderCap: 200 };
+function parseLimits(raw) {
+    if (!raw || typeof raw !== "object")
+        return undefined;
+    const r = raw;
+    const num = (v) => typeof v === "number" && Number.isFinite(v) && v > 0 ? Math.floor(v) : undefined;
+    const out = {};
+    for (const k of ["requestTimeoutMs", "maxOutputChars", "toolConcurrency", "renderCap"]) {
+        const v = num(r[k]);
+        if (v !== undefined)
+            out[k] = v;
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+/** G7: limits đã resolve (defaults + rc override) — các module đọc từ đây. */
+export function resolveLimits(limits) {
+    return { ...LIMIT_DEFAULTS, ...limits };
+}
+function readRcFile(path, label) {
+    if (!existsSync(path))
+        return {};
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch (err) {
+        // malformed rc file -> ignore it, but tell the user why their config is not applied
+        console.error(`⚠  ignoring malformed config file ${label}: ${err.message}`);
+        return {};
+    }
+}
+/**
+ * Global (machine-wide) config file. Overridable via SCODER_CONFIG for tests.
+ * Lowest precedence of all file sources — the project rc wins field-by-field.
+ */
+function globalRcPath() {
+    return process.env.SCODER_CONFIG || join(homedir(), ".scoder", "config.json");
+}
+/** Merge two rc views: global first, project fields win, maps merge per key. */
+function mergeRc(global, project) {
+    const merged = { ...global, ...project };
+    if (global.mcpServers || project.mcpServers) {
+        merged.mcpServers = { ...global.mcpServers, ...project.mcpServers };
+    }
+    if (global.modelPricing || project.modelPricing) {
+        merged.modelPricing = { ...global.modelPricing, ...project.modelPricing };
+    }
+    if (global.permissions || project.permissions) {
+        const concat = (a, b) => {
+            if (!Array.isArray(a) && !Array.isArray(b))
+                return b ?? a; // non-arrays pass through (parseList filters)
+            return [...(Array.isArray(a) ? a : []), ...(Array.isArray(b) ? b : [])];
+        };
+        merged.permissions = {
+            mode: project.permissions?.mode ?? global.permissions?.mode,
+            allowCommands: concat(global.permissions?.allowCommands, project.permissions?.allowCommands),
+            denyCommands: concat(global.permissions?.denyCommands, project.permissions?.denyCommands),
+        };
+    }
+    return merged;
+}
+/** T-04: exported for Agent.setModel custom-provider resolution. */
+export function loadRcFile(workdir) {
+    const global = readRcFile(globalRcPath(), globalRcPath());
     for (const name of [".scoderrc.json", ".scoderrc"]) {
         const p = resolve(workdir, name);
         if (existsSync(p)) {
-            try {
-                return JSON.parse(readFileSync(p, "utf8"));
-            }
-            catch (err) {
-                // malformed rc file -> ignore it, but tell the user why their config is not applied
-                console.error(`⚠  ignoring malformed config file ${name}: ${err.message}`);
-            }
+            return mergeRc(global, readRcFile(p, name));
         }
     }
-    return {};
+    return global;
 }
 function parsePermissionMode(raw) {
     if (raw === "auto" || raw === "ask" || raw === "readonly")
@@ -51,6 +113,29 @@ function parsePricing(raw) {
     }
     return out;
 }
+const VALID_EFFECTS = new Set(["allow", "deny", "ask"]);
+/** Validate permission rules v2; drop malformed entries with a warning. */
+export function parsePermissionRules(raw, label = "permissions.rules") {
+    if (raw === undefined)
+        return undefined;
+    if (!Array.isArray(raw)) {
+        console.error(`⚠  ignoring invalid ${label} (expected an array of {action, resource, effect})`);
+        return undefined;
+    }
+    const out = [];
+    for (let i = 0; i < raw.length; i++) {
+        const r = raw[i];
+        if (typeof r.action === "string" && r.action.trim() &&
+            typeof r.resource === "string" && r.resource &&
+            typeof r.effect === "string" && VALID_EFFECTS.has(r.effect)) {
+            out.push({ action: r.action.trim(), resource: r.resource, effect: r.effect });
+        }
+        else {
+            console.error(`⚠  ignoring invalid ${label}[${i}] (expected {action, resource, effect: allow|deny|ask})`);
+        }
+    }
+    return out;
+}
 export function loadConfig(overrides = {}) {
     const workdir = overrides.workdir ?? process.cwd();
     const rc = loadRcFile(workdir);
@@ -65,6 +150,18 @@ export function loadConfig(overrides = {}) {
         (providerRaw === undefined &&
             /^claude-/i.test(overrides.model ?? process.env.SCODER_MODEL ?? rc.model ?? ""));
     const provider = providerRaw === "anthropic" || isAnthropic ? "anthropic" : "openai";
+    // I-01: provider registry — support "provider/model" syntax + custom providers.
+    const customProviders = parseCustomProviders(rc.providers);
+    const rawModel = overrides.model ?? process.env.SCODER_MODEL ?? process.env.OPENAI_MODEL ?? rc.model ?? "";
+    const [providerPrefix, modelFromSlash] = splitProviderModel(rawModel);
+    const providerId = providerPrefix ?? overrides.provider ?? process.env.SCODER_PROVIDER ?? rc.provider ?? (isAnthropic ? "anthropic" : "openai");
+    const providerResolution = resolveProvider(providerId, customProviders);
+    const providerDef = "def" in providerResolution ? providerResolution.def : undefined;
+    if ("error" in providerResolution) {
+        console.error(`⚠  provider: ${providerResolution.error} — falling back to openai-compatible behavior`);
+    }
+    // API key: provider-specific env var wins (registry), then legacy chain.
+    const providerKeyEnv = providerDef ? process.env[providerDef.apiKeyEnv] : undefined;
     // Validate maxSteps: NaN/0/negative would silently break the agent loop
     // (steps < NaN is always false → the loop never runs).
     const rawMaxSteps = Number(process.env.SCODER_MAX_STEPS ?? rc.maxSteps ?? 40);
@@ -74,11 +171,14 @@ export function loadConfig(overrides = {}) {
         baseUrl: overrides.baseUrl ?? process.env.SCODER_BASE_URL ?? process.env.OPENAI_BASE_URL ?? rc.baseUrl ?? (isAnthropic ? ANTHROPIC_BASE_URL : DEFAULT_BASE_URL),
         apiKey: overrides.apiKey ??
             process.env.SCODER_API_KEY ??
+            providerKeyEnv ??
             (isAnthropic ? process.env.ANTHROPIC_API_KEY : undefined) ??
             process.env.OPENAI_API_KEY ??
             rc.apiKey ??
             "",
-        model: overrides.model ?? process.env.SCODER_MODEL ?? process.env.OPENAI_MODEL ?? rc.model ?? (isAnthropic ? ANTHROPIC_DEFAULT_MODEL : DEFAULT_MODEL),
+        model: overrides.model ?? process.env.SCODER_MODEL ?? process.env.OPENAI_MODEL ?? rc.model ?? (modelFromSlash || (isAnthropic ? ANTHROPIC_DEFAULT_MODEL : DEFAULT_MODEL)),
+        providerDef,
+        contextWindow: providerDef?.contextWindow,
         workdir,
         buildCmd: overrides.buildCmd ?? process.env.SCODER_BUILD_CMD ?? rc.buildCmd ?? null,
         maxSteps: overrides.maxSteps ?? validatedMaxSteps,
@@ -94,9 +194,20 @@ export function loadConfig(overrides = {}) {
                 ? true
                 : process.env.SCODER_LOG_FILE || undefined),
         mcpServers: rc.mcpServers,
+        guardrails: rc.guardrails,
         stream: overrides.stream ?? (process.env.SCODER_STREAM !== "0" ? true : false),
+        reasoning: overrides.reasoning ??
+            (process.env.SCODER_REASONING === "1" ? "on" : undefined) ??
+            rc.reasoning ??
+            "off",
         permissionMode: overrides.permissionMode ??
             parsePermissionMode(process.env.SCODER_PERMISSION ?? rc.permission ?? rc.permissions?.mode ?? "auto"),
+        permissionRules: parsePermissionRules(rc.permissions?.rules),
+        compaction: rc.compaction ?? undefined,
+        formatter: rc.formatter ?? undefined,
+        sandbox: rc.sandbox,
+        limits: parseLimits(rc.limits),
+        snapshots: rc.snapshots,
         modelPricing: parsePricing(rc.modelPricing),
     };
     // Secrets hygiene: warn if apiKey is set in the rc file (risk of accidental commit)
@@ -115,3 +226,58 @@ export function loadPermissionLists(workdir) {
         denyCommands: parseList(rc.permissions?.denyCommands),
     };
 }
+/**
+ * Policy layer (enterprise hard floor — pattern from opencode /v2/docs/policies):
+ * evaluated AFTER config rules but its deny always wins. Sources, lowest first:
+ * ~/.scoder/policies.json (user-global), /etc/scoder/policies.json (machine),
+ * SCODER_POLICY=<file> env (highest).
+ */
+export function loadPolicyRules(_workdir) {
+    const candidates = [
+        join(homedir(), ".scoder", "policies.json"),
+        "/etc/scoder/policies.json",
+        process.env.SCODER_POLICY ?? "",
+    ].filter(Boolean);
+    const out = [];
+    for (const p of candidates) {
+        if (!existsSync(p))
+            continue;
+        try {
+            const raw = JSON.parse(readFileSync(p, "utf8"));
+            const rules = parsePermissionRules(raw, p) ?? [];
+            out.push(...rules);
+        }
+        catch (err) {
+            console.error(`⚠  ignoring malformed policy file ${p}: ${err.message}`);
+        }
+    }
+    return out;
+}
+/**
+ * Saved "always allow" approvals (pattern from opencode permission/saved.ts):
+ * persisted in <workdir>/.scoder/permissions.local.json, project-scoped.
+ * Never overrides a configured deny (enforced in PermissionChecker).
+ */
+export function savedApprovalsPath(workdir) {
+    return resolve(workdir, ".scoder", "permissions.local.json");
+}
+export function loadSavedApprovals(workdir) {
+    const p = savedApprovalsPath(workdir);
+    if (!existsSync(p))
+        return [];
+    try {
+        return parsePermissionRules(JSON.parse(readFileSync(p, "utf8")), p) ?? [];
+    }
+    catch {
+        return [];
+    }
+}
+export function saveApproval(workdir, rule) {
+    const p = savedApprovalsPath(workdir);
+    const existing = loadSavedApprovals(workdir);
+    const next = [...existing.filter((r) => !(r.action === rule.action && r.resource === rule.resource)), rule];
+    mkdirSync(dirname(p), { recursive: true });
+    const tmp = `${p}.tmp`;
+    writeFileSync(tmp, JSON.stringify({ rules: next }, null, 2), { mode: 0o600 });
+    renameSync(tmp, p);
+}

package/dist/context.js

@@ -1,19 +1,70 @@
+import { encode } from "gpt-tokenizer";
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { resolve } from "node:path";
 const MAX_MESSAGES = 120; // keep history under control for long runs
 /**
- * Trim message history to stay within token budget.
- * Strategy: keep system prompt + last N messages, compact older user/assistant pairs.
+ * Total history token budget (I-10: token-accurate via gpt-tokenizer, thay
+ * char heuristic 100k chars ≈ 25k tokens). Conservative: system prompt +
+ * tool defs + reply buffer chiếm phần còn lại của contextWindow.
+ */
+const MAX_HISTORY_TOKENS = 90_000;
+/** Tool results older than this many recent tool messages get pruned. */
+const KEEP_RECENT_TOOL_RESULTS = 20;
+/** Token count for one message (tool_calls arguments included). Never throws. */
+function messageTokens(m) {
+    let text = m.content ?? "";
+    if (m.tool_calls)
+        for (const tc of m.tool_calls)
+            text += tc.name + tc.arguments;
+    try {
+        return encode(text).length;
+    }
+    catch {
+        return Math.ceil(text.length / 4);
+    }
+}
+const historyTokens = (msgs) => msgs.reduce((n, m) => n + messageTokens(m), 0);
+/**
+ * Trim message history to stay within token budget. Layered strategy
+ * (context engineering — inspired by compaction patterns, from scratch):
+ *   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 MAX_HISTORY_TOKENS — 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.
  */
 export function trimHistory(messages) {
-    if (messages.length <= MAX_MESSAGES)
-        return messages;
-    // Keep system + last MAX_MESSAGES-1
-    const system = messages[0].role === "system" ? messages[0] : null;
-    const rest = system ? messages.slice(1) : messages;
-    const trimmed = rest.slice(-(MAX_MESSAGES - 1));
-    if (system) {
-        return [system, ...trimmed];
+    let out = messages;
+    // 1) Message-count cap
+    if (out.length > MAX_MESSAGES) {
+        const system = out[0].role === "system" ? out[0] : null;
+        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) > MAX_HISTORY_TOKENS) {
+        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)];
+    }
+    // 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);
     }
-    return trimmed;
+    return out;
 }
 /**
  * Strict heuristic: does the assistant's plain-text message claim the task is
@@ -23,13 +74,16 @@ export function trimHistory(messages) {
  * completion phrase instead.
  */
 export function claimsCompletion(text) {
-    return /\b(?:task\s+(?:is\s+)?(?:now\s+)?(?:complete[d]?|done|finished)|all\s+(?:done|finished)|work\s+is\s+(?:now\s+)?(?:complete[d]?|done|finished)|tests?\s+(?:all\s+)?pass(?:ed|ing)?\s*[-—]\s*(?:task|everything)\s+complete[d]?)\b/i.test(text);
+    const english = /\b(?:task\s+(?:is\s+)?(?:now\s+)?(?:complete[d]?|done|finished)|all\s+(?:done|finished)|work\s+is\s+(?:now\s+)?(?:complete[d]?|done|finished)|tests?\s+(?:all\s+)?pass(?:ed|ing)?\s*[-—]\s*(?:task|everything)\s+complete[d]?)\b/i.test(text);
+    // Vietnamese completion claims — same narrow spirit: explicit phrases, not
+    // bare words ("xong" alone appears in "chưa xong" and must NOT match).
+    const vietnamese = /(?:nhiệm\s?vụ|công\s?việc|task|việc)\s+(?:đã\s+)?(?:hoàn\s?thành|xong\s?hoàn\s?toàn|đã\s+xong)|(?:hoàn\s?thành|xong)\s+(?:tất\s+cả|toàn\s+bộ)|đã\s+(?:sửa|xử\s+lý|fix)\s+xong\b/i.test(text);
+    return english || vietnamese;
 }
 /**
  * Summarize a long output to keep context lean.
  * For very long tool outputs, keep beginning + error lines + end.
- */
-export function summariseOutput(output, maxChars = 4000) {
+ */ export function summariseOutput(output, maxChars = 4000) {
     if (output.length <= maxChars)
         return output;
     const lines = output.split("\n");
@@ -42,3 +96,54 @@ export function summariseOutput(output, maxChars = 4000) {
         lines.slice(-keepEnd).join("\n");
     return snippet.slice(0, maxChars) + "\n... [truncated]";
 }
+/** @mention trong task: `@path` hoặc `@"path có space"` — không match email. */
+const MENTION_RE = /(?:^|[\s(])@(?:"([^"]+)"|([^\s()'"`,:]+))/g;
+const MAX_MENTION_CHARS = 60_000;
+/**
+ * Expand `@file` mentions trong task thành nội dung file (giống Claude Code):
+ * `fix @src/a.ts` → task + block nội dung file. Path được đọc relative workdir;
+ * mention không tồn tại giữ nguyên text (LLM tự nhận ra path sai).
+ */
+export function expandMentions(task, workdir) {
+    if (!task.includes("@"))
+        return task;
+    const mentions = [];
+    for (const m of task.matchAll(MENTION_RE)) {
+        const path = (m[1] ?? m[2] ?? "").trim();
+        if (path)
+            mentions.push({ token: m[0].trimStart(), path });
+    }
+    if (mentions.length === 0)
+        return task;
+    let out = task;
+    const blocks = [];
+    for (const { token, path } of mentions) {
+        // Chỉ remove token đầu tiên khớp (đề phòng path trùng lặp).
+        const idx = out.indexOf(token);
+        if (idx >= 0)
+            out = (out.slice(0, idx) + " " + out.slice(idx + token.length)).replace(/ {2,}/g, " ");
+        const abs = resolve(workdir, path);
+        if (!abs.startsWith(resolve(workdir))) {
+            blocks.push(`@${path}: path escapes working directory — skipped.`);
+            continue;
+        }
+        try {
+            const st = statSync(abs);
+            if (st.isDirectory()) {
+                // Directory mention → list file bên trong (depth 1).
+                const entries = readdirSync(abs).slice(0, 100);
+                blocks.push(`@${path}/ (directory):\n${entries.join("\n")}`);
+                continue;
+            }
+            if (st.size > MAX_MENTION_CHARS) {
+                blocks.push(`@${path}: too large (${(st.size / 1024).toFixed(0)}KB) — use read_file for it.`);
+                continue;
+            }
+            blocks.push(`@${path}:\n${readFileSync(abs, "utf8").slice(0, MAX_MENTION_CHARS)}`);
+        }
+        catch (err) {
+            blocks.push(`@${path}: not found (${err.message.split("\n")[0]})`);
+        }
+    }
+    return `${out.trim()}\n\n${blocks.join("\n\n")}`;
+}

package/dist/cost.js

@@ -92,6 +92,38 @@ export function loadSessionUsage(workdir, sessionId) {
     const events = readJsonlLog(path);
     return events ? extractUsageEvents(sessionId, events) : [];
 }
+const EMPTY_METRICS = {
+    stepCount: 0,
+    stepLatencyTotalMs: 0,
+    stepLatencyMaxMs: 0,
+    toolCallCount: 0,
+    guardrailCount: 0,
+    success: null,
+};
+/** Trích metrics hiệu năng từ raw JSONL events của một session. */
+export function extractSessionMetrics(events) {
+    const m = { ...EMPTY_METRICS };
+    for (const ev of events) {
+        const num = (v) => (typeof v === "number" && Number.isFinite(v) ? v : 0);
+        switch (ev.type) {
+            case "step":
+                m.stepCount += 1;
+                m.stepLatencyTotalMs += num(ev.durationMs);
+                m.stepLatencyMaxMs = Math.max(m.stepLatencyMaxMs, num(ev.durationMs));
+                break;
+            case "tool":
+                m.toolCallCount += 1;
+                break;
+            case "guardrail":
+                m.guardrailCount += 1;
+                break;
+            case "finish":
+                m.success = ev.success === true;
+                break;
+        }
+    }
+    return m;
+}
 /**
  * Collect usage for a selection of sessions:
  *  - explicit id    -> that session
@@ -110,10 +142,14 @@ export function collectUsage(workdir, opts = {}) {
     else {
         ids = listLogSessions(workdir);
     }
-    return ids.map((id) => ({
-        sessionId: id,
-        aggregate: aggregateUsage(loadSessionUsage(workdir, id), opts.pricingOverrides),
-    }));
+    return ids.map((id) => {
+        const events = readJsonlLog(resolve(workdir, ".scoder/logs", `${id}.jsonl`)) ?? [];
+        return {
+            sessionId: id,
+            aggregate: aggregateUsage(extractUsageEvents(id, events), opts.pricingOverrides),
+            metrics: extractSessionMetrics(events),
+        };
+    });
 }
 /** Render a human-readable cost report (also used by tests to assert output). */
 export function formatCostReport(sessionCosts) {
@@ -122,17 +158,31 @@ export function formatCostReport(sessionCosts) {
     }
     const grand = { calls: 0, inputTokens: 0, outputTokens: 0, cachedTokens: 0, costUsd: 0 };
     const lines = ["COST REPORT"];
+    let successes = 0;
+    let finished = 0;
     for (const sc of sessionCosts) {
         const a = sc.aggregate;
+        const mx = sc.metrics;
         grand.calls += a.calls;
         grand.inputTokens += a.inputTokens;
         grand.outputTokens += a.outputTokens;
         grand.cachedTokens += a.cachedTokens;
         grand.costUsd += a.costUsd;
-        lines.push(`  ${sc.sessionId}  calls=${a.calls}  in=${a.inputTokens.toLocaleString("en-US")}  out=${a.outputTokens.toLocaleString("en-US")}  cached=${a.cachedTokens.toLocaleString("en-US")}  cost≈$${a.costUsd.toFixed(4)}`);
+        if (mx.success !== null) {
+            finished += 1;
+            if (mx.success)
+                successes += 1;
+        }
+        const avgS = mx.stepCount > 0 ? (mx.stepLatencyTotalMs / mx.stepCount / 1000).toFixed(1) : null;
+        lines.push(`  ${sc.sessionId}  calls=${a.calls}  in=${a.inputTokens.toLocaleString("en-US")}  out=${a.outputTokens.toLocaleString("en-US")}  cached=${a.cachedTokens.toLocaleString("en-US")}  cost≈$${a.costUsd.toFixed(4)}` +
+            (mx.stepCount > 0
+                ? `  |  steps=${mx.stepCount}${avgS ? ` llm-avg=${avgS}s` : ""} tools=${mx.toolCallCount} guardrails=${mx.guardrailCount}` +
+                    (mx.success !== null ? ` ${mx.success ? "✓success" : "✗failed"}` : "")
+                : ""));
     }
     grand.costUsd = Math.round(grand.costUsd * 10_000) / 10_000;
-    lines.push(`TOTAL (${sessionCosts.length} session(s))  calls=${grand.calls}  in=${grand.inputTokens.toLocaleString("en-US")}  out=${grand.outputTokens.toLocaleString("en-US")}  cached=${grand.cachedTokens.toLocaleString("en-US")}  cost≈$${grand.costUsd.toFixed(4)}`);
+    lines.push(`TOTAL (${sessionCosts.length} session(s))  calls=${grand.calls}  in=${grand.inputTokens.toLocaleString("en-US")}  out=${grand.outputTokens.toLocaleString("en-US")}  cached=${grand.cachedTokens.toLocaleString("en-US")}  cost≈$${grand.costUsd.toFixed(4)}` +
+        (finished > 0 ? `  |  success-rate=${successes}/${finished}` : ""));
     return lines.join("\n");
 }
 /** Join a path under the workdir's log dir (exported for tests). */