@sean.holung/minicode 0.2.4 → 0.3.1

package/dist/tests/benchmark-index.test.js

@@ -0,0 +1,152 @@
+import assert from "node:assert/strict";
+import path from "node:path";
+import { test } from "node:test";
+import { buildProjectIndex } from "../src/indexer/project-index.js";
+const FIXTURE_ROOT = path.resolve(import.meta.dirname, "..", "test-programs", "benchmark-index");
+let index;
+// Build the index once, reuse across tests
+test("benchmark fixture: build index", async () => {
+    index = await buildProjectIndex(FIXTURE_ROOT);
+    assert.ok(index.symbols.size > 0, "should index symbols");
+    assert.ok(index.files.size > 0, "should index files");
+    assert.ok(index.dependencyEdges.length > 0, "should produce dependency edges");
+});
+// ---------------------------------------------------------------------------
+// Symbol extraction
+// ---------------------------------------------------------------------------
+test("benchmark: indexes TypeScript class declarations", () => {
+    const app = index.getSymbol("App");
+    assert.ok(app, "should index App class");
+    assert.equal(app.kind, "class");
+    assert.equal(app.exported, true);
+    assert.ok(index.getSymbol("App.start"), "should index App.start method");
+    assert.ok(index.getSymbol("App.constructor"), "should index App constructor");
+});
+test("benchmark: indexes JS named class expressions (const X = class X {})", () => {
+    const logger = index.getSymbol("ConsoleLogger");
+    assert.ok(logger, "should index ConsoleLogger class expression");
+    assert.equal(logger.kind, "class");
+    assert.ok(index.getSymbol("ConsoleLogger.info"), "should index ConsoleLogger.info");
+    assert.ok(index.getSymbol("ConsoleLogger.error"), "should index ConsoleLogger.error");
+    assert.ok(index.getSymbol("ConsoleLogger.constructor"), "should index constructor");
+});
+test("benchmark: indexes JS anonymous class expressions (const X = class {})", () => {
+    const bus = index.getSymbol("EventBus");
+    assert.ok(bus, "should index EventBus anonymous class expression");
+    assert.equal(bus.kind, "class");
+    assert.ok(index.getSymbol("EventBus.on"), "should index EventBus.on");
+    assert.ok(index.getSymbol("EventBus.emit"), "should index EventBus.emit");
+    assert.ok(index.getSymbol("EventBus.constructor"), "should index EventBus constructor");
+});
+test("benchmark: indexes JS class declarations with inheritance", () => {
+    const base = index.getSymbol("BasePlugin");
+    assert.ok(base, "should index BasePlugin");
+    assert.equal(base.kind, "class");
+    const auth = index.getSymbol("AuthPlugin");
+    assert.ok(auth, "should index AuthPlugin");
+    assert.equal(auth.kind, "class");
+    assert.ok(index.getSymbol("AuthPlugin.setupAuth"), "should index AuthPlugin.setupAuth");
+});
+test("benchmark: indexes interfaces and type aliases", () => {
+    const logger = index.getSymbol("Logger");
+    assert.ok(logger, "should index Logger interface");
+    assert.equal(logger.kind, "interface");
+    const plugin = index.getSymbol("Plugin");
+    assert.ok(plugin, "should index Plugin interface");
+    assert.equal(plugin.kind, "interface");
+    const startable = index.getSymbol("Startable");
+    assert.ok(startable, "should index Startable interface");
+    const logLevel = index.getSymbol("LogLevel");
+    assert.ok(logLevel, "should index LogLevel type alias");
+    assert.equal(logLevel.kind, "type");
+    const handler = index.getSymbol("EventHandler");
+    assert.ok(handler, "should index EventHandler type alias");
+    assert.equal(handler.kind, "type");
+});
+test("benchmark: indexes arrow functions and function expressions", () => {
+    const fmt = index.getSymbol("formatMessage");
+    assert.ok(fmt, "should index arrow function formatMessage");
+    assert.equal(fmt.kind, "function");
+    const parse = index.getSymbol("parseEvent");
+    assert.ok(parse, "should index function expression parseEvent");
+    assert.equal(parse.kind, "function");
+    const handler = index.getSymbol("createHandler");
+    assert.ok(handler, "should index function declaration createHandler");
+    assert.equal(handler.kind, "function");
+});
+test("benchmark: indexes function declarations in JS", () => {
+    const create = index.getSymbol("createLogger");
+    assert.ok(create, "should index createLogger");
+    assert.equal(create.kind, "function");
+    assert.equal(create.exported, true);
+    const factory = index.getSymbol("createPlugin");
+    assert.ok(factory, "should index createPlugin");
+    assert.equal(factory.kind, "function");
+});
+test("benchmark: indexes entry point function", () => {
+    const main = index.getSymbol("main");
+    assert.ok(main, "should index main");
+    assert.equal(main.kind, "function");
+    assert.equal(main.exported, true);
+});
+// ---------------------------------------------------------------------------
+// Dependency edges
+// ---------------------------------------------------------------------------
+function hasEdge(from, to, kind) {
+    return index.dependencyEdges.some((e) => e.from === from && e.to === to && e.kind === kind);
+}
+test("benchmark: extends edges", () => {
+    assert.ok(hasEdge("AuthPlugin", "BasePlugin", "extends"), "AuthPlugin should extend BasePlugin");
+});
+test("benchmark: implements edges", () => {
+    assert.ok(hasEdge("App", "Startable", "implements"), "App should implement Startable");
+});
+test("benchmark: new expression call edges", () => {
+    assert.ok(hasEdge("main", "App", "calls"), "main should call new App()");
+    assert.ok(hasEdge("App.start", "AuthPlugin", "calls"), "App.start should call new AuthPlugin()");
+    assert.ok(hasEdge("createLogger", "ConsoleLogger", "calls"), "createLogger should call new ConsoleLogger()");
+    assert.ok(hasEdge("createPlugin", "AuthPlugin", "calls"), "createPlugin should call new AuthPlugin()");
+    assert.ok(hasEdge("createPlugin", "BasePlugin", "calls"), "createPlugin should call new BasePlugin()");
+});
+test("benchmark: function call edges", () => {
+    assert.ok(hasEdge("main", "createLogger", "calls"), "main should call createLogger()");
+    assert.ok(hasEdge("createHandler", "formatMessage", "calls"), "createHandler should call formatMessage()");
+});
+test("benchmark: type reference edges", () => {
+    assert.ok(hasEdge("App.constructor", "Logger", "references"), "App.constructor should reference Logger type");
+    assert.ok(hasEdge("App.start", "AuthPlugin", "calls"), "App.start should call new AuthPlugin()");
+    assert.ok(hasEdge("createHandler", "EventHandler", "references"), "createHandler should reference EventHandler type");
+});
+// ---------------------------------------------------------------------------
+// Dependency cone traversal
+// ---------------------------------------------------------------------------
+test("benchmark: getDependencyCone from main", () => {
+    const cone = index.getDependencyCone("main", 2);
+    const names = cone.map((s) => s.qualifiedName);
+    assert.ok(names.includes("main"), "cone should include main itself");
+    assert.ok(names.includes("createLogger"), "depth 1: main calls createLogger");
+    assert.ok(names.includes("App"), "depth 1: main calls new App");
+    assert.ok(names.includes("ConsoleLogger"), "depth 2: createLogger calls new ConsoleLogger");
+});
+test("benchmark: getDependencyCone from App.start", () => {
+    const cone = index.getDependencyCone("App.start", 1);
+    const names = cone.map((s) => s.qualifiedName);
+    assert.ok(names.includes("App.start"), "cone should include App.start itself");
+    assert.ok(names.includes("AuthPlugin"), "App.start calls new AuthPlugin");
+});
+// ---------------------------------------------------------------------------
+// Code map
+// ---------------------------------------------------------------------------
+test("benchmark: code map includes key symbols", () => {
+    const codeMap = index.getCodeMap();
+    assert.ok(codeMap.text.includes("App"), "code map should include App");
+    assert.ok(codeMap.text.includes("ConsoleLogger"), "code map should include ConsoleLogger");
+    assert.ok(codeMap.text.includes("EventBus"), "code map should include EventBus");
+    assert.ok(codeMap.text.includes("main"), "code map should include main");
+    assert.ok(codeMap.totalCount > 0, "should report total symbol count");
+});
+test("benchmark: code map includes JS and TS files", () => {
+    const codeMap = index.getCodeMap();
+    assert.ok(codeMap.text.includes(".ts"), "code map should include .ts files");
+    assert.ok(codeMap.text.includes(".js"), "code map should include .js files");
+});

