@sean.holung/minicode 0.3.9 → 0.3.10

package/dist/tests/agent.test.js

@@ -59,6 +59,35 @@ function createEchoTool() {
         execute: async (input) => `echo:${String(input.value)}`,
     };
 }
+function createEditTool() {
+    return {
+        name: "edit_file",
+        description: "Edits a file",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: { type: "string" },
+                content: { type: "string" },
+            },
+            required: ["path", "content"],
+        },
+        execute: async (input) => `edited:${String(input.path)}`,
+    };
+}
+function createRunCommandTool() {
+    return {
+        name: "run_command",
+        description: "Runs a shell command",
+        inputSchema: {
+            type: "object",
+            properties: {
+                command: { type: "string" },
+            },
+            required: ["command"],
+        },
+        execute: async (input) => `ran:${String(input.command)}`,
+    };
+}
 function assertToolCallTranscriptIsComplete(messages) {
     for (let i = 0; i < messages.length; i += 1) {
         const message = messages[i];
@@ -113,6 +142,87 @@ test("agent stops on repeated identical tool calls", async () => {
     assert.match(text, /repeated identical tool calls/);
     assertToolCallTranscriptIsComplete(agent.getSession().getMessages());
 });
+test("agent does not treat repeated validation commands after edits as a loop", async () => {
+    const responses = [
+        {
+            text: "test current state",
+            toolCalls: [{ id: "run-1", name: "run_command", input: { command: "npm test" } }],
+            stopReason: "tool_use",
+            usage: { inputTokens: 1, outputTokens: 1 },
+        },
+        {
+            text: "first edit",
+            toolCalls: [{ id: "edit-1", name: "edit_file", input: { path: "app.ts", content: "one" } }],
+            stopReason: "tool_use",
+            usage: { inputTokens: 1, outputTokens: 1 },
+        },
+        {
+            text: "test after first edit",
+            toolCalls: [{ id: "run-2", name: "run_command", input: { command: "npm test" } }],
+            stopReason: "tool_use",
+            usage: { inputTokens: 1, outputTokens: 1 },
+        },
+        {
+            text: "second edit",
+            toolCalls: [{ id: "edit-2", name: "edit_file", input: { path: "app.ts", content: "two" } }],
+            stopReason: "tool_use",
+            usage: { inputTokens: 1, outputTokens: 1 },
+        },
+        {
+            text: "test after second edit",
+            toolCalls: [{ id: "run-3", name: "run_command", input: { command: "npm test" } }],
+            stopReason: "tool_use",
+            usage: { inputTokens: 1, outputTokens: 1 },
+        },
+        {
+            text: "Done.",
+            toolCalls: [],
+            stopReason: "end_turn",
+            usage: { inputTokens: 1, outputTokens: 1 },
+        },
+    ];
+    const agent = new CodingAgent({
+        config: createTestAgentConfig("/tmp"),
+        modelClient: new SequenceModelClient(responses),
+        toolRegistry: new ToolRegistry([
+            createEditTool(),
+            createRunCommandTool(),
+        ]),
+    });
+    const { text } = await agent.runTurn("Fix and test");
+    assert.equal(text, "Done.");
+    assertToolCallTranscriptIsComplete(agent.getSession().getMessages());
+});
+test("agent still stops on repeated identical mutations", async () => {
+    const responses = [
+        {
+            text: "first edit",
+            toolCalls: [{ id: "edit-1", name: "edit_file", input: { path: "app.ts", content: "same" } }],
+            stopReason: "tool_use",
+            usage: { inputTokens: 1, outputTokens: 1 },
+        },
+        {
+            text: "second edit",
+            toolCalls: [{ id: "edit-2", name: "edit_file", input: { path: "app.ts", content: "same" } }],
+            stopReason: "tool_use",
+            usage: { inputTokens: 1, outputTokens: 1 },
+        },
+        {
+            text: "third edit",
+            toolCalls: [{ id: "edit-3", name: "edit_file", input: { path: "app.ts", content: "same" } }],
+            stopReason: "tool_use",
+            usage: { inputTokens: 1, outputTokens: 1 },
+        },
+    ];
+    const agent = new CodingAgent({
+        config: createTestAgentConfig("/tmp"),
+        modelClient: new SequenceModelClient(responses),
+        toolRegistry: new ToolRegistry([createEditTool()]),
+    });
+    const { text } = await agent.runTurn("Edit repeatedly");
+    assert.match(text, /repeated identical tool calls/);
+    assertToolCallTranscriptIsComplete(agent.getSession().getMessages());
+});
 test("agent tells the user how to continue when the turn call limit is reached", async () => {
     const config = createTestAgentConfig("/tmp");
     config.maxSteps = 2;

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

@@ -0,0 +1,80 @@
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, test } from "node:test";
+import { buildBenchmarkAgentConfig, getDefaultBenchmarkConfigPath, } from "../src/benchmark/config.js";
+const tempDirs = [];
+afterEach(async () => {
+    await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
+});
+test("getDefaultBenchmarkConfigPath resolves under benchmarks/", () => {
+    const repoRoot = "/tmp/minicode-repo";
+    assert.equal(getDefaultBenchmarkConfigPath(repoRoot), path.join(repoRoot, "benchmarks", "benchmark.config.json"));
+});
+test("buildBenchmarkAgentConfig uses config, env files, shell env, and CLI overrides in precedence order", async () => {
+    const repoRoot = await mkdtemp(path.join(os.tmpdir(), "minicode-benchmark-config-"));
+    tempDirs.push(repoRoot);
+    const configPath = path.join(repoRoot, "benchmarks", "benchmark.config.json");
+    const envFilePath = path.join(repoRoot, "benchmarks", "benchmark.env");
+    await mkdir(path.dirname(configPath), { recursive: true });
+    await writeFile(configPath, JSON.stringify({
+        modelProvider: "openai-compatible",
+        model: "config-model",
+        openAiBaseUrl: "https://config.example/v1",
+        workspaceRoot: "./config-workspace",
+        maxSteps: 11,
+        maxContextTokens: 12000,
+        commandTimeoutMs: 4000,
+        enableDynamicPrompt: true,
+    }), "utf8");
+    await writeFile(envFilePath, [
+        "MODEL=env-file-model",
+        "OPENAI_BASE_URL=https://env-file.example/v1",
+        "OPENAI_API_KEY=env-file-key",
+        "MAX_STEPS=22",
+        "ENABLE_DYNAMIC_PROMPT=true",
+    ].join("\n"), "utf8");
+    const config = await buildBenchmarkAgentConfig({
+        cwd: repoRoot,
+        configPath: path.relative(repoRoot, configPath),
+        envFiles: [path.relative(repoRoot, envFilePath)],
+        env: {
+            MODEL: "shell-model",
+            MAX_STEPS: "33",
+            MAX_CONTEXT_TOKENS: "24000",
+            OPENAI_API_KEY: "shell-key",
+        },
+        overrides: {
+            model: "override-model",
+            baseUrl: "https://override.example/v1",
+            workspaceRoot: "./override-workspace",
+        },
+    });
+    assert.equal(config.modelProvider, "openai-compatible");
+    assert.equal(config.model, "override-model");
+    assert.equal(config.openAiBaseUrl, "https://override.example/v1");
+    assert.equal(config.workspaceRoot, path.join(repoRoot, "override-workspace"));
+    assert.equal(config.maxSteps, 33);
+    assert.equal(config.maxContextTokens, 24000);
+    assert.equal(config.commandTimeoutMs, 4000);
+    assert.equal(config.openAiApiKey, "shell-key");
+    assert.equal(config.enableDynamicPrompt, true);
+});
+test("buildBenchmarkAgentConfig does not require a default config file", async () => {
+    const repoRoot = await mkdtemp(path.join(os.tmpdir(), "minicode-benchmark-config-"));
+    tempDirs.push(repoRoot);
+    const config = await buildBenchmarkAgentConfig({
+        cwd: repoRoot,
+        env: {
+            MODEL_PROVIDER: "openai-compatible",
+            MODEL: "standalone-model",
+            OPENAI_BASE_URL: "http://localhost:1234/v1",
+        },
+    });
+    assert.equal(config.modelProvider, "openai-compatible");
+    assert.equal(config.model, "standalone-model");
+    assert.equal(config.openAiBaseUrl, "http://localhost:1234/v1");
+    assert.equal(config.maxSteps, 50);
+    assert.equal(config.enableDynamicPrompt, false);
+});

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

@@ -0,0 +1,180 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { buildBenchmarkToolTrace, getBenchmarkSystemPromptSuffix, isBenchmarkApprovalSeekingResponse, parseBenchmarkRunArgs, summarizeBenchmarkToolUsage, } from "../src/cli/benchmark-run.js";
+test("benchmark system prompt suffix clearly disables approval-seeking behavior", () => {
+    const suffix = getBenchmarkSystemPromptSuffix();
+    assert.match(suffix, /non-interactive benchmark harness/i);
+    assert.match(suffix, /already approved/i);
+    assert.match(suffix, /do not ask for confirmation/i);
+});
+test("benchmark system prompt suffix omits runtime budget knobs", () => {
+    const suffix = getBenchmarkSystemPromptSuffix();
+    assert.doesNotMatch(suffix, /maxSteps/i);
+    assert.doesNotMatch(suffix, /maxTokens/i);
+    assert.doesNotMatch(suffix, /modelTimeoutSeconds/i);
+    assert.doesNotMatch(suffix, /maxContextTokens/i);
+    assert.doesNotMatch(suffix, /commandTimeoutMs/i);
+});
+test("approval-seeking benchmark responses are detected", () => {
+    assert.equal(isBenchmarkApprovalSeekingResponse("I found the changes needed. Please confirm and I'll apply them."), true);
+    assert.equal(isBenchmarkApprovalSeekingResponse("May I proceed with these changes?"), true);
+});
+test("normal benchmark summaries are not treated as approval-seeking", () => {
+    assert.equal(isBenchmarkApprovalSeekingResponse("Updated src/app.ts, ran npm test once, and all tests passed."), false);
+    assert.equal(isBenchmarkApprovalSeekingResponse("The task is blocked because the repository does not contain the referenced file."), false);
+});
+test("parseBenchmarkRunArgs preserves prompt text and benchmark flags", () => {
+    const args = parseBenchmarkRunArgs([
+        "--verbose",
+        "--config",
+        "benchmarks/benchmark.config.json",
+        "--env-file",
+        "benchmarks/benchmark.env",
+        "--provider",
+        "openai-compatible",
+        "--model",
+        "openai/gpt-5",
+        "--base-url",
+        "https://openrouter.ai/api/v1",
+        "--workspace-root",
+        ".",
+        "--out",
+        "artifacts/result.json",
+        "Solve",
+        "the",
+        "exercise",
+    ]);
+    assert.equal(args.verbose, true);
+    assert.equal(args.prompt, "Solve the exercise");
+    assert.equal(args.configPath, "benchmarks/benchmark.config.json");
+    assert.deepEqual(args.envFiles, ["benchmarks/benchmark.env"]);
+    assert.equal(args.provider, "openai-compatible");
+    assert.equal(args.model, "openai/gpt-5");
+    assert.equal(args.baseUrl, "https://openrouter.ai/api/v1");
+    assert.equal(args.workspaceRoot, ".");
+    assert.equal(args.outFile, "artifacts/result.json");
+});
+test("buildBenchmarkToolTrace extracts assistant tool calls and matching results", () => {
+    const messages = [
+        { role: "user", content: "solve it" },
+        {
+            role: "assistant",
+            content: "reading",
+            toolCalls: [
+                { id: "call-1", name: "read_symbol", input: { name: "parse" } },
+                { id: "call-2", name: "read_file", input: { path: "parse.ts" } },
+            ],
+        },
+        {
+            role: "tool",
+            toolCallId: "call-1",
+            toolName: "read_symbol",
+            content: "symbol body",
+        },
+        {
+            role: "tool",
+            toolCallId: "call-2",
+            toolName: "read_file",
+            content: "file body",
+        },
+        { role: "assistant", content: "done" },
+    ];
+    const trace = buildBenchmarkToolTrace(messages);
+    assert.deepEqual(trace, [
+        {
+            step: 1,
+            name: "read_symbol",
+            input: { name: "parse" },
+            result: "symbol body",
+            skipped: false,
+        },
+        {
+            step: 1,
+            name: "read_file",
+            input: { path: "parse.ts" },
+            result: "file body",
+            skipped: false,
+        },
+    ]);
+});
+test("benchmark tool usage summary separates structured tools from file reads", () => {
+    const summary = summarizeBenchmarkToolUsage([
+        {
+            step: 1,
+            name: "read_symbol",
+            input: { name: "parse" },
+            result: "symbol body",
+            skipped: false,
+        },
+        {
+            step: 1,
+            name: "get_dependencies",
+            input: { name: "parse" },
+            result: "deps",
+            skipped: false,
+        },
+        {
+            step: 2,
+            name: "read_file",
+            input: { path: "parse.ts" },
+            result: "file body",
+            skipped: false,
+        },
+        {
+            step: 3,
+            name: "edit_file",
+            input: { path: "parse.ts", old_string: "a", new_string: "b" },
+            result: "edited",
+            skipped: false,
+        },
+        {
+            step: 4,
+            name: "run_command",
+            input: { command: "npm test" },
+            result: "ok",
+            skipped: false,
+        },
+    ], "Done");
+    assert.equal(summary.total, 5);
+    assert.equal(summary.specializedTotal, 2);
+    assert.equal(summary.specializedByName.read_symbol, 1);
+    assert.equal(summary.specializedByName.get_dependencies, 1);
+    assert.equal(summary.fileReadTotal, 1);
+    assert.equal(summary.mutationTotal, 1);
+    assert.equal(summary.commandTotal, 1);
+    assert.deepEqual(summary.repeatedToolCalls, []);
+});
+test("benchmark tool usage summary reports repeated-call stops", () => {
+    const summary = summarizeBenchmarkToolUsage([
+        {
+            step: 1,
+            name: "read_file",
+            input: { path: "accumulate.ts" },
+            result: "stub",
+            skipped: false,
+        },
+        {
+            step: 2,
+            name: "read_file",
+            input: { path: "accumulate.ts" },
+            result: "stub",
+            skipped: false,
+        },
+        {
+            step: 3,
+            name: "read_file",
+            input: { path: "accumulate.ts" },
+            result: "Tool skipped: Stopped due to repeated identical tool calls. Please refine the prompt or provide additional constraints.",
+            skipped: true,
+        },
+    ], "Stopped due to repeated identical tool calls. Please refine the prompt or provide additional constraints.");
+    assert.equal(summary.repeatedStop, true);
+    assert.equal(summary.skippedTotal, 1);
+    assert.deepEqual(summary.repeatedToolCalls, [
+        {
+            name: "read_file",
+            input: { path: "accumulate.ts" },
+            count: 3,
+        },
+    ]);
+});

package/dist/tests/cli-args.test.js

@@ -42,6 +42,28 @@ test("parseCliArgs supports --json and --out path", () => {
     assert.equal(parsed.outFile, "result.json");
     assert.equal(parsed.task, "summarize todos");
 });
+test("parseCliArgs detects benchmark run and preserves subcommand argv", () => {
+    const parsed = parseCliArgs([
+        "node",
+        "src/index.ts",
+        "benchmark",
+        "run",
+        "--config",
+        "benchmarks/custom.json",
+        "--model",
+        "test-model",
+        "solve task",
+    ]);
+    assert.equal(parsed.benchmarkRun, true);
+    assert.deepEqual(parsed.benchmarkArgv, [
+        "--config",
+        "benchmarks/custom.json",
+        "--model",
+        "test-model",
+        "solve task",
+    ]);
+    assert.equal(parsed.task, "");
+});
 test("parseCliArgs supports --out=<file>", () => {
     const parsed = parseCliArgs([
         "node",

package/dist/tests/cli-oneshot.integration.test.js

@@ -24,3 +24,8 @@ test("oneshot mode exits with usage code when --out has no value", () => {
     assert.equal(result.status, 2);
     assert.match(result.stderr, /--out requires a file path/);
 });
+test("benchmark run exits with usage code when prompt is missing", () => {
+    const result = runCli(["benchmark", "run"]);
+    assert.equal(result.status, 2);
+    assert.match(result.stderr, /benchmark run requires prompt text or --prompt-file/);
+});

package/dist/tests/config.test.js

@@ -93,3 +93,24 @@ test("loadAgentConfig reads model start timeout in seconds", async () => {
     const config = await loadAgentConfig("/tmp", { minicodeHome });
     assert.equal(config.modelTimeoutSeconds, 75);
 });
+test("loadAgentConfig disables dynamic prompts by default", async () => {
+    const base = await mkdtemp(path.join(os.tmpdir(), "minicode-config-test-"));
+    tempDirs.push(base);
+    const minicodeHome = path.join(base, "home");
+    await mkdir(minicodeHome, { recursive: true });
+    await writeFile(path.join(minicodeHome, ".env"), "MODEL=test-model\n", "utf8");
+    const previousDynamicPrompt = process.env.ENABLE_DYNAMIC_PROMPT;
+    try {
+        delete process.env.ENABLE_DYNAMIC_PROMPT;
+        const config = await loadAgentConfig("/tmp", { minicodeHome });
+        assert.equal(config.enableDynamicPrompt, false);
+    }
+    finally {
+        if (previousDynamicPrompt === undefined) {
+            delete process.env.ENABLE_DYNAMIC_PROMPT;
+        }
+        else {
+            process.env.ENABLE_DYNAMIC_PROMPT = previousDynamicPrompt;
+        }
+    }
+});

package/dist/tests/file-tools.test.js

@@ -5,6 +5,7 @@ import path from "node:path";
 import { test } from "node:test";
 import { createEditFileTool, createReadFileTool, createRunCommandTool, createWriteFileTool } from "@minicode/agent-sdk";
 import { buildProjectIndex } from "../src/indexer/project-index.js";
+import { createToolRegistry } from "../src/tools/registry.js";
 import { createTestAgentConfig } from "./test-utils.js";
 async function createTempWorkspace() {
     return mkdtemp(path.join(tmpdir(), "minicode-tests-"));
@@ -69,6 +70,41 @@ test("write_file triggers reindex when projectIndex provided", async () => {
     const added = index.getSymbol("add");
     assert.ok(added?.signature.includes("a: number, b: number"), "index should reflect newly written file");
 });
+test("write_file succeeds even when post-write reindex fails", async () => {
+    const workspaceRoot = await createTempWorkspace();
+    const index = await buildProjectIndex(workspaceRoot);
+    index.reindexFile = async () => {
+        throw new Error("reindex failed");
+    };
+    const registry = createToolRegistry(createTestAgentConfig(workspaceRoot), index);
+    const result = await registry.execute("write_file", {
+        path: "src/util.ts",
+        content: `export function add(a: number, b: number): number {\n  return a + b;\n}\n`,
+    });
+    assert.match(result, /Wrote \d+ characters to "src\/util\.ts"\./);
+    const written = await readFile(path.join(workspaceRoot, "src", "util.ts"), "utf8");
+    assert.match(written, /export function add/);
+});
+test("edit_file succeeds even when post-edit reindex fails", async () => {
+    const workspaceRoot = await createTempWorkspace();
+    const { mkdir } = await import("node:fs/promises");
+    const filePath = path.join(workspaceRoot, "src", "util.ts");
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, `export function add(a: number, b: number): number {\n  return a + b;\n}\n`, "utf8");
+    const index = await buildProjectIndex(workspaceRoot);
+    index.reindexFile = async () => {
+        throw new Error("reindex failed");
+    };
+    const registry = createToolRegistry(createTestAgentConfig(workspaceRoot), index);
+    const result = await registry.execute("edit_file", {
+        path: "src/util.ts",
+        old_string: "return a + b;",
+        new_string: "return a + b + 1;",
+    });
+    assert.match(result, /Updated "src\/util\.ts" successfully\./);
+    const updated = await readFile(filePath, "utf8");
+    assert.match(updated, /return a \+ b \+ 1;/);
+});
 test("run_command refreshes index after shell-created file changes", async () => {
     const workspaceRoot = await createTempWorkspace();
     const index = await buildProjectIndex(workspaceRoot);

package/dist/tests/harbor-adapter.test.js

@@ -0,0 +1,57 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { test } from "node:test";
+import assert from "node:assert/strict";
+const repoRoot = path.resolve(import.meta.dirname, "..");
+const adapterPath = path.join(repoRoot, "benchmarks", "harbor", "minicode_agent.py");
+const readAdapter = () => readFile(adapterPath, "utf8");
+test("Harbor adapter exposes the expected importable class and name", async () => {
+    const source = await readAdapter();
+    assert.match(source, /class MinicodeAgent\(BaseInstalledAgent\):/);
+    assert.match(source, /def name\(\) -> str:/);
+    assert.match(source, /return "minicode"/);
+});
+test("Harbor adapter shells out through benchmark mode with artifact outputs", async () => {
+    const source = await readAdapter();
+    assert.match(source, /"minicode",\s*"benchmark",\s*"run"/s);
+    assert.match(source, /"--workspace-root",\s*"\."/s);
+    assert.match(source, /"--out",\s*RESULT_PATH/s);
+    assert.match(source, /"--diff-out",\s*PATCH_PATH/s);
+    assert.match(source, /shlex\.quote\(arg\)/);
+});
+test("Harbor adapter forwards benchmark env knobs", async () => {
+    const source = await readAdapter();
+    for (const [sourceKey, targetKey] of [
+        ["MINICODE_BENCHMARK_MAX_STEPS", "MAX_STEPS"],
+        ["MINICODE_BENCHMARK_MAX_CONTEXT_TOKENS", "MAX_CONTEXT_TOKENS"],
+        ["MINICODE_BENCHMARK_MODEL_TIMEOUT_SECONDS", "MODEL_TIMEOUT_SECONDS"],
+        ["MINICODE_BENCHMARK_COMMAND_TIMEOUT_MS", "COMMAND_TIMEOUT_MS"],
+        ["MINICODE_BENCHMARK_MAX_TOOL_OUTPUT_CHARS", "MAX_TOOL_OUTPUT_CHARS"],
+    ]) {
+        assert.match(source, new RegExp(`"${sourceKey}",\\s*"${targetKey}"`));
+    }
+});
+test("Harbor adapter defaults OpenAI-compatible runs through OpenRouter", async () => {
+    const source = await readAdapter();
+    assert.match(source, /DEFAULT_OPENROUTER_BASE_URL = "https:\/\/openrouter\.ai\/api\/v1"/);
+    assert.match(source, /return "openai-compatible", self\._base_url or DEFAULT_OPENROUTER_BASE_URL/);
+});
+test("Harbor adapter documents a module import path for Harbor", async () => {
+    const readme = await readFile(path.join(repoRoot, "benchmarks", "harbor", "README.md"), "utf8");
+    assert.match(readme, /export PYTHONPATH=\/path\/to\/minicode/);
+    assert.match(readme, /--agent-import-path benchmarks\.harbor\.minicode_agent:MinicodeAgent/);
+});
+test("Harbor adapter installs native build prerequisites for fresh containers", async () => {
+    const source = await readAdapter();
+    assert.match(source, /build-essential python3/);
+});
+test("Harbor adapter installs Node when npm is missing from benchmark containers", async () => {
+    const source = await readAdapter();
+    assert.match(source, /command -v npm/);
+});
+test("Harbor adapter documents local tarball smoke testing", async () => {
+    const readme = await readFile(path.join(repoRoot, "benchmarks", "harbor", "README.md"), "utf8");
+    assert.match(readme, /npm pack --pack-destination \/tmp/);
+    assert.match(readme, /package_spec=http:\/\/host\.docker\.internal:18081\/sean\.holung-minicode-0\.2\.0\.tgz/);
+    assert.match(readme, /reward `1\.0`/);
+});

package/dist/tests/indexer.test.js

@@ -193,7 +193,7 @@ test("reindexFile updates symbols and code map after file change", async () => {
   return title ? \`Hello, \${title} \${name}\` : \`Hello, \${name}\`;
 }
 `;
-    index.reindexFile("sample.ts", updatedContent);
+    await index.reindexFile("sample.ts", updatedContent);
     const updatedSym = index.getSymbol("greet");
     assert.ok(updatedSym, "should still find greet");
     assert.ok(updatedSym.signature.includes("title?: string"), "signature should reflect updated params");