@tyvm/knowhow 0.0.146 → 0.0.148

package/src/services/SyncerService.ts

@@ -3,6 +3,7 @@
  * Hides complexity of choosing and managing sync backends.
  */
 import { BaseAgent } from "../agents/base/base";
+import { TraceAll } from "../util/Trace";
 import { AgentSyncFs } from "./AgentSyncFs";
 import { AgentSyncKnowhowWeb } from "./AgentSyncKnowhowWeb";
 
@@ -11,12 +12,13 @@ export interface SyncerOptions {
   prompt: string;
   /** If provided → use web sync (unless syncFs is set) */
   messageId?: string;
+  /** Existing remote Knowhow task UUID. Never inferred from the local taskId. */
+  remoteTaskId?: string;
   /** Force fs sync even if messageId is provided */
   syncFs?: boolean;
   /**
-   * Push the agent's work to a remote Knowhow task. When set (and there is no
-   * messageId), the `taskId` is treated as the remote task ID to attach to and
-   * push updates to, rather than creating a new remote task.
+   * Push the agent's work to the existing `remoteTaskId`. The local taskId is
+   * always a filesystem identity and is never used as a remote identifier.
    */
   syncRemote?: boolean;
   /** Agent name to persist in metadata.json */
@@ -44,8 +46,9 @@ export interface AgentSyncer {
  * Decision logic:
  *   - Always sets up AgentSyncFs (primary local syncer)
  *   - If messageId is present AND syncFs is not forced → creates a new remote task via AgentSyncKnowhowWeb
- *   - If syncRemote is set (and no messageId) → attaches to the remote task identified by taskId
+ *   - If syncRemote and a valid remoteTaskId are set → attaches to that UUID
  */
+@TraceAll()
 export class SyncerService implements AgentSyncer {
   private fsSync: AgentSyncFs;
   private webSync: AgentSyncKnowhowWeb;
@@ -75,14 +78,16 @@ export class SyncerService implements AgentSyncer {
 
     // Determine whether to ATTACH to an already-existing remote task and push
     // local work to it (no creation needed). This is the "--sync-remote" path:
-    // the caller wants to push work to the remote task identified by taskId.
+    // the caller wants to push work to an explicitly identified remote task.
     // We only auto-attach when there is NO messageId (messageId always creates
     // a fresh remote task above).
     //
     // This is orthogonal to fs sync: we can push to the remote task AND keep
     // the local .knowhow/processes/agents/<id>/ files in sync at the same time.
     const shouldAttachExisting =
-      !!options.syncRemote && !options.messageId && !!options.taskId;
+      !!options.syncRemote &&
+      !options.messageId &&
+      isUuid(options.remoteTaskId);
 
     // Always create fs sync task first
     console.log(
@@ -104,6 +109,7 @@ export class SyncerService implements AgentSyncer {
 
       if (knowhowTaskId) {
         this.useWebSync = true;
+        await this.fsSync.setRemoteIdentity(knowhowTaskId, options.messageId);
         this.createdTaskId = knowhowTaskId;
         console.log(`🌐 Web sync task created: ${knowhowTaskId}`);
       }
@@ -112,9 +118,10 @@ export class SyncerService implements AgentSyncer {
     // Attach live web sync to an existing remote task (push updates to it).
     if (!shouldUseWebSync && shouldAttachExisting) {
       this.useWebSync = true;
-      this.createdTaskId = options.taskId;
+      await this.fsSync.setRemoteIdentity(options.remoteTaskId!);
+      this.createdTaskId = options.remoteTaskId;
       console.log(
-        `🌐 Attaching web sync to existing remote task: ${options.taskId}`
+        `🌐 Attaching web sync to existing remote task: ${options.remoteTaskId}`
       );
     }
 
@@ -174,3 +181,11 @@ export class SyncerService implements AgentSyncer {
     return this.useWebSync ? this.createdTaskId : undefined;
   }
 }
+
+/** Remote task IDs are UUIDs; local filesystem IDs are timestamped slugs. */
+function isUuid(value: string | undefined): value is string {
+  return !!value &&
+    /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(
+      value
+    );
+}

package/src/services/TaskRegistry.ts

@@ -2,10 +2,12 @@
  * Task Registry Service - Manages active agent tasks
  */
 import { TaskInfo } from "../chat/types";
+import { TraceAll } from "../util/Trace";
 
 /**
  * TaskRegistry manages the in-memory registry of active agent tasks
  */
+@TraceAll()
 export class TaskRegistry {
   private tasks = new Map<string, TaskInfo>();
 

package/src/services/Tools.ts

@@ -1,4 +1,5 @@
 import { ChatCompletionTool } from "openai/resources/chat";
+import { TraceAll } from "../util/Trace";
 import { replaceEscapedNewLines, restoreEscapedNewLines } from "../utils";
 import { includedTools } from "../agents/tools/list";
 import { AgentService } from "./AgentService";
@@ -61,6 +62,7 @@ export interface ToolContext {
  * larger context bloat from having every tool defined in system prompt
  *
  */
+@TraceAll()
 export class ToolsService {
   private context: ToolContext = {};
 
@@ -133,6 +135,16 @@ export class ToolsService {
     return this.tools.map((tool) => tool.function.name);
   }
 
+  /**
+   * Return every registered function implementation. Unlike getToolNames(),
+   * this is not a prompt-visibility list; lazy tool services may intentionally
+   * hide definitions from the model while keeping their functions callable by
+   * trusted programmatic consumers such as the script runtime.
+   */
+  getFunctionNames(): string[] {
+    return Object.keys(this.functions).filter((name) => typeof this.functions[name] === "function");
+  }
+
   getTool(name: string): Tool {
     return this.tools.find(
       (tool) =>

package/src/services/index.ts

@@ -16,6 +16,7 @@ import { TaskRegistry } from "./TaskRegistry";
 import { MediaProcessorService } from "./MediaProcessorService";
 import { BehaviorsService } from "./BehaviorsService";
 import { RuntimeReloadService } from "./RuntimeReloadService";
+import { ExtensionsService } from "./ExtensionsService";
 
 import { ConversionService } from "./conversion/ConversionService";
 import { TracingService } from "./TracingService";
@@ -45,12 +46,14 @@ export { TracingService } from "./TracingService";
 export type { TracerImpl, SpanHandle } from "./TracingService";
 export * from "./conversion";
 export * from "./RuntimeReloadService";
+export * from "./ExtensionsService";
 export { BehaviorsService } from "./BehaviorsService";
 
 let Singletons = {} as {
   Tools: ToolsService;
   Events: EventService;
   Agents: AgentService;
+  Tracing: typeof TracingService;
   Embeddings: EmbeddingsService;
   Flags: FlagsService;
   Mcp: McpService;
@@ -63,6 +66,7 @@ let Singletons = {} as {
   Conversion: ConversionService;
   Behaviors: BehaviorsService;
   RuntimeReload: RuntimeReloadService;
+  Extensions: ExtensionsService;
 };
 
 export const services = (): typeof Singletons => {
@@ -83,6 +87,7 @@ export const services = (): typeof Singletons => {
     Singletons = {
       Agents,
       AwsS3: new S3Service(),
+      Tracing: TracingService,
       Clients,
       Docker: new DockerService(),
       Events,
@@ -96,6 +101,7 @@ export const services = (): typeof Singletons => {
       knowhowApiClient: new KnowhowSimpleClient(),
       Behaviors,
       RuntimeReload: new RuntimeReloadService(),
+      Extensions: new ExtensionsService(),
     };
 
     Singletons.Tools.setContext({

package/src/services/modules/index.ts

@@ -207,6 +207,11 @@ export class ModulesService {
       }
       this._loadedModules.push({ modulePath, resolvedPath, module: importedModule, params: initParams });
 
+      context.Extensions?.removeOwner(modulePath);
+      for (const extension of importedModule.extensions ?? []) {
+        context.Extensions?.register(modulePath, extension);
+      }
+
       // Only register tools/agents/plugins/clients if the relevant services
       // are available in context (they may not be during early CLI command registration)
       if (context.Agents) {
@@ -253,6 +258,7 @@ export class ModulesService {
     // Clear first so repeated shutdown/reload attempts cannot destroy twice.
     this._loadedModules = [];
     for (const { modulePath, resolvedPath, module: mod, params } of toDestroy) {
+      params.context?.Extensions?.removeOwner(modulePath);
       if (typeof mod.destroy === "function") {
         try {
           await mod.destroy(params);
@@ -284,9 +290,12 @@ export class ModulesService {
 
     // Load global-config modules resolving against the global install's
     // node_modules (~/.knowhow/node_modules) first.
+    // Pass a merged config so that keys defined in the global config (e.g.
+    // `tracing`) are visible to globally-declared modules during init().
+    // Local config keys take precedence so that local overrides still work.
     if (globalModules.length > 0) {
       await this.loadModulesFrom(
-        { ...config, modules: globalModules },
+        { ...globalConfig, ...config, modules: globalModules },
         context,
         globalResolvePaths()
       );

package/src/services/modules/types.ts

@@ -15,6 +15,7 @@ import { EventService } from "../EventService";
 import { ConversionService } from "../conversion/ConversionService";
 import { BehaviorsService } from "../BehaviorsService";
 import { ComputerUseService } from "./computerUse";
+import { ExtensionsService, ModuleExtension } from "../ExtensionsService";
 
 import { TracingService as TracingServiceType } from "../TracingService";
 /*
@@ -66,6 +67,7 @@ export interface ModuleContext {
   Program?: Command;
   Behaviors?: BehaviorsService;
   ComputerUse?: ComputerUseService;
+  Extensions?: ExtensionsService;
   [key: string]: any;
   Tracing?: typeof TracingServiceType;
 }
@@ -98,6 +100,8 @@ export interface KnowhowModule {
    */
   destroy?: (params: InitParams) => Promise<void>;
   commands: ModuleChatCommand[];
+  /** Optional capabilities consumed by core or third-party services. */
+  extensions?: ModuleExtension[];
   tools: ModuleTool[];
   agents: ModuleAgent[];
   plugins: ModulePlugin[];

package/src/types.ts

@@ -75,6 +75,8 @@ export type Config = {
   promptsDir: string;
   lintCommands?: { [fileExtension: string]: string };
   orgId?: string;
+  /** Private Ed25519 identity selected with `knowhow login --identity`. */
+  cliIdentityPath?: string;
   syncRemote?: boolean;
   micCommand?: string;
   defaultMic?: string;

package/src/util/Trace.ts

@@ -141,7 +141,7 @@ export interface TraceAllOptions {
 export function TraceAll(options: TraceAllOptions = {}) {
   const skip = new Set(options.skip ?? []);
 
-  return function <T extends { new (...args: unknown[]): object }>(
+  return function <T extends abstract new (...args: unknown[]) => object>(
     constructor: T
   ): T {
     const className = constructor.name;

package/src/utils/http.ts

@@ -21,6 +21,15 @@ export class HttpError extends Error {
   }
 }
 
+/**
+ * Optional, non-enumerable hook carried by an authenticated headers object.
+ * The hook may replace an expired credential before one safe 401 retry.
+ */
+export const HTTP_UNAUTHORIZED_HANDLER = Symbol("httpUnauthorizedHandler");
+export type RefreshableHeaders = Record<string, string> & {
+  [HTTP_UNAUTHORIZED_HANDLER]?: () => Promise<void>;
+};
+
 async function parseBody<T>(response: Response, responseType?: string): Promise<T> {
   if (responseType === "arraybuffer") {
     return (await response.arrayBuffer()) as unknown as T;
@@ -41,13 +50,14 @@ async function request<T = any>(
   url: string,
   options: {
     method?: string;
-    headers?: Record<string, string>;
+    headers?: RefreshableHeaders;
     body?: any;
     responseType?: "json" | "arraybuffer" | "stream" | "text";
     params?: Record<string, any>;
     /** Timeout in milliseconds. Default: 30000 (30s). Use 0 to disable. */
     timeout?: number;
-  } = {}
+  } = {},
+  mayRefresh = true
 ): Promise<HttpResponse<T>> {
   const { method = "GET", headers = {}, body, responseType, params, timeout = 30000 } = options;
 
@@ -102,6 +112,12 @@ async function request<T = any>(
   }
 
   if (!response.ok) {
+    const refresh = headers[HTTP_UNAUTHORIZED_HANDLER];
+    if (response.status === 401 && mayRefresh && refresh) {
+      await refresh();
+      return request<T>(url, options, false);
+    }
+
     const text = await response.text().catch(() => "");
     let parsedBody: any;
     try {

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/ToolCommandModule.test.ts

@@ -0,0 +1,71 @@
+import { ToolCommandModule } from "../../../src/chat/modules/ToolCommandModule";
+import { LazyToolsService } from "../../../src/services/LazyToolsService";
+import { ChatService } from "../../../src/chat/types";
+
+function makeHarness() {
+  const tools = new LazyToolsService();
+  tools.addTools([{
+    type: "function",
+    function: {
+      name: "hiddenEcho",
+      description: "echo",
+      parameters: { type: "object", properties: { value: { type: "string" } } },
+    },
+  }]);
+  tools.setFunction("hiddenEcho", ({ value }: { value: string }) => ({ value }));
+
+  const context: any = { plugins: [], chatHistory: [], activeAgentTaskId: "task-1" };
+  const service = {
+    getTools: () => tools,
+    getContext: () => context,
+    registerCommand: jest.fn(),
+    registerMode: jest.fn(),
+  } as unknown as ChatService;
+  const module = new ToolCommandModule();
+  return module.initialize(service).then(() => ({
+    command: module.getCommands()[0],
+    tools,
+  }));
+}
+
+describe("ToolCommandModule", () => {
+  let log: jest.SpyInstance;
+  let error: jest.SpyInstance;
+
+  beforeEach(() => {
+    log = jest.spyOn(console, "log").mockImplementation();
+    error = jest.spyOn(console, "error").mockImplementation();
+  });
+
+  afterEach(() => jest.restoreAllMocks());
+
+  test("executes compact JSON against a hidden lazy tool", async () => {
+    const { command, tools } = await makeHarness();
+    expect(tools.getToolNames()).not.toContain("hiddenEcho");
+
+    await command.handler(['{"name":"hiddenEcho","arguments":{"value":"hello world"}}']);
+
+    expect(log).toHaveBeenCalledWith('{\n  "value": "hello world"\n}');
+    expect(error).not.toHaveBeenCalled();
+  });
+
+  test("accepts an OpenAI-style tool call", async () => {
+    const { command } = await makeHarness();
+    await command.handler([
+      '{"id":"call-1","function":{"name":"hiddenEcho","arguments":{"value":"ok"}}}',
+    ]);
+    expect(log).toHaveBeenCalledWith('{\n  "value": "ok"\n}');
+  });
+
+  test("prints usage and actionable errors", async () => {
+    const { command } = await makeHarness();
+    await command.handler([]);
+    expect(log).toHaveBeenCalledWith(expect.stringContaining("Usage: /tool"));
+
+    await command.handler(["not-json"]);
+    expect(error).toHaveBeenCalledWith(expect.stringContaining("Invalid tool call JSON"));
+
+    await command.handler(['{"name":"missing","arguments":{}}']);
+    expect(error).toHaveBeenCalledWith(expect.stringContaining("Tool execution failed"));
+  });
+});

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"
+    );
+  });
+});