package/dist/tests/indexer.test.js

@@ -199,3 +199,65 @@ test("reindexFile updates symbols and code map after file change", async () => {
     const codeMap = index.getCodeMap();
     assert.ok(codeMap.text.includes("title?: string"), "code map should reflect new signature");
 });
+test("TypeScript plugin indexes class expressions assigned to variables", () => {
+    const code = `const MyClass = class MyClass {
+  constructor(name) {
+    this.name = name;
+  }
+
+  greet() {
+    return "hello " + this.name;
+  }
+};`;
+    const symbols = typescriptPlugin.indexFile("class-expr.js", code);
+    const names = symbols.map((s) => s.qualifiedName);
+    assert.ok(names.includes("MyClass"), "should extract class expression MyClass");
+    assert.ok(names.includes("MyClass.constructor"), "should extract constructor");
+    assert.ok(names.includes("MyClass.greet"), "should extract method greet");
+    const cls = symbols.find((s) => s.qualifiedName === "MyClass");
+    assert.equal(cls.kind, "class");
+});
+test("TypeScript plugin indexes anonymous class expressions using variable name", () => {
+    const code = `const Widget = class {
+  render() {
+    return "<div/>";
+  }
+};`;
+    const symbols = typescriptPlugin.indexFile("anon-class.js", code);
+    const names = symbols.map((s) => s.qualifiedName);
+    assert.ok(names.includes("Widget"), "should extract anonymous class as Widget");
+    assert.ok(names.includes("Widget.render"), "should extract method with class prefix");
+    const cls = symbols.find((s) => s.qualifiedName === "Widget");
+    assert.equal(cls.kind, "class");
+});
+test("TypeScript plugin indexes exported class expressions", () => {
+    const code = `export const Service = class Service {
+  start() {}
+  stop() {}
+};`;
+    const symbols = typescriptPlugin.indexFile("service.js", code);
+    const cls = symbols.find((s) => s.qualifiedName === "Service");
+    assert.ok(cls, "should extract exported class expression");
+    assert.equal(cls.exported, true, "should mark as exported");
+    assert.equal(cls.kind, "class");
+    const names = symbols.map((s) => s.qualifiedName);
+    assert.ok(names.includes("Service.start"));
+    assert.ok(names.includes("Service.stop"));
+});
+test("resolveDependencies tracks new expressions as calls edges", () => {
+    const code = `
+class Logger {
+  log(msg) {}
+}
+
+function setup() {
+  const logger = new Logger();
+  logger.log("ready");
+}
+`;
+    const symbols = typescriptPlugin.indexFile("new-expr.js", code);
+    const projectFiles = new Map([["new-expr.js", code]]);
+    const edges = typescriptPlugin.resolveDependencies(symbols, projectFiles);
+    const newCallEdge = edges.find((e) => e.from === "setup" && e.to === "Logger" && e.kind === "calls");
+    assert.ok(newCallEdge, "new Logger() should produce a calls edge from setup to Logger");
+});

