@tyvm/knowhow 0.0.145 → 0.0.147

package/tests/clients/reasoningEffort.test.ts

@@ -0,0 +1,79 @@
+import { GenericAnthropicClient } from "../../src/clients/anthropic";
+import { GenericGeminiClient } from "../../src/clients/gemini";
+import { GenericOpenAiClient } from "../../src/clients/openai";
+import { AnthropicModels } from "../../src/clients/pricing";
+import {
+  REASONING_EFFORTS,
+  ReasoningEffort,
+  isReasoningEffort,
+} from "../../src/clients/types";
+import {
+  GoogleThinkingBudgetModels,
+  GoogleThinkingLevelModels,
+} from "../../src/types";
+import { GenericXAIClient } from "../../src/clients/xai";
+
+const options = (model: string, reasoning_effort: ReasoningEffort) => ({
+  model,
+  reasoning_effort,
+  messages: [],
+});
+
+describe("reasoning effort values", () => {
+  it("accepts the complete provider-neutral set and rejects other values", () => {
+    expect(REASONING_EFFORTS).toEqual([
+      "none",
+      "minimal",
+      "low",
+      "medium",
+      "high",
+      "xhigh",
+      "max",
+    ]);
+    REASONING_EFFORTS.forEach((effort) => expect(isReasoningEffort(effort)).toBe(true));
+    expect(isReasoningEffort("extra-high")).toBe(false);
+    expect(isReasoningEffort(undefined)).toBe(false);
+  });
+
+  it("maps provider-neutral values to OpenAI legacy and Responses spellings", () => {
+    const client = new GenericOpenAiClient("fake-key");
+    expect(client.resolveReasoningEffort(options("unknown", "none"))).toBe("low");
+    expect(client.resolveReasoningEffort(options("unknown", "minimal"))).toBe("low");
+    expect(client.resolveReasoningEffort(options("unknown", "xhigh"))).toBe("high");
+    expect(client.resolveReasoningEffort(options("unknown", "max"))).toBe("high");
+    expect(client.resolveReasoningEffortForModel(options("unknown", "max"))).toBe("xhigh");
+  });
+
+  it("maps all values to valid Gemini thinking levels and budgets", () => {
+    const client = new GenericGeminiClient("fake-key");
+    const levelModel = GoogleThinkingLevelModels[0];
+    const budgetModel = GoogleThinkingBudgetModels[0];
+
+    expect(client.buildThinkingConfig(options(levelModel, "none"))).toEqual({ thinkingLevel: "minimal" });
+    expect(client.buildThinkingConfig(options(levelModel, "minimal"))).toEqual({ thinkingLevel: "minimal" });
+    expect(client.buildThinkingConfig(options(levelModel, "xhigh"))).toEqual({ thinkingLevel: "high" });
+    expect(client.buildThinkingConfig(options(levelModel, "max"))).toEqual({ thinkingLevel: "high" });
+    expect(client.buildThinkingConfig(options(budgetModel, "none"))).toEqual({ thinkingBudget: 0 });
+    expect(client.buildThinkingConfig(options(budgetModel, "minimal"))).toEqual({ thinkingBudget: 512 });
+    expect(client.buildThinkingConfig(options(budgetModel, "medium"))).toEqual({ thinkingBudget: 8192 });
+    expect(client.buildThinkingConfig(options(budgetModel, "max"))).toEqual({ thinkingBudget: -1 });
+  });
+
+  it("maps provider-neutral values to Anthropic output effort", () => {
+    const client = new GenericAnthropicClient("fake-key");
+    expect(client.getEffortOutputConfig(AnthropicModels.Sonnet5, "none")).toBeUndefined();
+    expect(client.getEffortOutputConfig(AnthropicModels.Sonnet5, "minimal")).toEqual({ effort: "low" });
+    expect(client.getEffortOutputConfig(AnthropicModels.Sonnet5, "xhigh")).toEqual({ effort: "xhigh" });
+    expect(client.getEffortOutputConfig(AnthropicModels.Sonnet5, "max")).toEqual({ effort: "max" });
+    expect(client.getEffortOutputConfig("unsupported", "high")).toBeUndefined();
+  });
+
+  it("maps provider-neutral values to xAI legacy effort", () => {
+    const client = new GenericXAIClient("fake-key");
+    expect(client.resolveLegacyReasoningEffort("none")).toBeUndefined();
+    expect(client.resolveLegacyReasoningEffort("minimal")).toBe("low");
+    expect(client.resolveLegacyReasoningEffort("medium")).toBe("medium");
+    expect(client.resolveLegacyReasoningEffort("xhigh")).toBe("high");
+    expect(client.resolveLegacyReasoningEffort("max")).toBe("high");
+  });
+});

