s-app-scoder-agent 0.3.0 → 0.5.0

package/README.md

@@ -80,9 +80,22 @@ You (task) → LLM plans → Tools execute code → Build runs → Success? →
 | `edit_file` | Find-and-replace (unique match required) |
 | `list_files` | Recursive directory listing |
 | `run_command` | Execute any shell command (subject to permission policy) |
+| `web_fetch` | Fetch a public HTTP(S) URL → readable text (HTML→text, JSON pretty-printed) |
 
 File writes (`write_file` / `edit_file`) are symlink-safe: paths are resolved via `realpath` and cannot escape the working directory, even through a malicious symlink. `read_file` refuses files larger than 2MB with guidance to use `grep`/`head`/`tail`.
 
+### Web access (`web_fetch`)
+
+The agent can read the internet through the built-in `web_fetch` tool — it fetches exact URLs (it cannot search) and returns readable plain text: HTML is converted to text (scripts/styles stripped, entities decoded, title extracted), JSON is pretty-printed, binary content is refused. The system prompt instructs the agent *when to fetch* (external/API docs, URLs in error messages, current versions, changelogs) and when not to (answer available locally).
+
+Safety defaults:
+
+- **SSRF protection** — `localhost`, private and link-local addresses (10.x, 172.16/12, 192.168.x, 127.x, 169.254.x, IPv6 ULA/link-local) are blocked. Set `SCODER_WEB_ALLOW_PRIVATE=1` to allow local dev servers.
+- Only `http`/`https`; up to 5 redirects — every hop is re-validated against the private-address block list.
+- 30 s timeout, SIGINT-abortable; body capped at 512 KB; extracted text capped at 20k chars (configurable via `max_chars`).
+- HTML is converted to plain text (no JS execution); images/archives/PDFs are refused.
+- Read-only — the tool never writes locally, so it is allowed even in `readonly` permission mode.
+
 ## Configuration
 
 ### Environment variables
@@ -96,6 +109,9 @@ File writes (`write_file` / `edit_file`) are symlink-safe: paths are resolved vi
 | `SCODER_MAX_STEPS` | `40` | Max loop iterations before giving up |
 | `SCODER_PERMISSION` | `auto` | Permission mode: `auto` \| `ask` \| `readonly` |
 | `SCODER_STREAM` | `1` | `0` to disable streaming LLM output |
+| `SCODER_STREAM` | `1` | `0` to disable streaming LLM output |
+| `SCODER_SERVER_TOKEN` | — | `scoder serve` only: require `Authorization: Bearer <token>` |
+| `SCODER_WEB_ALLOW_PRIVATE` | — | Set to `1` to let `web_fetch` reach localhost/private addresses (local dev) |
 | `SCODER_NO_APIKEY_WARNING` | — | Set to `1` to suppress the apiKey-in-rc warning |
 
 ### Per-project config file (.scoderrc.json)