package/dist/tests/serve.integration.test.js

@@ -1,6 +1,7 @@
 import assert from "node:assert/strict";
 import { test, afterEach } from "node:test";
 import { createServer } from "node:http";
+import { mkdirSync, writeFileSync, rmSync } from "node:fs";
 import { createRequestHandler } from "../src/serve/server.js";
 import { AgentBridge } from "../src/serve/agent-bridge.js";
 import { createTestAgentConfig } from "./test-utils.js";
@@ -126,6 +127,49 @@ class MockBridge extends AgentBridge {
         this._pinned.delete(name);
         return true;
     }
+    // Annotation state for testing
+    _annotations = new Map();
+    getAnnotations() {
+        return Object.fromEntries(this._annotations);
+    }
+    getAnnotationsForSymbol(name) {
+        // Resolve symbol name to qualifiedName
+        const sym = this.getSymbol(name);
+        const key = sym ? sym.qualifiedName : name;
+        return this._annotations.get(key) ?? [];
+    }
+    addAnnotation(name, text) {
+        const sym = this.getSymbol(name);
+        if (!sym)
+            return false;
+        const trimmed = text.slice(0, 500).trim();
+        if (trimmed.length === 0)
+            return false;
+        const key = sym.qualifiedName;
+        const existing = this._annotations.get(key) ?? [];
+        existing.push(trimmed);
+        this._annotations.set(key, existing);
+        return true;
+    }
+    removeAnnotation(name, index) {
+        const notes = this._annotations.get(name);
+        if (!notes || index < 0 || index >= notes.length)
+            return false;
+        notes.splice(index, 1);
+        if (notes.length === 0)
+            this._annotations.delete(name);
+        return true;
+    }
+    clearAnnotations(name) {
+        this._annotations.delete(name);
+    }
+    async explainSymbol(name, onEvent) {
+        const sym = this.getSymbol(name);
+        if (!sym)
+            throw new Error(`Symbol "${name}" not found`);
+        onEvent({ type: "streaming_chunk", content: `Explaining ${name}...` });
+        return `Explaining ${name}...`;
+    }
 }
 // ── Test harness ──
 let activeServer;
