s-app-scoder-agent 0.8.21 → 0.9.2

package/dist/agents-guide.js

@@ -0,0 +1,201 @@
+/**
+ * v2 (3.2): AGENTS.md hierarchy — project/global conventions injected into
+ * the system prompt instead of being rediscovered every run.
+ *
+ * Sources (in order of increasing specificity):
+ *   1. ~/.scoder/AGENTS.md        — user-global conventions
+ *   2. <workdir>/AGENTS.md        — repo root conventions
+ *   3. <dir>/AGENTS.md            — nearest file walking up from each focus
+ *      file mentioned in the task (e.g. src/tui/app.tsx → src/tui/, src/, root)
+ *
+ * Budgets: global + root ≤ 1200 chars each, nested ≤ 800 chars each,
+ * total block ≤ 4000 chars. Content is wrapped in a clearly-delimited block
+ * and marked "(project conventions — apply unless the task says otherwise)".
+ */
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join, normalize, relative, resolve, sep } from "node:path";
+const GLOBAL_BUDGET = 1200;
+const ROOT_BUDGET = 1200;
+const NESTED_BUDGET = 800;
+const TOTAL_BUDGET = 4000;
+function readBudget(file, budget) {
+    try {
+        const st = statSync(file);
+        if (!st.isFile())
+            return null;
+        const raw = readFileSync(file, "utf8").trim();
+        if (!raw)
+            return null;
+        return raw.length <= budget ? raw : `${raw.slice(0, budget)}\n… [truncated — ${raw.length - budget} more chars]`;
+    }
+    catch {
+        return null;
+    }
+}
+const ROOT_NAMES = ["AGENTS.md", "AGENTS.local.md"];
+function rootGuide(workdir) {
+    const out = [];
+    const globalFile = join(homedir(), ".scoder", "AGENTS.md");
+    const global = readBudget(globalFile, GLOBAL_BUDGET);
+    if (global)
+        out.push({ source: globalFile, content: global });
+    for (const name of ROOT_NAMES) {
+        const f = join(workdir, name);
+        const content = readBudget(f, ROOT_BUDGET);
+        if (content) {
+            out.push({ source: f, content });
+            break;
+        }
+    }
+    return out;
+}
+/** Nearest AGENTS.md at or above `focusFile`, stopping at workdir root. */
+function nearestGuide(workdir, focusFile) {
+    let dir = dirname(resolve(workdir, focusFile));
+    const rootAbs = resolve(workdir);
+    for (;;) {
+        const root = normalize(rootAbs);
+        const current = normalize(dir);
+        if (current !== root && !current.startsWith(`${root}${sep}`))
+            return null;
+        for (const name of ROOT_NAMES) {
+            const f = join(dir, name);
+            const content = readBudget(f, NESTED_BUDGET);
+            if (content)
+                return { source: f, content };
+        }
+        if (normalize(dir) === normalize(rootAbs))
+            return null;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+/** Extract path-like tokens from a task description (relative file mentions). */
+export function extractFocusFiles(task, workdir) {
+    const FILE_EXTS = new Set([
+        "ts", "tsx", "js", "jsx", "mjs", "cjs", "py", "go", "rs", "java", "rb", "php", "cs",
+        "json", "yaml", "yml", "toml", "md", "sql", "sh", "css", "scss", "vue", "svelte", "html",
+    ]);
+    const out = new Set();
+    const rx = /(?:\.\.?\/|[\w-]+\/)*[\w-]+\.[A-Za-z][\w]{0,9}/g;
+    for (const m of task.matchAll(rx)) {
+        const p = m[0];
+        const ext = p.slice(p.lastIndexOf(".") + 1).toLowerCase();
+        if (!FILE_EXTS.has(ext))
+            continue;
+        if (/^https?:/i.test(p))
+            continue;
+        const abs = resolve(workdir, p);
+        const rel = relative(workdir, abs);
+        if (rel.startsWith("..") || /^[a-zA-Z]:/.test(rel))
+            continue;
+        if (existsSync(abs))
+            out.add(rel.split(sep).join("/"));
+        if (out.size >= 5)
+            break;
+    }
+    return [...out];
+}
+/**
+ * Collect the AGENTS.md chain for a task. `focusFiles` are relative paths
+ * (typically extracted via extractFocusFiles). Order: global → root → nearest
+ * nested (deduped by source). Total size capped at TOTAL_BUDGET.
+ */
+export function collectAgentGuides(workdir, focusFiles = []) {
+    const guides = [];
+    const seen = new Set();
+    const push = (g) => {
+        if (seen.has(g.source))
+            return false;
+        seen.add(g.source);
+        guides.push(g);
+        return true;
+    };
+    for (const g of rootGuide(workdir))
+        push(g);
+    for (const f of focusFiles) {
+        const g = nearestGuide(workdir, f);
+        if (g)
+            push(g);
+    }
+    // Total budget cap — drop the oldest (least specific) first.
+    let total = guides.reduce((n, g) => n + g.content.length, 0);
+    while (guides.length > 1 && total > TOTAL_BUDGET) {
+        const dropped = guides.shift();
+        if (!dropped)
+            break;
+        total -= dropped.content.length;
+    }
+    return guides;
+}
+/**
+ * Template written by /init — AGENTS.md starter. Detects project identity and
+ * build/test commands from common manifest files; falls back to placeholders.
+ */
+export function agentsMdTemplate(workdir) {
+    let name = basename(workdir);
+    let build = "npm run build";
+    let test = "npm test";
+    try {
+        const pkg = JSON.parse(readFileSync(join(workdir, "package.json"), "utf8"));
+        if (pkg.name)
+            name = pkg.name;
+        if (pkg.scripts?.build)
+            build = "npm run build";
+        if (pkg.scripts?.test)
+            test = "npm test";
+    }
+    catch {
+        // not a node project — keep generic placeholders
+        if (existsSync(join(workdir, "go.mod"))) {
+            build = "go build ./...";
+            test = "go test ./...";
+        }
+        else if (existsSync(join(workdir, "Cargo.toml"))) {
+            build = "cargo build";
+            test = "cargo test";
+        }
+        else if (existsSync(join(workdir, "pyproject.toml"))) {
+            build = "python -m compileall .";
+            test = "pytest";
+        }
+        else if (existsSync(join(workdir, "Makefile"))) {
+            build = "make";
+            test = "make test";
+        }
+    }
+    return `# ${name} — AGENTS.md
+
+Conventions for AI coding agents working in this repository. Keep this file
+accurate: update it when the build, tests, or architecture change.
+
+## Project overview
+<!-- One paragraph: what this project is, its main stack, and its layout. -->
+
+## Commands
+- Build: \`${build}\`
+- Test: \`${test}\`
+- Lint / typecheck: <!-- e.g. npm run lint && npm run typecheck -->
+
+## Architecture map
+<!-- Where the important things live: entry points, modules, data flow. -->
+
+## Conventions
+<!-- Code style, error-handling patterns, naming, test style, commit style. -->
+
+## Guardrails
+<!-- What agents must never do here (generated files, migrations, secrets…). -->
+`;
+}
+/** Format the AGENTS.md block for the system prompt ("" when nothing found). */
+export function buildAgentGuideBlock(workdir, task) {
+    const guides = collectAgentGuides(workdir, extractFocusFiles(task, workdir));
+    if (guides.length === 0)
+        return "";
+    const parts = guides.map((g) => `--- ${relative(workdir, g.source).split(sep).join("/") || g.source} ---\n${g.content}`);
+    return (`\n\nAGENTS.md (project conventions — apply unless the task explicitly says otherwise):\n` +
+        parts.join("\n\n"));
+}

package/dist/agents.js

@@ -1,14 +1,29 @@
 /**
- * Agents (I-06) — .scoder/agents/<name>.md definitions + built-ins.
+ * Agents (I-06 + v2 profiles) — .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.
+ * (primary|subagent|all), model override, steps, prompt body — plus v2:
+ * tool whitelist, permission mode, temperature, reasoning, maxTokens,
+ * skills pre-staging, color.
  */
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { parseFrontmatter } from "./skills.js";
+/** Read-only tools an agent may use — mutating specs are filtered out. */
+export const READ_ONLY_TOOL_SPECS = [
+    "read_file",
+    "list_files",
+    "grep",
+    "glob",
+    "repo_map",
+    "web_fetch",
+    "load_skill",
+    "write_todos",
+];
+/** Specs a readonly primary/subagent never sees (defense in depth vs permission alone). */
+export const MUTATING_TOOL_SPECS = ["write_file", "edit_file", "apply_patch", "run_command"];
 /** Built-in agents — lowest priority; .md files override by name. */
 export const BUILTIN_AGENTS = [
     {
@@ -22,14 +37,41 @@ export const BUILTIN_AGENTS = [
         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.",
+        permission: "readonly",
+        tools: READ_ONLY_TOOL_SPECS,
+        reasoning: "on",
     },
     {
         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.",
+        permission: "readonly",
+        tools: READ_ONLY_TOOL_SPECS,
+    },
+    {
+        name: "review",
+        description: "Code reviewer — reviews diffs for correctness, security and style. Never edits.",
+        mode: "all",
+        prompt: "You are a code review agent. Review the requested diff or files for correctness bugs, security issues, and violations of the project's conventions. Use read-only tools only. Report findings as a ranked list: [blocking] / [important] / [nit] with file:line citations and a concrete fix for each. End with an overall verdict: APPROVE / REQUEST CHANGES / NEEDS DISCUSSION. Do NOT modify any files.",
+        permission: "readonly",
+        tools: READ_ONLY_TOOL_SPECS,
     },
 ];
+const parsePermissions = (v) => v === "auto" || v === "ask" || v === "readonly" ? v : undefined;
+const parseReasoning = (v) => v === "off" || v === "on" ? v : undefined;
+const parseList = (v) => {
+    if (!v)
+        return undefined;
+    const out = (Array.isArray(v) ? v : v.split(",")).map((s) => String(s).trim()).filter(Boolean);
+    return out.length > 0 ? out : undefined;
+};
+const parseNumber = (v) => {
+    if (v === undefined)
+        return undefined;
+    const n = Number(v);
+    return Number.isFinite(n) ? n : undefined;
+};
 /** Scan .scoder/agents/*.md (project) + ~/.scoder/agents/*.md (global). */
 export function discoverAgents(workdir) {
     const out = new Map();
@@ -51,10 +93,18 @@ export function discoverAgents(workdir) {
                     description: meta.description ?? "",
                     mode: mode,
                     model: meta.model || undefined,
-                    steps: meta.steps ? Number(meta.steps) || undefined : undefined,
+                    steps: parseNumber(meta.steps),
                     prompt: body,
                     hidden: meta.hidden === "true",
                     disabled: meta.disabled === "true",
+                    tools: parseList(meta.tools),
+                    permission: parsePermissions(meta.permission),
+                    temperature: parseNumber(meta.temperature),
+                    reasoning: parseReasoning(meta.reasoning),
+                    // frontmatter keys are lowercased by parseFrontmatter
+                    maxTokens: parseNumber(meta.maxtokens),
+                    skills: parseList(meta.skills),
+                    color: meta.color || undefined,
                 });
             }
             catch {
@@ -68,3 +118,26 @@ export function discoverAgents(workdir) {
 export function findAgent(workdir, name) {
     return discoverAgents(workdir).find((a) => a.name === name) ?? null;
 }
+/** Primary agents user-selectable via --agent / /agent (mode primary|all). */
+export function selectableAgents(workdir) {
+    return discoverAgents(workdir).filter((a) => a.mode !== "subagent" && !a.hidden);
+}
+/**
+ * v2: filter a tool list for an agent def.
+ *  - def.tools set → whitelist (unknown names dropped, reported by caller);
+ *  - def.permission "readonly" → drop mutating specs (defense in depth);
+ *  - otherwise the list is unchanged.
+ */
+export function filterToolNamesForDef(names, def) {
+    if (!def)
+        return names;
+    if (def.tools && def.tools.length > 0) {
+        const allow = new Set(def.tools.map((t) => t.toLowerCase()));
+        return names.filter((n) => allow.has(n.toLowerCase()));
+    }
+    if (def.permission === "readonly") {
+        const blocked = new Set(MUTATING_TOOL_SPECS);
+        return names.filter((n) => !blocked.has(n.toLowerCase()));
+    }
+    return names;
+}

package/dist/compaction.js

@@ -79,11 +79,16 @@ export function extractSummaryInput(task, messages) {
         lines.push(`Files modified: ${[...files].join(", ")}`);
     return lines.join("\n");
 }
-/** Message sent to the summarizer LLM. */
+/** Message sent to the summarizer LLM (v2: structured template, not prose). */
 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.";
+    "Use a STRUCTURED template with exactly these sections (skip a section only if empty):\n" +
+    "GOAL: one line — the original task.\n" +
+    "STATE: what is done and what is not (build/test status).\n" +
+    "CHANGED: files created/modified and why.\n" +
+    "DECISIONS: decisions made and their rationale (keep every decision).\n" +
+    "FAILURES: errors hit and what did NOT work (so they are not repeated).\n" +
+    "NEXT: the exact next steps, in order.\n" +
+    "Be factual and terse — max 400 words. Preserve file paths, commands and error codes verbatim.";
 /** Build the post-compaction message list. */
 export function applyCompaction(messages, summary, cfg) {
     const cut = findCutIndex(messages, cfg);
@@ -104,6 +109,9 @@ export function applyCompaction(messages, summary, cfg) {
                     arguments: tc.arguments.length > 120 ? tc.arguments.slice(0, 120) + "…" : tc.arguments,
                 })),
             });
+            for (const tc of m.tool_calls) {
+                skeletons.push({ role: "tool", tool_call_id: tc.id, content: "[compacted — tool result omitted]" });
+            }
         }
     }
     const summaryMsg = {

package/dist/config.js

@@ -53,6 +53,9 @@ function mergeRc(global, project) {
     if (global.mcpServers || project.mcpServers) {
         merged.mcpServers = { ...global.mcpServers, ...project.mcpServers };
     }
+    if (global.routing || project.routing) {
+        merged.routing = { ...global.routing, ...project.routing };
+    }
     if (global.modelPricing || project.modelPricing) {
         merged.modelPricing = { ...global.modelPricing, ...project.modelPricing };
     }
@@ -66,6 +69,7 @@ function mergeRc(global, project) {
             mode: project.permissions?.mode ?? global.permissions?.mode,
             allowCommands: concat(global.permissions?.allowCommands, project.permissions?.allowCommands),
             denyCommands: concat(global.permissions?.denyCommands, project.permissions?.denyCommands),
+            rules: concat(global.permissions?.rules, project.permissions?.rules),
         };
     }
     return merged;
@@ -176,7 +180,7 @@ export function loadConfig(overrides = {}) {
             process.env.OPENAI_API_KEY ??
             rc.apiKey ??
             "",
-        model: overrides.model ?? process.env.SCODER_MODEL ?? process.env.OPENAI_MODEL ?? rc.model ?? (modelFromSlash || (isAnthropic ? ANTHROPIC_DEFAULT_MODEL : DEFAULT_MODEL)),
+        model: modelFromSlash || (overrides.model ?? process.env.SCODER_MODEL ?? process.env.OPENAI_MODEL ?? rc.model ?? (isAnthropic ? ANTHROPIC_DEFAULT_MODEL : DEFAULT_MODEL)),
         providerDef,
         contextWindow: providerDef?.contextWindow,
         workdir,
@@ -208,6 +212,12 @@ export function loadConfig(overrides = {}) {
         sandbox: rc.sandbox,
         limits: parseLimits(rc.limits),
         snapshots: rc.snapshots,
+        agent: overrides.agent ?? process.env.SCODER_AGENT ?? rc.agent,
+        routing: rc.routing,
+        repoMap: rc.repoMap,
+        promptVersion: rc.promptVersion,
+        verifyCmds: rc.verifyCmds,
+        selfReview: rc.selfReview,
         modelPricing: parsePricing(rc.modelPricing),
     };
     // Secrets hygiene: warn if apiKey is set in the rc file (risk of accidental commit)
@@ -266,7 +276,11 @@ export function loadSavedApprovals(workdir) {
     if (!existsSync(p))
         return [];
     try {
-        return parsePermissionRules(JSON.parse(readFileSync(p, "utf8")), p) ?? [];
+        const raw = JSON.parse(readFileSync(p, "utf8"));
+        const rules = raw && typeof raw === "object" && !Array.isArray(raw) && "rules" in raw
+            ? raw.rules
+            : raw;
+        return parsePermissionRules(rules, p) ?? [];
     }
     catch {
         return [];

package/dist/context.js

@@ -1,6 +1,6 @@
 import { encode } from "gpt-tokenizer";
-import { readFileSync, readdirSync, statSync } from "node:fs";
-import { resolve } from "node:path";
+import { readFileSync, readdirSync, statSync, realpathSync } from "node:fs";
+import { resolve, relative, isAbsolute } from "node:path";
 const MAX_MESSAGES = 120; // keep history under control for long runs
 /**
  * Default history token budget when compaction is disabled (I-10:
@@ -137,7 +137,19 @@ export function expandMentions(task, workdir) {
         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))) {
+        const root = resolve(workdir);
+        const lexical = relative(root, abs);
+        let contained = !lexical.startsWith("..") && !isAbsolute(lexical);
+        try {
+            const realRoot = realpathSync(root);
+            const realAbs = realpathSync(abs);
+            const realRel = relative(realRoot, realAbs);
+            contained = contained && !realRel.startsWith("..") && !isAbsolute(realRel);
+        }
+        catch {
+            // Missing paths are retained as a diagnostic; existing paths are checked above.
+        }
+        if (!contained) {
             blocks.push(`@${path}: path escapes working directory — skipped.`);
             continue;
         }

package/dist/diagnostics.js

@@ -0,0 +1,188 @@
+/**
+ * v2 (3.5): Diagnostics — turn raw build/test/lint logs into structured
+ * {file, line, severity, code, message} records, plus an error classifier
+ * that maps a failure to a recovery strategy for the agent.
+ *
+ * Supported: tsc (both formats), eslint stylish/compact, pytest (tracebacks +
+ * FAILED lines), go test, cargo, make. Unknown formats fall back to a generic
+ * "error-ish line with a file(:line)? prefix" pattern. Output is deduplicated
+ * and capped (30 diagnostics) so the agent gets a fixable list, not a log.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+const MAX_DIAGNOSTICS = 30;
+function add(out, seen, d) {
+    const key = `${d.file}:${d.line}:${d.code}:${d.message.slice(0, 80)}`;
+    if (seen.has(key))
+        return;
+    seen.add(key);
+    if (out.length < MAX_DIAGNOSTICS)
+        out.push(d);
+}
+/** Parse a command output into structured diagnostics (best-effort). */
+export function parseDiagnostics(output) {
+    const out = [];
+    const seen = new Set();
+    let currentFile = null;
+    let pendingCargo = null;
+    for (const rawLine of output.split("\n")) {
+        const line = rawLine.trimEnd();
+        let m;
+        // ── cargo (real output): error line, then "  --> file:line" on the NEXT line.
+        if (pendingCargo) {
+            m = /^\s*-->\s+([^\s:]+):(\d+)(?::\d+)?$/.exec(line);
+            if (m) {
+                add(out, seen, { file: m[1], line: Number(m[2]), severity: "error", code: pendingCargo.code, message: pendingCargo.message, source: "cargo" });
+                pendingCargo = null;
+                continue;
+            }
+            pendingCargo = null; // the error had no location line — drop it
+        }
+        // ── tsc (modern): src/foo.ts(12,5): error TS2322: message
+        m = /^([^\s()][^()]*)\((\d+),(\d+)\):\s*(error|warning)\s+(TS\d+):\s*(.+)$/.exec(line);
+        if (m) {
+            add(out, seen, { file: m[1], line: Number(m[2]), severity: m[4] === "warning" ? "warning" : "error", code: m[5], message: m[6].trim(), source: "tsc" });
+            continue;
+        }
+        // ── tsc (new style): src/foo.ts:12:5 - error TS2322: message
+        m = /^([^\s:][^:]*):(\d+):(\d+)\s+-\s+(error|warning)\s+(TS\d+):\s*(.+)$/.exec(line);
+        if (m) {
+            add(out, seen, { file: m[1], line: Number(m[2]), severity: m[4] === "warning" ? "warning" : "error", code: m[5], message: m[6].trim(), source: "tsc" });
+            continue;
+        }
+        // ── cargo: error[E0308]: msg  --> src/main.rs:10:5
+        m = /^error(?:\[(E\d+)\])?:\s*(.+)\s+-->\s+([^\s:]+):(\d+)(?::\d+)?$/.exec(line);
+        if (m) {
+            add(out, seen, { file: m[3], line: Number(m[4]), severity: "error", code: m[1] ?? null, message: m[2].trim(), source: "cargo" });
+            continue;
+        }
+        // ── cargo (2-line): "error[E0308]: msg" standing alone → expect --> next line.
+        m = /^error(?:\[(E\d+)\])?:\s*(.+)$/.exec(line);
+        if (m) {
+            pendingCargo = { code: m[1] ?? null, message: m[2].trim() };
+            continue;
+        }
+        // ── go vet/test: file.go:123: message   (also covers "# package" headers)
+        m = /^([^\s:][^:()]*(?:\.go|\.py|\.rs|\.ts|\.tsx|\.js|\.mjs)):(\d+):\s+(.+)$/.exec(line);
+        if (m && /error|fail|cannot|undefined|invalid|unexpected|panic/i.test(m[3])) {
+            add(out, seen, { file: m[1], line: Number(m[2]), severity: "error", code: null, message: m[3].trim(), source: "generic" });
+            continue;
+        }
+        // ── eslint stylish: "✖ N problems" ignored; file header then indented rows
+        m = /^\s*(\d+):(\d+)\s+(error|warning)\s+(.+?)\s{2,}([\w-]+)$/.exec(line);
+        if (m && currentFile) {
+            add(out, seen, { file: currentFile, line: Number(m[1]), severity: m[3], code: m[5], message: m[4].trim(), source: "eslint" });
+            continue;
+        }
+        // eslint file header: /abs/path/file.ts  (a bare path on its own line)
+        if (/^([\w./-]+\.(?:ts|tsx|js|jsx|mjs|cjs|vue|svelte))\s*$/.test(line.trim())) {
+            currentFile = line.trim();
+            continue;
+        }
+        // ── pytest: FAILED test_x.py::test_name - assert ...
+        m = /^FAILED\s+([^\s:]+)(?:::[^\s]+)?(?:\s+-\s+(.+))?$/.exec(line);
+        if (m) {
+            add(out, seen, { file: m[1], line: null, severity: "error", code: "FAILED", message: (m[2] ?? "test failed").trim(), source: "pytest" });
+            continue;
+        }
+        // pytest traceback frame: E   AssertionError: ...
+        m = /^E\s+(.+)$/.exec(line);
+        if (m) {
+            add(out, seen, { file: "(pytest)", line: null, severity: "error", code: null, message: m[1].trim().slice(0, 200), source: "pytest" });
+            continue;
+        }
+        // ── go test: --- FAIL: TestName
+        m = /^--- FAIL:\s+([\w/]+)/.exec(line);
+        if (m) {
+            add(out, seen, { file: "(go test)", line: null, severity: "error", code: "FAIL", message: `test failed: ${m[1]}`, source: "go" });
+            continue;
+        }
+        // ── make: make: *** [target] Error 2
+        m = /^make(?:\[\d+\])?: \*\*\* \[([^\]]+)\] Error (\d+)/.exec(line);
+        if (m) {
+            add(out, seen, { file: "Makefile", line: null, severity: "error", code: `make:${m[2]}`, message: `target failed: ${m[1]}`, source: "make" });
+            continue;
+        }
+    }
+    return out;
+}
+/** Compact one-line-per-diagnostic rendering (prompt + UI friendly). */
+export function formatDiagnostics(diags) {
+    if (diags.length === 0)
+        return "";
+    const lines = diags.map((d) => `- ${d.file}${d.line != null ? `:${d.line}` : ""} [${d.severity}${d.code ? ` ${d.code}` : ""}] ${d.message}`);
+    return `Diagnostics (${diags.length}):\n${lines.join("\n")}`;
+}
+/** Classify an error into a recovery strategy for the agent. */
+export function classifyError(text) {
+    const t = text.toLowerCase();
+    const has = (...pats) => pats.some((p) => t.includes(p));
+    if (has("permission denied", "eacces", "denied by policy", "access is denied", "unauthorized", "403")) {
+        return { kind: "permission", strategy: "do NOT retry the same command — use a safer alternative or report the limitation to the user." };
+    }
+    if (has("enotfound", "econnrefused", "etimedout", "network", "fetch failed", "eai_again", "econnreset", "401", "rate limit", "429")) {
+        return { kind: "network", strategy: "check connectivity and credentials first (web_fetch/env), wait or pick another source; do not loop blindly." };
+    }
+    if (has("syntaxerror", "unexpected token", "unexpected end of", "parse error", "unterminated")) {
+        return { kind: "syntax", strategy: "read the file around the indicated line and fix the syntax error directly." };
+    }
+    if (/ts\d{3,5}|type .{0,40}is not assignable|type mismatch|expected type|no compatible/.test(t)) {
+        return { kind: "type", strategy: "read the failing type declaration and the usage site — fix the type, don't cast blindly." };
+    }
+    if (has("assertionerror", "assert failed", "expected", "to equal", "failed assert", "--- fail")) {
+        return { kind: "test", strategy: "read the failing test, understand what it expects, then fix the implementation (or the test only if it is provably wrong)." };
+    }
+    if (has("typeerror", "referenceerror", "rangeerror", "panic", "nil pointer", "null pointer", "segmentation", "enoent")) {
+        return { kind: "runtime", strategy: "read the stack trace, find the failing frame, and fix the root cause." };
+    }
+    return { kind: "unknown", strategy: "read the full error carefully; try a different approach or ask the user." };
+}
+/**
+ * Detect verify commands for the workdir from manifests. rc override via
+ * `verifyCmds` wins (empty string disables one).
+ */
+export function detectVerifyCmds(workdir) {
+    const out = {};
+    try {
+        const pkgPath = join(workdir, "package.json");
+        if (existsSync(pkgPath)) {
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+            const s = pkg.scripts ?? {};
+            if (s.build)
+                out.build = "npm run build";
+            if (s.test)
+                out.test = "npm test";
+            if (s.lint)
+                out.lint = "npm run lint";
+            if (s.typecheck)
+                out.typecheck = "npm run typecheck";
+            else if (s["type-check"])
+                out.typecheck = "npm run type-check";
+        }
+    }
+    catch { /* malformed package.json — fall through */ }
+    try {
+        if (existsSync(join(workdir, "pyproject.toml")))
+            out.test = out.test ?? "pytest";
+        if (existsSync(join(workdir, "Cargo.toml"))) {
+            out.build = out.build ?? "cargo build";
+            out.test = out.test ?? "cargo test";
+        }
+        if (existsSync(join(workdir, "go.mod"))) {
+            out.build = out.build ?? "go build ./...";
+            out.test = out.test ?? "go test ./...";
+        }
+        const makefile = join(workdir, "Makefile");
+        if (existsSync(makefile)) {
+            const mk = readFileSync(makefile, "utf8");
+            if (/^build:/m.test(mk))
+                out.build = out.build ?? "make";
+            if (/^test:/m.test(mk))
+                out.test = out.test ?? "make test";
+            if (/^lint:/m.test(mk))
+                out.lint = out.lint ?? "make lint";
+        }
+    }
+    catch { /* best-effort */ }
+    return out;
+}