@@ -225,7 +241,39 @@ Sessions older than 7 days are pruned automatically on the next run. Use `--no-s
 
 ## Streaming
 
-LLM output is streamed token-by-token by default (`SCODER_STREAM=0` to disable). If a provider doesn't support streaming, scoder automatically falls back to non-streaming requests.
+scoder streams everything it can, live, as it happens:
+
+- **LLM tokens** — assistant text renders character-by-character (OpenAI-compatible SSE and native Anthropic streaming). If a provider doesn't support streaming, scoder automatically falls back to non-streaming requests. Disable with `SCODER_STREAM=0`.
+- **Tool output** — `run_command` and build output print live (dimmed block) while the command runs, instead of appearing only after it finishes. Live output is capped at 20k chars; the full output still goes to the LLM.
+- **SIGINT-safe** — Ctrl+C kills the running command immediately; streamed rendering never blocks the event loop.
+- Output honors `NO_COLOR` and degrades to plain text when piped (CI-friendly).
+
+## HTTP Server Mode (`scoder serve`)
+
+Run scoder as a local HTTP service — submit tasks programmatically and consume progress as Server-Sent Events:
+
+```bash
+scoder serve                    # http://127.0.0.1:0 (random port, printed at startup)
+scoder serve --port 4114        # fixed port
+SCODER_SERVER_TOKEN=secret scoder serve --host 127.0.0.1
+```
+
+| Endpoint | Method | Description |
+|----------|--------|-------------|
+| `/api/health` | GET | Liveness: `{ ok, running, runs }` |
+| `/api/runs` | POST | Start a run: `{ "task": "...", "workdir?", "buildCmd?", "model?", "provider?", "maxSteps?", "permission?" }` → `202 { id, eventsUrl }` |
+| `/api/runs` | GET | List runs with status/timing |
+| `/api/runs/<id>` | GET | Run status + final result |
+| `/api/runs/<id>/events` | GET | **SSE stream** — full event replay, then live, closes on finish |
+| `/api/runs/<id>/abort` | POST | Abort a running run (equivalent to SIGINT) |
+
+SSE event types: `run_start`, `step`, `llm_delta` (assistant text), `tool_call`, `tool_output` (live stdout/stderr chunks), `tool_result`, `llm_usage`, `build`, `finish`. The stream replays every event from the beginning, then stays live, and closes after `finish` — safe to (re)connect at any time.
+
+Notes:
+
+- Runs are always non-interactive; `permission: "ask"` is rejected — use `auto` or `readonly`.
+- Binds `127.0.0.1` by default. Set `SCODER_SERVER_TOKEN` to require `Authorization: Bearer <token>` on every request.
+- Max 4 concurrent runs (extra requests get `429`); per-run overrides: `workdir`, `buildCmd`, `model`, `provider`, `maxSteps`, `permission`.
 
 ## Logging
 
@@ -268,6 +316,7 @@ scoder detects the build command automatically:
 ```
 scoder [options] "<task>"     Run a task autonomously until the build passes
 scoder                       Start interactive session
+scoder serve [--port] [--host]   HTTP server mode (see above)
 scoder --help | --version     Help and version
 ```
 
@@ -283,6 +332,9 @@ scoder --help | --version     Help and version
 | `-y` | Non-interactive mode (denies commands needing confirmation) |
 | `--provider <name>` | `openai` \| `anthropic` (env SCODER_PROVIDER; auto-detected) |
 | `--no-save` | Disable session auto-save to `.scoder/sessions/` |
+| `--log-file` | Write a structured JSONL event log to `.scoder/logs/` |
+| `--port <n>` | (`serve`) TCP port, `0` = random free port |
+| `--host <addr>` | (`serve`) Bind address (default `127.0.0.1`) |
 
 ## Examples
 
@@ -305,6 +357,15 @@ scoder -m claude-sonnet-4-5 "refactor the parser module"
 
 # CI: non-interactive, no session saving
 scoder --no-save -y "run the full migration"
+
+# Run as an HTTP service and consume progress via SSE
+scoder serve --port 4114 &
+curl -s -X POST localhost:4114/api/runs -H 'Content-Type: application/json' \
+  -d '{"task": "add input validation to the CLI"}'
+curl -N http://127.0.0.1:4114/api/runs/<id>/events     # live progress
+
+# Fetch external docs during a task (agent decides when, via web_fetch)
+scoder "upgrade express to v5 — check the official migration guide first"
 ```
 
 ## Architecture