@@ -532,3 +576,184 @@ test("POST /api/focus returns 400 for invalid action", async () => {
     });
     assert.equal(res.status, 400);
 });
+// ── Symbol source endpoint tests ──
+test("GET /api/symbols/:name/source returns source code for known symbol", async () => {
+    const bridge = new MockBridge();
+    const base = await startTestServer(bridge);
+    // Create a temp file matching the mock symbol's filePath
+    const wsRoot = "/tmp/test-workspace";
+    mkdirSync(`${wsRoot}/src`, { recursive: true });
+    writeFileSync(`${wsRoot}/src/foo.ts`, "line1\nfunction foo(): void {\n  return;\n}\nline5\n");
+    try {
+        const res = await fetch(`${base}/api/symbols/foo/source`);
+        assert.equal(res.status, 200);
+        const body = (await res.json());
+        assert.equal(body.symbol, "foo");
+        assert.equal(body.filePath, "src/foo.ts");
+        assert.equal(body.startLine, 1);
+        assert.equal(body.endLine, 5);
+        assert.ok(body.source.includes("line1"));
+    }
+    finally {
+        rmSync(wsRoot, { recursive: true, force: true });
+    }
+});
+test("GET /api/symbols/:name/source returns 404 for unknown symbol", async () => {
+    const bridge = new MockBridge();
+    const base = await startTestServer(bridge);
+    const res = await fetch(`${base}/api/symbols/nonexistent/source`);
+    assert.equal(res.status, 404);
+    const body = (await res.json());
+    assert.ok(body.error.includes("nonexistent"));
+});
+test("GET /api/symbols/:name/source returns 500 when file is missing", async () => {
+    const bridge = new MockBridge();
+    const base = await startTestServer(bridge);
+    // Don't create the file — let it fail with a read error
+    const res = await fetch(`${base}/api/symbols/foo/source`);
+    assert.equal(res.status, 500);
+    const body = (await res.json());
+    assert.ok(body.error.includes("src/foo.ts"));
+});
+// ── Annotations API tests ──
+test("GET /api/annotations returns empty annotations initially", async () => {
+    const bridge = new MockBridge();
+    const base = await startTestServer(bridge);
+    const res = await fetch(`${base}/api/annotations`);
+    assert.equal(res.status, 200);
+    const body = (await res.json());
+    assert.deepEqual(body.annotations, {});
+});
+test("POST /api/symbols/:name/annotations adds annotation", async () => {
+    const bridge = new MockBridge();
+    const base = await startTestServer(bridge);
+    const res = await fetch(`${base}/api/symbols/foo/annotations`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ text: "don't modify, stable API" }),
+    });
+    assert.equal(res.status, 200);
+    const body = (await res.json());
+    assert.equal(body.symbol, "foo");
+    assert.equal(body.annotations.length, 1);
+    assert.equal(body.annotations[0], "don't modify, stable API");
+});
+test("GET /api/symbols/:name/annotations returns annotations for symbol", async () => {
+    const bridge = new MockBridge();
+    const base = await startTestServer(bridge);
+    // Add one first
+    await fetch(`${base}/api/symbols/foo/annotations`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ text: "note 1" }),
+    });
+    const res = await fetch(`${base}/api/symbols/foo/annotations`);
+    assert.equal(res.status, 200);
+    const body = (await res.json());
+    assert.equal(body.annotations.length, 1);
+    assert.equal(body.annotations[0], "note 1");
+});
+test("POST /api/symbols/:name/annotations returns 404 for unknown symbol", async () => {
+    const bridge = new MockBridge();
+    const base = await startTestServer(bridge);
+    const res = await fetch(`${base}/api/symbols/nonexistent/annotations`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ text: "hello" }),
+    });
+    assert.equal(res.status, 404);
+});
+test("POST /api/symbols/:name/annotations returns 400 for missing text", async () => {
+    const bridge = new MockBridge();
+    const base = await startTestServer(bridge);
+    const res = await fetch(`${base}/api/symbols/foo/annotations`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({}),
+    });
+    assert.equal(res.status, 400);
+});
+test("DELETE /api/symbols/:name/annotations/:index removes annotation", async () => {
+    const bridge = new MockBridge();
+    const base = await startTestServer(bridge);
+    // Add two annotations
+    await fetch(`${base}/api/symbols/foo/annotations`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ text: "first" }),
+    });
+    await fetch(`${base}/api/symbols/foo/annotations`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ text: "second" }),
+    });
+    // Remove first
+    const res = await fetch(`${base}/api/symbols/foo/annotations/0`, {
+        method: "DELETE",
+    });
+    assert.equal(res.status, 200);
+    const body = (await res.json());
+    assert.equal(body.annotations.length, 1);
+    assert.equal(body.annotations[0], "second");
+});
+test("DELETE /api/symbols/:name/annotations/:index returns 404 for invalid index", async () => {
+    const bridge = new MockBridge();
+    const base = await startTestServer(bridge);
+    const res = await fetch(`${base}/api/symbols/foo/annotations/99`, {
+        method: "DELETE",
+    });
+    assert.equal(res.status, 404);
+});
+test("DELETE /api/symbols/:name/annotations clears all annotations", async () => {
+    const bridge = new MockBridge();
+    const base = await startTestServer(bridge);
+    // Add annotations
+    await fetch(`${base}/api/symbols/foo/annotations`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ text: "note" }),
+    });
+    // Clear all
+    const res = await fetch(`${base}/api/symbols/foo/annotations`, {
+        method: "DELETE",
+    });
+    assert.equal(res.status, 200);
+    const body = (await res.json());
+    assert.deepEqual(body.annotations, []);
+});
+test("GET /api/annotations returns all annotations after adding", async () => {
+    const bridge = new MockBridge();
+    const base = await startTestServer(bridge);
+    await fetch(`${base}/api/symbols/foo/annotations`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ text: "foo note" }),
+    });
+    await fetch(`${base}/api/symbols/Bar/annotations`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ text: "bar note" }),
+    });
+    const res = await fetch(`${base}/api/annotations`);
+    assert.equal(res.status, 200);
+    const body = (await res.json());
+    assert.ok(Object.keys(body.annotations).length >= 2);
+});
+test("GET /api/symbols/:name/explain returns SSE stream", async () => {
+    const bridge = new MockBridge();
+    const base = await startTestServer(bridge);
+    const res = await fetch(`${base}/api/symbols/foo/explain`);
+    assert.equal(res.status, 200);
+    assert.equal(res.headers.get("content-type"), "text/event-stream");
+    const text = await res.text();
+    assert.ok(text.includes("data: "));
+    assert.ok(text.includes("[DONE]"));
+});
+test("GET /api/symbols/:name/explain returns error for unknown symbol", async () => {
+    const bridge = new MockBridge();
+    const base = await startTestServer(bridge);
+    const res = await fetch(`${base}/api/symbols/nonexistent/explain`);
+    assert.equal(res.status, 200); // SSE always starts 200
+    const text = await res.text();
+    assert.ok(text.includes("error"));
+});