package/tests/compressor/toolResponseCache.test.ts

@@ -111,7 +111,8 @@ describe("ToolResponseCache - MCP Format Support", () => {
     it("should filter data array with ._data | map(select(.private == true))", async () => {
       const result = await cache.queryToolResponse(
         "github-repos",
-        "._data | map(select(.private == true))"
+        "._data | map(select(.private == true))",
+        { maxCharacters: 50_000 }
       );
       
       // Parse and verify filtering worked

package/tests/manual/clients/completions.test.ts

@@ -17,6 +17,7 @@ import { OpenAiChatModels, OpenAiReasoningModels, OpenAiResponsesOnlyModels } fr
 import { AnthropicTextModels, AnthropicLimitedAvailabilityModels } from "../../../src/clients/pricing/anthropic";
 import { GoogleTextModels } from "../../../src/clients/pricing/google";
 import { XaiTextModels, XaiDeprecatedTextModels } from "../../../src/clients/pricing/xai";
+import { FireworksTextPricing } from "../../../src/clients/pricing/fireworks";
 
 const OUTPUT_FILE = path.join(__dirname, "completions.json");
 const PROMPT = "Say hello in 5 words.";
@@ -29,6 +30,7 @@ interface ModelEntry {
   provider: string;
   model: string;
   envKey: string;
+  reasoningEffort?: "low";
 }
 
 function openaiEntries(models: string[]): ModelEntry[] {
@@ -47,19 +49,35 @@ function xaiEntries(models: string[]): ModelEntry[] {
   return models.map((model) => ({ provider: "xai", model, envKey: "XAI_API_KEY" }));
 }
 
+function fireworksEntries(): ModelEntry[] {
+  return Object.entries(FireworksTextPricing)
+    .filter(([, pricing]) => !pricing.deprecated)
+    .map(([model]) => ({
+      provider: "fireworks",
+      model,
+      envKey: "FIREWORKS_API_KEY",
+      // Fireworks model support for reasoning_effort is model-specific. This
+      // suite exercises the request shape used by Patcher without that flag.
+    }));
+}
+
 const TEST_MODELS: ModelEntry[] = [
   // OpenAI — all active chat + reasoning models + responses-API models
   // Deduplicate since some models appear in multiple lists
-  ...openaiEntries([...new Set([...OpenAiChatModels, ...OpenAiReasoningModels, ...OpenAiResponsesOnlyModels])]),
+  ...openaiEntries([...new Set([...OpenAiChatModels, ...OpenAiReasoningModels, ...OpenAiResponsesOnlyModels])])
+    .map((entry) => ({ ...entry, reasoningEffort: "low" as const })),
 
   // Anthropic — active text models (limited availability excluded)
-  ...anthropicEntries(AnthropicTextModels),
+  ...anthropicEntries(AnthropicTextModels).map((entry) => ({ ...entry, reasoningEffort: "low" as const })),
 
   // Google — all active text models
-  ...googleEntries(GoogleTextModels),
+  ...googleEntries(GoogleTextModels).map((entry) => ({ ...entry, reasoningEffort: "low" as const })),
 
   // XAI — active text models (deprecated grok-2 models excluded)
-  ...xaiEntries(XaiTextModels),
+  ...xaiEntries(XaiTextModels).map((entry) => ({ ...entry, reasoningEffort: "low" as const })),
+
+  // Fireworks — all active catalog models
+  ...fireworksEntries(),
 ];
 
 // ─── Persistence helpers ──────────────────────────────────────────────────────
@@ -118,7 +136,7 @@ describe("Text Completions – multi-provider model verification", () => {
     console.log(`   Total records: ${Object.keys(results).length}`);
   });
 
-  for (const { provider, model, envKey } of TEST_MODELS) {
+  for (const { provider, model, envKey, reasoningEffort } of TEST_MODELS) {
     const key = recordKey(provider, model);
 
     test(`${provider} / ${model}`, async () => {
@@ -145,11 +163,10 @@ describe("Text Completions – multi-provider model verification", () => {
         model,
         messages: [{ role: "user", content: PROMPT }],
         max_tokens: 2000,
-        // Use low reasoning effort for all models that support it — keeps latency
-        // and cost down while still verifying the model responds successfully.
-        // For OpenAI this maps to reasoning_effort="low", for Gemini to
-        // thinkingLevel="low" or thinkingBudget=1024, etc.
-        reasoning_effort: "low",
+        // Exercise the summary option enabled by Patcher. Provider clients must
+        // translate or remove this internal option rather than forwarding it.
+        reasoning_summary: true,
+        reasoning_effort: reasoningEffort,
       });
       const durationMs = Date.now() - startMs;
 

package/tests/processors/TokenCompressor.test.ts

@@ -446,7 +446,7 @@ describe("TokenCompressor", () => {
       expect(result).toContain("Available keys:");
     });
 
-    it("should auto-stitch a multi-chunk chain into the full content", () => {
+    it("should auto-stitch and paginate a multi-chunk chain", () => {
       // Force a multi-chunk compression then expand the first key.
       const content = "a".repeat(40000);
       const placeholder = tokenCompressor.compressStringInChunks(content);
@@ -456,9 +456,23 @@ describe("TokenCompressor", () => {
       const functions = toolsServiceCalls[0][0];
       const result = functions.expandTokens(firstKey);
 
-      // Full content is returned in one call with no chunk-linking markers.
-      expect(result).toBe(content);
+      expect(result.length).toBeLessThanOrEqual(20_000);
+      expect(result).toContain("Repeat with characterOffset=");
       expect(result).not.toContain("NEXT_CHUNK_KEY");
+
+      const pages = [result];
+      let offsetMatch = result.match(/characterOffset=(\d+)/);
+      while (offsetMatch) {
+        const page = functions.expandTokens(
+          firstKey,
+          undefined,
+          undefined,
+          Number(offsetMatch[1])
+        );
+        pages.push(page);
+        offsetMatch = page.match(/Repeat with characterOffset=(\d+)/);
+      }
+      expect(pages.reduce((sum, page) => sum + (page.match(/^a+/)?.[0].length || 0), 0)).toBe(content.length);
     });
 
     it("should support a ranged read with real line numbers", () => {

package/tests/processors/tools/boundedRetrievalTools.test.ts

@@ -0,0 +1,68 @@
+import {
+  executeJqQuery,
+  jqToolResponseDefinition,
+} from "../../../src/processors/tools/jqToolResponse";
+import {
+  executeTail,
+  tailToolResponseDefinition,
+} from "../../../src/processors/tools/tailToolResponse";
+import {
+  executeListStoredToolResponses,
+  listStoredToolResponsesDefinition,
+} from "../../../src/processors/tools/listStoredToolResponses";
+
+describe("bounded retrieval tools", () => {
+  it("bounds and paginates JQ output", async () => {
+    const data = JSON.stringify(Array.from({ length: 100 }, (_, i) => `value-${i}-${"x".repeat(30)}`));
+    const first = await executeJqQuery(data, "jq-id", ".", ["jq-id"], {}, { maxCharacters: 1000 });
+    expect(first.length).toBeLessThanOrEqual(1000);
+    expect(first).toContain("Repeat with characterOffset=");
+
+    const offset = Number(first.match(/characterOffset=(\d+)/)?.[1]);
+    const next = await executeJqQuery(data, "jq-id", ".", ["jq-id"], {}, {
+      characterOffset: offset,
+      maxCharacters: 1000,
+    });
+    expect(next).not.toBe(first);
+  });
+
+  it("bounds tail line lengths and supports backward pagination", async () => {
+    const data = ["first", `second ${"a".repeat(5000)}`, "third"].join("\n");
+    const result = await executeTail(data, "tail-id", ["tail-id"], {
+      lines: 1,
+      endLine: 2,
+      maxLineCharacters: 1000,
+      maxCharacters: 2000,
+    });
+    expect(result.length).toBeLessThanOrEqual(2000);
+    expect(result).toContain("Earlier lines available");
+    expect(result).toContain("lineCharacterOffset=1000");
+  });
+
+  it("paginates stored response results", async () => {
+    const storage = { a: "one", b: "two", c: "three" };
+    const metadata = {
+      a: { toolCallId: "a", originalLength: 3, storedAt: 1 },
+      b: { toolCallId: "b", originalLength: 3, storedAt: 2 },
+      c: { toolCallId: "c", originalLength: 5, storedAt: 3 },
+    };
+    const result = await executeListStoredToolResponses(storage, metadata, {}, {
+      maxResults: 1,
+      resultOffset: 1,
+    });
+    expect(result).toContain("Tool Call ID: b");
+    expect(result).not.toContain("Tool Call ID: c");
+    expect(result).toContain("resultOffset=2");
+  });
+
+  it("exposes pagination controls in each tool schema", () => {
+    const jqOptions = (jqToolResponseDefinition.function.parameters.properties as any).options;
+    const tailOptions = (tailToolResponseDefinition.function.parameters.properties as any).options;
+    const listOptions = (listStoredToolResponsesDefinition.function.parameters.properties as any).options;
+    expect(jqOptions.properties.characterOffset).toBeDefined();
+    expect(tailOptions.properties.endLine).toBeDefined();
+    expect(tailOptions.properties.maxCharacters).toBeDefined();
+    expect(listOptions.properties.resultOffset).toBeDefined();
+    expect(listOptions.properties.maxCharacters).toBeDefined();
+  });
+});

package/tests/processors/tools/grepToolResponse.test.ts

@@ -1,4 +1,7 @@
-import { executeGrep } from "../../../src/processors/tools/grepToolResponse";
+import {
+  executeGrep,
+  grepToolResponseDefinition,
+} from "../../../src/processors/tools/grepToolResponse";
 
 /**
  * Verifies grepToolResponse operates on the decompressed/plain stored content
@@ -69,4 +72,88 @@ describe("executeGrep", () => {
 
     expect(result).toContain("No matches found");
   });
+
+  it("bounds the total response and advertises the next result page", async () => {
+    const manyMatches = Array.from(
+      { length: 20 },
+      (_, index) => `match ${index} ${"x".repeat(200)}`
+    ).join("\n");
+
+    const result = await executeGrep(
+      manyMatches,
+      toolCallId,
+      "match",
+      [toolCallId],
+      { maxCharacters: 1000, maxResults: 20 }
+    );
+
+    expect(result.length).toBeLessThanOrEqual(1000);
+    expect(result).toContain("More matches available");
+    expect(result).toMatch(/resultOffset=\d+/);
+  });
+
+  it("keeps a large log grep under the default response limit", async () => {
+    const logMatches = Array.from(
+      { length: 500 },
+      (_, index) => `${index}: ${JSON.stringify({ level: 30, message: "sandbox runner", detail: "x".repeat(500) })}`
+    ).join("\n");
+
+    const result = await executeGrep(
+      logMatches,
+      toolCallId,
+      "runner|sandbox",
+      [toolCallId]
+    );
+
+    expect(result.length).toBeLessThanOrEqual(20_000);
+    expect(result).toContain("More matches available");
+  });
+
+  it("paginates matches using resultOffset", async () => {
+    const result = await executeGrep(
+      ["match zero", "match one", "match two"].join("\n"),
+      toolCallId,
+      "match",
+      [toolCallId],
+      { maxResults: 1, resultOffset: 1 }
+    );
+
+    expect(result).not.toContain("match zero");
+    expect(result).toContain("match one");
+    expect(result).not.toContain("match two");
+    expect(result).toContain("resultOffset=2");
+  });
+
+  it("slices very long matching lines and lets callers page within the line", async () => {
+    const longLine = `prefix-${"a".repeat(5000)}-suffix`;
+    const firstPage = await executeGrep(
+      longLine,
+      toolCallId,
+      "prefix",
+      [toolCallId]
+    );
+
+    expect(firstPage.length).toBeLessThan(10_000);
+    expect(firstPage).toContain("line 1 truncated");
+    expect(firstPage).toContain("lineCharacterOffset=4000");
+    expect(firstPage).not.toContain("-suffix");
+
+    const secondPage = await executeGrep(
+      longLine,
+      toolCallId,
+      "prefix",
+      [toolCallId],
+      { lineCharacterOffset: 4000 }
+    );
+
+    expect(secondPage).toContain("-suffix");
+    expect(secondPage).toContain("End of matches");
+  });
+
+  it("exposes pagination controls in the tool schema", () => {
+    const options = (grepToolResponseDefinition.function.parameters.properties as any).options;
+    expect(options.properties.resultOffset).toBeDefined();
+    expect(options.properties.lineCharacterOffset).toBeDefined();
+    expect(options.properties.maxCharacters).toBeDefined();
+  });
 });

package/tests/unit/agents/historyRollback.test.ts

@@ -0,0 +1,53 @@
+import { rollbackAgentInteractions } from "../../../src/agents/historyRollback";
+import { Message } from "../../../src/clients/types";
+
+const message = (role: Message["role"], content: string): Message => ({ role, content });
+
+describe("rollbackAgentInteractions", () => {
+  const threads: Message[][] = [[
+    message("user", "request"),
+    message("assistant", "first"),
+    message("tool", "first result"),
+    message("assistant", "second"),
+    message("tool", "second result"),
+  ]];
+
+  it("clones history without changing it when rollback is zero", () => {
+    const result = rollbackAgentInteractions(threads, 0);
+    expect(result).toEqual(threads);
+    expect(result).not.toBe(threads);
+    expect(result[0]).not.toBe(threads[0]);
+    expect(result[0][0]).not.toBe(threads[0][0]);
+  });
+
+  it("removes the newest assistant and its following tool results", () => {
+    expect(rollbackAgentInteractions(threads, 1)).toEqual([threads[0].slice(0, 3)]);
+  });
+
+  it("can remove multiple interactions", () => {
+    expect(rollbackAgentInteractions(threads, 2)).toEqual([[threads[0][0]]]);
+  });
+
+  it("removes a trailing assistant without tools", () => {
+    const input = [[message("user", "request"), message("assistant", "tail")]];
+    expect(rollbackAgentInteractions(input, 1)).toEqual([[input[0][0]]]);
+  });
+
+  it.each([-1, 1.5])("rejects invalid rollback %p", (rollback) => {
+    expect(() => rollbackAgentInteractions(threads, rollback)).toThrow(
+      "rollback must be a non-negative integer"
+    );
+  });
+
+  it("rejects rollback beyond available interactions", () => {
+    expect(() => rollbackAgentInteractions(threads, 3)).toThrow(
+      "only has 2 assistant interaction(s)"
+    );
+  });
+
+  it("does not mutate input history", () => {
+    const before = JSON.stringify(threads);
+    rollbackAgentInteractions(threads, 1);
+    expect(JSON.stringify(threads)).toBe(before);
+  });
+});

package/tests/unit/auth/keyAuth.test.ts

@@ -0,0 +1,102 @@
+const post = jest.fn();
+const publicKeyBase64 = Buffer.alloc(32, 7).toString("base64");
+const keyPairExists = jest.fn(() => true);
+const loadKeyPair = jest.fn(() => ({ publicKeyBase64 }));
+const signMessage = jest.fn(() => "server-message-signature");
+
+jest.mock("../../../src/utils/http", () => ({
+  __esModule: true,
+  default: {
+    post,
+    isHttpError: (error: unknown) =>
+      typeof error === "object" && error !== null && "status" in error,
+  },
+}));
+
+jest.mock("../../../src/auth/keyManager", () => ({
+  keyPairExists,
+  loadKeyPair,
+  signMessage,
+}));
+
+jest.mock("../../../src/auth/browserLogin", () => ({
+  getCliUserAgent: () => "test-agent",
+}));
+
+import {
+  authenticateWithKey,
+  exchangePublicKeyJwt,
+  hasKeyPair,
+  registerPublicKey,
+} from "../../../src/auth/keyAuth";
+
+describe("keyAuth", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    keyPairExists.mockReturnValue(true);
+  });
+
+  it("signs the exact server challenge for the selected key, org, and environment", async () => {
+    post
+      .mockResolvedValueOnce({
+        data: {
+          challengeId: "challenge_1",
+          message: "exact message from server",
+          expiresAt: "2099-01-01T00:00:00.000Z",
+        },
+        status: 201,
+      })
+      .mockResolvedValueOnce({ data: { jwt: "renewed-jwt" }, status: 200 });
+
+    expect(hasKeyPair("/keys/work")).toBe(true);
+    await expect(
+      exchangePublicKeyJwt("org-1", "https://work.example", "/keys/work")
+    ).resolves.toBe("renewed-jwt");
+
+    expect(loadKeyPair).toHaveBeenCalledWith("/keys/work");
+    expect(signMessage).toHaveBeenCalledWith("exact message from server", "/keys/work");
+    expect(post.mock.calls).toEqual([
+      [
+        "https://work.example/api/public-keys/challenge",
+        { publicKey: publicKeyBase64, orgId: "org-1" },
+        { headers: { "User-Agent": "test-agent" } },
+      ],
+      [
+        "https://work.example/api/public-keys/authenticate",
+        { challengeId: "challenge_1", signature: "server-message-signature" },
+        { headers: { "User-Agent": "test-agent" } },
+      ],
+    ]);
+  });
+
+  it("falls back when the key is unavailable without signing a challenge", async () => {
+    post.mockRejectedValueOnce({ status: 401 });
+
+    await expect(
+      authenticateWithKey("org-1", "https://work.example", "/keys/work")
+    ).resolves.toBe(false);
+
+    expect(post).toHaveBeenCalledTimes(1);
+    expect(signMessage).not.toHaveBeenCalled();
+  });
+
+  it("registers only server-owned Ed25519 key fields in the selected environment", async () => {
+    post.mockResolvedValueOnce({ data: {}, status: 201 });
+
+    await registerPublicKey("browser-jwt", publicKeyBase64, "https://dev.example");
+
+    expect(post).toHaveBeenCalledWith(
+      "https://dev.example/api/public-keys/register",
+      {
+        publicKey: publicKeyBase64,
+        label: expect.any(String),
+      },
+      {
+        headers: {
+          Authorization: "Bearer browser-jwt",
+          "User-Agent": "test-agent",
+        },
+      }
+    );
+  });
+});

package/tests/unit/auth/keyManager.test.ts

@@ -0,0 +1,67 @@
+import crypto from "crypto";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import {
+  generateKeyPair,
+  loadKeyPair,
+  signMessage,
+} from "../../../src/auth/keyManager";
+
+describe("keyManager", () => {
+  let directory: string;
+  let identity: string;
+
+  beforeEach(() => {
+    directory = fs.mkdtempSync(path.join(os.tmpdir(), "knowhow-key-manager-"));
+    identity = path.join(directory, "identity");
+  });
+
+  afterEach(() => {
+    fs.rmSync(directory, { recursive: true, force: true });
+  });
+
+  it("creates an Ed25519 identity with an OpenSSH-compatible public key", () => {
+    const generated = generateKeyPair(identity);
+    const publicKeyLine = fs.readFileSync(`${identity}.pub`, "utf8").trim();
+
+    expect(publicKeyLine).toMatch(/^ssh-ed25519 [A-Za-z0-9+/]+=* knowhow-cli$/);
+    expect(fs.statSync(identity).mode % 0o1000).toBe(0o600);
+    expect(loadKeyPair(identity)).toEqual(generated);
+
+    const challengeMessage = "exact server-provided challenge";
+    const signature = signMessage(challengeMessage, identity);
+    const publicKey = crypto.createPublicKey(fs.readFileSync(identity));
+    expect(
+      crypto.verify(
+        null,
+        Buffer.from(challengeMessage),
+        publicKey,
+        Buffer.from(signature, "base64")
+      )
+    ).toBe(true);
+  });
+
+  it("loads legacy raw-base64 public keys but rejects non-Ed25519 identities", () => {
+    const generated = generateKeyPair(identity);
+    fs.writeFileSync(`${identity}.pub`, generated.publicKeyBase64);
+    expect(loadKeyPair(identity).publicKeyBase64).toBe(generated.publicKeyBase64);
+
+    const rsaIdentity = path.join(directory, "rsa");
+    const rsa = crypto.generateKeyPairSync("rsa", {
+      modulusLength: 2048,
+      privateKeyEncoding: { type: "pkcs8", format: "pem" },
+      publicKeyEncoding: { type: "spki", format: "pem" },
+    });
+    fs.writeFileSync(rsaIdentity, rsa.privateKey);
+    fs.writeFileSync(`${rsaIdentity}.pub`, generated.publicKeyBase64);
+
+    expect(() => loadKeyPair(rsaIdentity)).toThrow("must be an Ed25519 private key");
+  });
+
+  it("does not overwrite a partial identity", () => {
+    fs.writeFileSync(identity, "existing key");
+    expect(() => generateKeyPair(identity)).toThrow("a key file already exists");
+    expect(fs.readFileSync(identity, "utf8")).toBe("existing key");
+  });
+});

package/tests/unit/chat/historyCommandArgs.test.ts

@@ -0,0 +1,37 @@
+import { parseHistoryCommandArgs } from "../../../src/chat/modules/SessionsModule";
+
+describe("parseHistoryCommandArgs", () => {
+  it("parses an id and rollback in either order", () => {
+    expect(parseHistoryCommandArgs(["task-1", "--rollback", "2"])).toEqual({
+      id: "task-1", rollback: 2, showAll: false,
+    });
+    expect(parseHistoryCommandArgs(["--rollback", "1", "task-1"])).toEqual({
+      id: "task-1", rollback: 1, showAll: false,
+    });
+  });
+
+  it("supports interactive --all", () => {
+    expect(parseHistoryCommandArgs(["--all"])).toEqual({
+      id: undefined, rollback: 0, showAll: true,
+    });
+  });
+
+  it.each([
+    [["--rollback"]],
+    [["--rollback", "-1"]],
+    [["--rollback", "1.5"]],
+  ])(
+    "rejects invalid rollback arguments: %p",
+    (args) => {
+      expect(() => parseHistoryCommandArgs(args)).toThrow(
+        "--rollback must be a non-negative integer"
+      );
+    }
+  );
+
+  it("rejects unexpected arguments", () => {
+    expect(() => parseHistoryCommandArgs(["one", "two"])).toThrow(
+      "Unexpected argument: two"
+    );
+  });
+});