@@ -312,22 +373,26 @@ scoder --no-save -y "run the full migration"
 ```
 ┌─────────────────────────────────────────────┐
 │  CLI (src/index.ts)                         │
-│   arg parsing, REPL, SIGINT handling        │
-└─────────────────┬───────────────────────────┘
-                  │
-┌─────────────────▼───────────────────────────┐
+│   arg parsing, REPL, serve, SIGINT          │
+└───────────────┬─────────────────────────────┘
+                │
+┌───────────────▼─────────────────────────────┐
 │  Agent (src/agent.ts)                       │
-│   Closed-loop orchestrator                  │
-│   history trimming, error injection         │
-└───────┬───────────────────────┬─────────────┘
-        │                       │
-┌───────▼───────┐    ┌─────────▼──────────┐
-│  LLM Client   │    │  Tool Registry       │
-│ (src/llm.ts)  │    │ (src/tools.ts)       │
-│ OpenAI compat │    │ read/write/run/list │
-└───────────────┘    └──────────────────────┘
-        │
-        ▼
+│  Closed-loop orchestrator                   │
+│  history trimming, error injection          │
+│  emits AgentEvent (UI / SSE consumers)      │
+└──────┬─────────────┬───────────────┬────────┘
+       │             │               │
+┌──────▼───────┐  ┌──▼───────────┐  ┌▼──────────────────┐
+│  LLM Client  │  │ Tool Registry│  │ Server            │
+│ (src/llm.ts) │  │(src/tools.ts)│  │ (src/server.ts)   │
+│ OpenAI compat│  │ + web_fetch  │  │ HTTP API + SSE    │
+│ (anthropic:  │  │ (src/        │  │ runs in background│
+│  provider-   │  │  webfetch.ts)│  └───────────────────┘
+│  anthropic)  │  └──────────────┘
+└──────────────┘
+       │
+       ▼
 ┌─────────────────────────────────────────────┐
 │  Build Checker (src/build.ts)               │
 │   run build → exit 0 = stop condition met   │
@@ -337,7 +402,7 @@ scoder --no-save -y "run the full migration"
 ## Integration Testing
 
 ```bash
-npm test          # runs: lint → typecheck → build → 116 unit tests + e2e + MCP smoke
+npm test          # runs: build → unit tests (node --test) → e2e closed-loop → MCP smoke
 npm run lint      # eslint flat config (typescript-eslint + eqeqeq, prefer-const...)
 npm run typecheck # tsc --noEmit
 ```
@@ -345,17 +410,18 @@ npm run typecheck # tsc --noEmit
 Test suites (run with `npm test` — auto-discovers `test/*.test.mjs`):
 - `test/permissions.test.mjs` — catastrophic patterns, mode classification, allowlist word-boundary, timeout-denies
 - `test/permission-prompt.test.mjs` — interactive prompt timeout behavior
-- `test/tools.test.mjs` — safePath traversal, symlink escape, file-size cap, write/edit/list
+- `test/tools.test.mjs` — safePath traversal, symlink escape, file-size cap, write/edit/list, live `run_command` output streaming
+- `test/webfetch.test.mjs` — HTML→text, JSON, redirects, SSRF guard, binary refusal, truncation
+- `test/server.test.mjs` — HTTP API: run lifecycle via SSE, abort, auth, live `tool_output` events
 - `test/core.test.mjs` — unified diff, retry backoff, context trimming
 - `test/config.test.mjs` — env/rc/cli precedence, logFile mapping, permission lists
 - `test/session.test.mjs` — session store, smart prune, resolve
+- `test/cost.test.mjs` — token usage & cost aggregation
 - `test/anthropic.test.mjs` — message translation + native SSE streaming
 - `test/llm.test.mjs` — OpenAI-compatible chat + SSE streaming + redaction
 - `test/run-e2e.mjs` — closed-loop integration (mock LLM server)
 - `test/run-mcp-test.mjs` — MCP smoke (mock stdio server)
 
-Coverage (lines): **90.3%** overall — see `npm run coverage`.
-
 ## Exit Codes
 
 | Code | Meaning |

package/dist/agent.js

@@ -28,7 +28,13 @@ RULES:
 6. Never invent requirements beyond the given task.
 7. IMPORTANT: if a run_command is denied by permission policy, you will receive
    an error message. Use this as a signal to find a safer alternative or to
-   communicate the limitation to the user.`;
+   communicate the limitation to the user.
+8. You have web access ONLY through web_fetch (it fetches exact URLs, it cannot
+   search). Use it when the task depends on external or fast-changing knowledge:
+   library/API documentation, a URL found in an error message or code comment,
+   current package versions, changelogs, release notes, standards. Skip it when
+   the answer is in the working directory or is stable general knowledge. After
+   fetching, ground your edits in what the page actually says.`;
 export class Agent {
     config;
     client;
@@ -43,9 +49,15 @@ export class Agent {
     sessionCreatedAt;
     currentTask = "";
     lastBuildResult = null;
+    /** Accumulated token usage across the current run (session state). */
+    usageTotals = { calls: 0, inputTokens: 0, outputTokens: 0, cachedTokens: 0 };
     mcp = null;
     /** Aborted when abort() is called — cancels in-flight LLM requests (SIGINT). */
     runSignal = new AbortController();