package/node_modules/@minicode/agent-sdk/dist/src/agent/agent.d.ts

@@ -1,4 +1,4 @@
-import type { CodeMapResult } from "../prompt/system-prompt.js";
+import type { CodeMapResult } from "../indexer/types.js";
 import { Session } from "../session/session.js";
 import type { CompactionResult } from "../session/session.js";
 import { ToolRegistry } from "../tools/registry.js";
@@ -37,6 +37,8 @@ export declare class CodingAgent {
     private readonly verbose;
     private readonly onProgress;
     private readonly onUiUpdate;
+    private readonly onVerbose;
+    private readonly getSystemPromptSuffix;
     /**
      * Tracks symbol names the user/agent has been working with.
      * Persists across turns so the code map stays focused on the
@@ -59,7 +61,10 @@ export declare class CodingAgent {
         verbose?: boolean;
         onProgress?: (message: string) => void;
         onUiUpdate?: (event: UiUpdate) => void;
+        onVerbose?: (message: string) => void;
+        getSystemPromptSuffix?: () => string | undefined;
     });
+    private verboseLog;
     getSession(): Session;
     /**
      * Manually compact the conversation context.

package/node_modules/@minicode/agent-sdk/dist/src/agent/agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../../src/agent/agent.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../../src/agent/agent.ts"],"names":[],"mappings":"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"}

package/node_modules/@minicode/agent-sdk/dist/src/agent/agent.js

@@ -107,6 +107,8 @@ export class CodingAgent {
     verbose;
     onProgress;
     onUiUpdate;
+    onVerbose;
+    getSystemPromptSuffix;
     /**
      * Tracks symbol names the user/agent has been working with.
      * Persists across turns so the code map stays focused on the
@@ -129,6 +131,17 @@ export class CodingAgent {
         this.verbose = params.verbose ?? false;
         this.onProgress = params.onProgress;
         this.onUiUpdate = params.onUiUpdate;
+        this.onVerbose = params.onVerbose;
+        this.getSystemPromptSuffix = params.getSystemPromptSuffix;
+    }
+    verboseLog(...args) {
+        const msg = args.map((a) => typeof a === "string" ? a : JSON.stringify(a, null, 2)).join(" ");
+        if (this.onVerbose) {
+            this.onVerbose(msg);
+        }
+        else {
+            console.error(msg);
+        }
     }
     getSession() {
         return this.session;
@@ -232,15 +245,17 @@ export class CodingAgent {
             // Rebuild system prompt each step with the latest focus set,
             // so the code map dynamically adapts as the agent explores symbols.
             const codeMapResult = this.getCodeMap?.(this.getFocusSet());
-            const systemPrompt = buildSystemPrompt(this.config, toolSchemas, codeMapResult);
+            const basePrompt = buildSystemPrompt(this.config, toolSchemas, codeMapResult);
+            const suffix = this.getSystemPromptSuffix?.();
+            const systemPrompt = suffix ? basePrompt + "\n\n" + suffix : basePrompt;
             const messages = this.session.getMessages();
             if (this.verbose) {
-                console.error(`\n${VERBOSE_SEP}`);
-                console.error(`[verbose] Request (step ${step})`);
-                console.error(`${VERBOSE_SEP}`);
-                console.error("\n[System Prompt]\n", systemPrompt);
-                console.error("\n[Messages]\n", JSON.stringify(messages, null, 2));
-                console.error(VERBOSE_SEP);
+                this.verboseLog(`\n${VERBOSE_SEP}`);
+                this.verboseLog(`[verbose] Request (step ${step})`);
+                this.verboseLog(VERBOSE_SEP);
+                this.verboseLog("\n[System Prompt]\n", systemPrompt);
+                this.verboseLog("\n[Messages]\n", JSON.stringify(messages, null, 2));
+                this.verboseLog(VERBOSE_SEP);
             }
             const response = await this.modelClient.chat({
                 model: this.config.model,
@@ -260,16 +275,16 @@ export class CodingAgent {
             totalInputTokens += response.usage.inputTokens;
             totalOutputTokens += response.usage.outputTokens;
             if (this.verbose) {
-                console.error(`\n${VERBOSE_SEP}`);
-                console.error("[verbose] Response");
-                console.error(`${VERBOSE_SEP}`);
-                console.error("Text:", response.text);
-                console.error("Tool calls:", response.toolCalls.length);
+                this.verboseLog(`\n${VERBOSE_SEP}`);
+                this.verboseLog("[verbose] Response");
+                this.verboseLog(VERBOSE_SEP);
+                this.verboseLog("Text:", response.text);
+                this.verboseLog("Tool calls:", response.toolCalls.length);
                 if (response.toolCalls.length > 0) {
-                    console.error("Tools:", response.toolCalls.map((t) => `${t.name}(${JSON.stringify(t.input)})`).join(", "));
+                    this.verboseLog("Tools:", response.toolCalls.map((t) => `${t.name}(${JSON.stringify(t.input)})`).join(", "));
                 }
-                console.error("Usage:", response.usage);
-                console.error(VERBOSE_SEP);
+                this.verboseLog("Usage:", response.usage);
+                this.verboseLog(VERBOSE_SEP);
             }
             if (response.toolCalls.length === 0) {
                 const finalText = response.text.length > 0
@@ -345,9 +360,9 @@ export class CodingAgent {
                     });
                 }
                 if (this.verbose) {
-                    console.error(`\n${VERBOSE_SEP}`);
-                    console.error(`[verbose] Tool: ${toolCall.name}`);
-                    console.error("Arguments:", JSON.stringify(toolCall.input, null, 2));
+                    this.verboseLog(`\n${VERBOSE_SEP}`);
+                    this.verboseLog(`[verbose] Tool: ${toolCall.name}`);
+                    this.verboseLog("Arguments:", JSON.stringify(toolCall.input, null, 2));
                 }
                 let toolResult;
                 const toolStartMs = Date.now();
@@ -388,8 +403,8 @@ export class CodingAgent {
                     });
                 }
                 if (this.verbose) {
-                    console.error("Output:", toolResult);
-                    console.error(VERBOSE_SEP);
+                    this.verboseLog("Output:", toolResult);
+                    this.verboseLog(VERBOSE_SEP);
                 }
                 this.session.addMessage({
                     role: "tool",