+    /** Optional structured-event sink (used by the HTTP/SSE server frontend). */
+    onEvent = null;
+    /** Set while a tool call is executing, for tool_output event correlation. */
+    currentToolCall = null;
     constructor(config) {
         this.config = config;
         const commonOpts = {
@@ -70,6 +82,7 @@ export class Agent {
             workdir: config.workdir,
             permissions: this.permissions,
             permissionMode: config.permissionMode,
+            onToolOutput: this.handleToolOutput,
         };
         this.session = new SessionStore(config.workdir, config.noSave !== true);
         this.logger = JsonlLogger.forSession(config.workdir, this.session.id, config.logFile);
@@ -90,6 +103,81 @@ export class Agent {
         // terminate its child process immediately (long builds must be interruptible).
         this.ctx.signal = this.runSignal.signal;
     }
+    /** Emit one structured run event to the sink (if attached). */
+    emit(ev) {
+        this.onEvent?.(ev);
+    }
+    /**
+     * Live tool-output handler: renders chunks in the terminal (dimmed block) and
+     * forwards them as `tool_output` events. Opens the stream block lazily on the
+     * first chunk; `endToolStream()` closes it after the tool completes.
+     */
+    handleToolOutput = (name, stream, delta) => {
+        if (!ui.isToolStreamOpen()) {
+            ui.toolStreamStart();
+        }
+        ui.toolStreamChunk(delta);
+        this.emit({ type: "tool_output", name, stream, delta });
+    };
+    /** Close the live tool-output block (if open) before printing the next UI element. */
+    endToolStream() {
+        if (ui.isToolStreamOpen())
+            ui.toolStreamEnd();
+    }
+    /** Push one tool-result message back into the conversation. */
+    pushToolResult(tc, content) {
+        this.messages.push({
+            role: "tool",
+            tool_call_id: tc.id,
+            name: tc.name,
+            content,
+        });
+    }
+    /**
+     * Handle a rejected tool call (unknown tool, policy denial, user denial):
+     * render the failure, log the event, and push an ERROR tool message so the
+     * LLM can react. Replaces the previously duplicated denied/deny/unknown blocks.
+     */
+    rejectToolCall(step, tc, output, logExtra) {
+        ui.toolResult(tc.name, false, output);
+        this.emit({ type: "tool_result", step, name: tc.name, ok: false, output });
+        this.logger.log({ type: "tool", step, tool: tc.name, ok: false, ...logExtra });
+        this.pushToolResult(tc, output);
+    }
+    /**
+     * Record usage of one LLM call: render token counts, log an `llm_usage`
+     * event, and accumulate totals into session state.
+     */
+    recordLlmUsage(usage) {
+        if (!usage)
+            return;
+        const input = usage.prompt_tokens ?? 0;
+        const output = usage.completion_tokens ?? 0;
+        const cached = usage.cached_tokens ?? 0;
+        this.usageTotals.calls += 1;
+        this.usageTotals.inputTokens += input;
+        this.usageTotals.outputTokens += output;
+        this.usageTotals.cachedTokens += cached;
+        ui.info(`tokens: in=${usage.prompt_tokens ?? "?"} out=${usage.completion_tokens ?? "?"}`);
+        this.emit({
+            type: "llm_usage",
+            usage: { input_tokens: input, output_tokens: output, cached_tokens: cached },
+        });
+        this.logger.log({
+            type: "llm_usage",
+            model: this.client.model,
+            provider: this.config.provider,
+            usage: {
+                input_tokens: input,
+                output_tokens: output,
+                cached_tokens: cached,
+            },
+        });
+    }
+    /** Reset per-run usage accumulation (called when a fresh run starts). */
+    resetUsageTotals() {
+        this.usageTotals = { calls: 0, inputTokens: 0, outputTokens: 0, cachedTokens: 0 };
+    }
     /**
      * One LLM turn: streaming if enabled (renders deltas live), with automatic
      * fallback to non-streaming when the provider/stream fails.
@@ -110,6 +198,7 @@ export class Agent {
                         started = true;
                     }
                     ui.llmStreamChunk(chunk.contentDelta);
+                    this.emit({ type: "llm_delta", delta: chunk.contentDelta });
                     streamedText += chunk.contentDelta;
                 }
                 if (chunk.final)
@@ -166,11 +255,16 @@ export class Agent {
             throw new Error("No API key configured. Set SCODER_API_KEY or OPENAI_API_KEY (or put apiKey in .scoderrc.json).");
         }
         const buildCmd = this.buildCmd;
-        ui.header("TASK");
-        ui.info(task);
-        ui.info(`model=${this.client.model}  workdir=${this.config.workdir}  build="${buildCmd}"  maxSteps=${this.config.maxSteps}`);
+        ui.banner("scoder", [
+            ["task", task],
+            ["model", `${this.client.model} (${this.config.provider}${this.config.stream ? ", stream" : ""})`],
+            ["workdir", this.config.workdir],
+            ["build", buildCmd],
+            ["steps", `max ${this.config.maxSteps}  ·  permission ${this.config.permissionMode}`],
+        ]);
         this.currentTask = task;
         this.resetRunSignal();
+        this.resetUsageTotals();
         this.messages = [
             {
                 role: "system",
@@ -179,6 +273,14 @@ export class Agent {
             },
             { role: "user", content: task },
         ];
+        this.emit({
+            type: "run_start",
+            task,
+            model: this.client.model,
+            provider: this.config.provider,
+            workdir: this.config.workdir,
+            buildCmd,
+        });
         try {
             await this.connectMcp();
             return await this.runLoop(0, buildCmd, null);
@@ -199,6 +301,7 @@ export class Agent {
         const buildCmd = this.buildCmd;
         this.currentTask = `${this.currentTask}\n${task}`.trim();
         this.resetRunSignal();
+        this.resetUsageTotals();
         this.messages.push({ role: "user", content: task });
         try {
             await this.connectMcp();
@@ -217,6 +320,7 @@ export class Agent {
         this.sessionCreatedAt = session.createdAt;
         this.currentTask = session.task;
         this.resetRunSignal();
+        this.resetUsageTotals();
         this.messages = session.messages ?? [];
         ui.header(`RESUME ${session.id}`);
         ui.info(`previous task: ${session.task} (${session.steps} step(s) done)`);
@@ -250,6 +354,7 @@ export class Agent {
         while (steps < this.config.maxSteps && !this.aborted) {
             steps++;
             ui.step(steps, this.config.maxSteps, "thinking...");
+            this.emit({ type: "step", step: steps, maxSteps: this.config.maxSteps });
             const { message, usage } = await this.chatWithStream().catch((err) => {
                 // SIGINT during the LLM call — stop gracefully instead of crashing
                 if (this.aborted) {
@@ -262,19 +367,13 @@ export class Agent {
             });
             if (this.aborted)
                 break;
-            if (usage) {
-                ui.info(`tokens: in=${usage.prompt_tokens ?? "?"} out=${usage.completion_tokens ?? "?"}`);
-                this.logger.log({ type: "step", step: steps, usage });
-            }
-            else {
-                this.logger.log({ type: "step", step: steps });
-            }
+            this.recordLlmUsage(usage);
+            this.logger.log({ type: "step", step: steps });
             // No tool calls => assistant produced a text answer
             if (!message.tool_calls || message.tool_calls.length === 0) {
                 const text = message.content ?? "";
                 this.messages.push({ role: "assistant", content: text });
                 // If the assistant says it's done without building, force a build check.
-                // If the assistant says it's done without building, force a build check.
                 if (claimsCompletion(text) && steps < this.config.maxSteps) {
                     ui.info("agent claims completion -> verifying with build");
                     lastBuild = await this.checkBuild(buildCmd);
@@ -311,24 +410,14 @@ export class Agent {
                     args = tc.arguments ? JSON.parse(tc.arguments) : {};
                 }
                 catch {
-                    this.messages.push({
-                        role: "tool",
-                        tool_call_id: tc.id,
-                        name: tc.name,
-                        content: `ERROR: invalid JSON arguments: ${tc.arguments.slice(0, 200)}`,
-                    });
+                    this.pushToolResult(tc, `ERROR: invalid JSON arguments: ${tc.arguments.slice(0, 200)}`);
                     continue;
                 }
                 ui.toolCall(tc.name, args);
+                this.currentToolCall = { step: steps, id: tc.id, name: tc.name };
+                this.emit({ type: "tool_call", step: steps, id: tc.id, name: tc.name, args });
                 if (!tool && !(this.mcp?.hasTool(tc.name))) {
-                    ui.toolResult(tc.name, false, "unknown tool");
-                    this.logger.log({ type: "tool", step: steps, tool: tc.name, ok: false, error: "unknown tool" });
-                    this.messages.push({
-                        role: "tool",
-                        tool_call_id: tc.id,
-                        name: tc.name,
-                        content: `ERROR: unknown tool "${tc.name}". Available: ${AGENT_TOOLS.map((t) => t.spec.function.name).join(", ")}${this.mcp ? " + MCP tools (mcp__<server>__<tool>)" : ""}`,
-                    });
+                    this.rejectToolCall(steps, tc, `ERROR: unknown tool "${tc.name}". Available: ${AGENT_TOOLS.map((t) => t.spec.function.name).join(", ")}${this.mcp ? " + MCP tools (mcp__<server>__<tool>)" : ""}`, { error: "unknown tool" });
                     continue;
                 }
                 let result;
@@ -341,14 +430,7 @@ export class Agent {
                                 ok: false,
                                 output: `ERROR: command denied by permission policy (${decision.reason}): ${String(args.command).slice(0, 200)}`,
                             };
-                            ui.toolResult(tc.name, false, result.output);
-                            this.logger.log({ type: "tool", step: steps, tool: tc.name, args, ok: false, denied: decision.reason });
-                            this.messages.push({
-                                role: "tool",
-                                tool_call_id: tc.id,
-                                name: tc.name,
-                                content: result.output,
-                            });
+                            this.rejectToolCall(steps, tc, result.output, { args, denied: decision.reason });
                             continue;
                         }
                         if (decision.decision === "ask") {
@@ -358,14 +440,7 @@ export class Agent {
                                     ok: false,
                                     output: `ERROR: user denied permission to run: ${String(args.command).slice(0, 200)}`,
                                 };
-                                ui.toolResult(tc.name, false, result.output);
-                                this.logger.log({ type: "tool", step: steps, tool: tc.name, args, ok: false, denied: "user" });
-                                this.messages.push({
-                                    role: "tool",
-                                    tool_call_id: tc.id,
-                                    name: tc.name,
-                                    content: result.output,
-                                });
+                                this.rejectToolCall(steps, tc, result.output, { args, denied: "user" });
                                 continue;
                             }
                         }
@@ -404,14 +479,12 @@ export class Agent {
                     this.aborted = true;
                     ui.warn("edit confirmation aborted by user ([q]uit) — stopping the run");
                 }
+                this.endToolStream();
+                this.currentToolCall = null;
                 ui.toolResult(tc.name, result.ok, result.output);
+                this.emit({ type: "tool_result", step: steps, name: tc.name, ok: result.ok, output: result.output });
                 stepToolResults.set(tc.id, { ok: result.ok, output: result.output });
-                this.messages.push({
-                    role: "tool",
-                    tool_call_id: tc.id,
-                    name: tc.name,
-                    content: summariseOutput(result.output),
-                });
+                this.pushToolResult(tc, summariseOutput(result.output));
             }
             // After a build-command run, treat success as the terminal condition.
             // Match the FULL build command (not just its first word): matching "npm"
@@ -456,12 +529,20 @@ export class Agent {
             lastBuild: lastBuild
                 ? { success: lastBuild.success, command: lastBuild.command, output: lastBuild.output.slice(0, 10_000) }
                 : null,
+            usage: {
+                llmCalls: this.usageTotals.calls,
+                inputTokens: this.usageTotals.inputTokens,
+                outputTokens: this.usageTotals.outputTokens,
+                cachedTokens: this.usageTotals.cachedTokens,
+            },
         }, this.sessionCreatedAt);
     }
     /** Explicitly verify the build (independent of what the LLM claims). */
     async checkBuild(buildCmd) {
-        const res = await runBuild(this.config.workdir, buildCmd);
+        const res = await runBuild(this.config.workdir, buildCmd, (stream, delta) => this.handleToolOutput("build", stream, delta));
+        this.endToolStream();
         ui.buildStatus(res.success, res.output);
+        this.emit({ type: "build", success: res.success, command: buildCmd, output: res.output });
         this.logger.log({ type: "build", success: res.success, command: buildCmd, output: res.output.slice(0, 10_000) });
         return res;
     }
@@ -472,6 +553,7 @@ export class Agent {
         else {
             ui.error(`Task NOT complete. ${summary}`);
         }
+        this.emit({ type: "finish", success, steps, summary: summary.slice(0, 2000) });
         this.logger.log({ type: "finish", success, steps });
         return { success, steps, buildCmd, summary: summary.slice(0, 2000) };
     }

package/dist/build.js

@@ -10,8 +10,9 @@ export function detectBuildCommand(workdir) {
             if (pkg.scripts?.build)
                 return "npm run build";
         }
-        catch {
-            // fall through
+        catch (err) {
+            // malformed package.json -> fall through to the other detectors
+            console.error(`⚠  cannot parse package.json (${err.message}) — build command detection degraded`);
         }
     }
     if (existsSync(resolve(workdir, "Makefile")))
@@ -29,13 +30,10 @@ export function detectBuildCommand(workdir) {
 /**
  * Run the build command. This is the agent's stop condition:
  * exit code 0 == task complete.
+ * `onOutput` (optional) receives stdout/stderr chunks live while the build runs.
  */
-/**
- * Run the build command. This is the agent's stop condition:
- * exit code 0 == task complete.
- */
-export async function runBuild(workdir, command) {
-    const res = await toolRunCommand(workdir, { command, timeout_secs: 600 });
+export async function runBuild(workdir, command, onOutput) {
+    const res = await toolRunCommand(workdir, { command, timeout_secs: 600 }, undefined, onOutput);
     return {
         success: res.ok,
         command,

package/dist/config.js

@@ -11,8 +11,9 @@ function loadRcFile(workdir) {
             try {
                 return JSON.parse(readFileSync(p, "utf8"));
             }
-            catch {
-                // malformed rc file -> ignore
+            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}`);
             }
         }
     }
@@ -28,6 +29,28 @@ function parseList(raw) {
         return [];
     return raw.filter((x) => typeof x === "string");
 }
+/** Validate the user-supplied pricing table; drop malformed entries with a warning. */
+function parsePricing(raw) {
+    if (raw === undefined)
+        return undefined;
+    if (typeof raw !== "object" || raw === null) {
+        console.error("⚠  ignoring invalid modelPricing in config (expected an object)");
+        return undefined;
+    }
+    const out = {};
+    for (const key of Object.keys(raw)) {
+        const p = raw[key];
+        if (typeof p === "object" && p !== null &&
+            typeof p.input === "number" && Number.isFinite(p.input) &&
+            typeof p.output === "number" && Number.isFinite(p.output)) {
+            out[key] = { input: p.input, output: p.output };
+        }
+        else {
+            console.error(`⚠  ignoring invalid modelPricing entry "${key}" (expected { input: number, output: number })`);
+        }
+    }
+    return out;
+}
 export function loadConfig(overrides = {}) {
     const workdir = overrides.workdir ?? process.cwd();
     const rc = loadRcFile(workdir);
@@ -74,6 +97,7 @@ export function loadConfig(overrides = {}) {
         stream: overrides.stream ?? (process.env.SCODER_STREAM !== "0" ? true : false),
         permissionMode: overrides.permissionMode ??
             parsePermissionMode(process.env.SCODER_PERMISSION ?? rc.permission ?? rc.permissions?.mode ?? "auto"),
+        modelPricing: parsePricing(rc.modelPricing),
     };
     // Secrets hygiene: warn if apiKey is set in the rc file (risk of accidental commit)
     if (rc.apiKey && !process.env.SCODER_NO_APIKEY_WARNING) {

package/dist/constants.js

@@ -0,0 +1,69 @@
+/**
+ * Central constants: model pricing for cost estimation.
+ *
+ * Prices are USD per 1M tokens (input / output), approximate list prices.
+ * They can be overridden per-project via the rc file:
+ *
+ *   .scoderrc.json:
+ *   { "modelPricing": { "my-model": { "input": 1.0, "output": 2.0 } } }
+ *
+ * Keys are matched as a PREFIX of the model name (case-insensitive), so
+ * "gpt-4o-mini" also covers "gpt-4o-mini-2024-07-18". More specific keys
+ * (longer prefix) win.
+ */
+/** Fallback price when a model is unknown (deliberately conservative, not zero). */
+export const DEFAULT_MODEL_PRICING = { input: 0.5, output: 1.5 };
+/** Approximate list prices, USD per 1M tokens. Longest matching prefix wins. */
+export const MODEL_PRICING = {
+    // OpenAI
+    "gpt-4o-mini": { input: 0.15, output: 0.6 },
+    "gpt-4o": { input: 2.5, output: 10 },
+    "gpt-4.1-mini": { input: 0.4, output: 1.6 },
+    "gpt-4.1": { input: 2, output: 8 },
+    "gpt-4-turbo": { input: 10, output: 30 },
+    "gpt-4": { input: 30, output: 60 },
+    "gpt-3.5-turbo": { input: 0.5, output: 1.5 },
+    "o1": { input: 15, output: 60 },
+    "o1-mini": { input: 1.1, output: 4.4 },
+    "o3-mini": { input: 1.1, output: 4.4 },
+    "o3": { input: 2, output: 8 },
+    "o4-mini": { input: 1.1, output: 4.4 },
+    // Anthropic
+    "claude-opus-4": { input: 15, output: 75 },
+    "claude-sonnet-4": { input: 3, output: 15 },
+    "claude-haiku-4": { input: 0.8, output: 4 },
+    "claude-3-7-sonnet": { input: 3, output: 15 },
+    "claude-3-5-sonnet": { input: 3, output: 15 },
+    "claude-3-5-haiku": { input: 0.8, output: 4 },
+    "claude-3-haiku": { input: 0.25, output: 1.25 },
+    "claude-3-opus": { input: 15, output: 75 },
+    // Popular local/OpenAI-compatible providers (mostly $0 or nominal)
+    "llama3": { input: 0, output: 0 },
+    "qwen": { input: 0, output: 0 },
+    "deepseek-chat": { input: 0.27, output: 1.1 },
+    "deepseek-reasoner": { input: 0.55, output: 2.19 },
+};
+/**
+ * Resolve the price table for a model, honouring user overrides.
+ * `overrides` maps model-name prefixes to pricing and always wins over the
+ * built-in table. Longest matching prefix wins (case-insensitive).
+ */
+export function resolveModelPricing(model, overrides = {}) {
+    const m = model.toLowerCase();
+    let best = null;
+    // Built-in table first (longest prefix wins), then overrides — an override
+    // with the SAME prefix length replaces the built-in entry.
+    for (const [key, pricing] of Object.entries(MODEL_PRICING)) {
+        const k = key.toLowerCase();
+        if (m.startsWith(k) && (!best || k.length > best.key.length)) {
+            best = { key: k, pricing };
+        }
+    }
+    for (const [key, pricing] of Object.entries(overrides)) {
+        const k = key.toLowerCase();
+        if (m.startsWith(k) && (!best || k.length >= best.key.length)) {
+            best = { key: k, pricing };
+        }
+    }
+    return best ? best.pricing : DEFAULT_MODEL_PRICING;
+}