@tyvm/knowhow 0.0.147 → 0.0.149

package/tests/clients/AIClient.test.ts

@@ -187,6 +187,98 @@ describe("AIClient", () => {
       expect(result.model).toBe("unknown-model");
     });
 
+    // ── New tests: explicit provider + slashed model prefix stripping ────────
+
+    it("knowhow provider: resolves 'anthropic/claude-sonnet-4-6' to model stored as 'anthropic/claude-sonnet-4-6'", () => {
+      aiClient.registerClient("knowhow", new FakeClient());
+      aiClient.registerModels("knowhow", [
+        "anthropic/claude-sonnet-4-6",
+        "openai/gpt-4",
+        "google/gemini-pro",
+      ]);
+
+      // Exact match: provider=knowhow, model=anthropic/claude-sonnet-4-6
+      const result = aiClient.detectProviderModel("knowhow", "anthropic/claude-sonnet-4-6");
+      expect(result.provider).toBe("knowhow");
+      expect(result.model).toBe("anthropic/claude-sonnet-4-6");
+    });
+
+    it("knowhow provider: resolves bare 'claude-sonnet-4-6' to 'anthropic/claude-sonnet-4-6' stored on knowhow", () => {
+      aiClient.registerClient("knowhow", new FakeClient());
+      aiClient.registerModels("knowhow", [
+        "anthropic/claude-sonnet-4-6",
+        "openai/gpt-4",
+      ]);
+
+      // Bare model name — should resolve by stripping the provider prefix from
+      // the registered model and matching on the trailing segment
+      const result = aiClient.detectProviderModel("knowhow", "claude-sonnet-4-6");
+      expect(result.provider).toBe("knowhow");
+      expect(result.model).toBe("anthropic/claude-sonnet-4-6");
+    });
+
+    it("fireworks provider: resolves 'kimi-k3' to 'accounts/fireworks/models/kimi-k3'", () => {
+      aiClient.registerClient("fireworks", new FakeClient());
+      aiClient.registerModels("fireworks", [
+        "accounts/fireworks/models/kimi-k3",
+        "accounts/fireworks/models/kimi-k2p7-code",
+        "accounts/fireworks/models/minimax-m3",
+        "accounts/fireworks/models/deepseek-v3-2",
+      ]);
+
+      const result = aiClient.detectProviderModel("fireworks", "kimi-k3");
+      expect(result.provider).toBe("fireworks");
+      expect(result.model).toBe("accounts/fireworks/models/kimi-k3");
+    });
+
+    it("fireworks provider: resolves 'accounts/fireworks/models/kimi-k3' (full path) correctly", () => {
+      aiClient.registerClient("fireworks", new FakeClient());
+      aiClient.registerModels("fireworks", [
+        "accounts/fireworks/models/kimi-k3",
+        "accounts/fireworks/models/deepseek-v4-pro",
+      ]);
+
+      // Full path exact match
+      const result = aiClient.detectProviderModel("fireworks", "accounts/fireworks/models/kimi-k3");
+      expect(result.provider).toBe("fireworks");
+      expect(result.model).toBe("accounts/fireworks/models/kimi-k3");
+    });
+
+    it("explicit provider: does NOT leak to a different provider when stripping slashes", () => {
+      aiClient.registerClient("knowhow", new FakeClient());
+      aiClient.registerModels("knowhow", ["anthropic/claude-sonnet-4-6"]);
+
+      // 'fake' provider doesn't have this model — should not find it on knowhow
+      const result = aiClient.detectProviderModel("fake", "claude-sonnet-4-6");
+      // Falls back: provider=fake, model=claude-sonnet-4-6 (no cross-provider leak)
+      expect(result.provider).toBe("fake");
+      expect(result.model).toBe("claude-sonnet-4-6");
+    });
+
+    it("empty provider: finds 'claude-sonnet-4-6' cross-provider on knowhow (stored as 'anthropic/claude-sonnet-4-6')", () => {
+      aiClient.registerClient("knowhow", new FakeClient());
+      aiClient.registerModels("knowhow", [
+        "anthropic/claude-sonnet-4-6",
+        "openai/gpt-4",
+      ]);
+
+      const result = aiClient.detectProviderModel("", "claude-sonnet-4-6");
+      expect(result.provider).toBe("knowhow");
+      expect(result.model).toBe("anthropic/claude-sonnet-4-6");
+    });
+
+    it("empty provider: finds 'kimi-k3' cross-provider on fireworks (stored as 'accounts/fireworks/models/kimi-k3')", () => {
+      aiClient.registerClient("fireworks", new FakeClient());
+      aiClient.registerModels("fireworks", [
+        "accounts/fireworks/models/kimi-k3",
+        "accounts/fireworks/models/deepseek-v4-pro",
+      ]);
+
+      const result = aiClient.detectProviderModel("", "kimi-k3");
+      expect(result.provider).toBe("fireworks");
+      expect(result.model).toBe("accounts/fireworks/models/kimi-k3");
+    });
+
     it("should detect real provider when model exists", () => {
       // Register an anthropic provider explicitly so we don't rely on env vars
       aiClient.registerClient("anthropic", new FakeClient());
@@ -442,14 +534,14 @@ describe("AIClient", () => {
     });
 
     it("should handle empty provider and model strings", () => {
-      // Empty strings should return default OpenAI client with gpt-5
-      const result = aiClient.getClient("", "");
-      expect(result.provider.length).toBeGreaterThan(0);
-      expect(result.model.length).toBeGreaterThan(0);
+      // Empty provider + empty model: detectProviderModel returns the fallback (empty strings)
+      // getClient("", "") throws because "" is not a registered provider
+      expect(() => aiClient.getClient("", "")).toThrow();
 
       const detection = aiClient.detectProviderModel("", "");
-      expect(detection?.provider?.length).toBeGreaterThan(0);
-      expect(detection?.model?.length).toBeGreaterThan(0);
+      // Falls back to original values — both empty
+      expect(detection?.provider).toBe("");
+      expect(detection?.model).toBe("");
     });
 
     it("should handle malformed model formats", () => {
@@ -469,15 +561,6 @@ describe("AIClient", () => {
         expect(detection).toBeDefined();
         expect(detection?.provider).toBeDefined();
         expect(detection?.model).toBeDefined();
-        // For malformed inputs that can't be parsed, should fallback to defaults
-        if (
-          input === "provider/" ||
-          input === "///" ||
-          input === "provider/model/"
-        ) {
-          expect(detection?.provider?.length).toBeGreaterThan(0);
-          expect(detection?.model?.length).toBeGreaterThan(0);
-        }
       });
     });
 

package/tests/processes/managedProcessShim.test.ts

@@ -0,0 +1,59 @@
+import { spawn } from "child_process";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+
+describe("managed process shim", () => {
+  const testOnPosix = process.platform === "win32" ? test.skip : test;
+
+  testOnPosix("exits after a short command instead of leaking the shim process", async () => {
+    const directory = fs.mkdtempSync(path.join(os.tmpdir(), "knowhow-shim-test-"));
+    const configPath = path.join(directory, "launch.json");
+    const shimModule = path.resolve(__dirname, "../../src/processes/managedProcessShim");
+    fs.writeFileSync(configPath, JSON.stringify({
+      id: "short-command",
+      command: process.execPath,
+      args: ["-e", "process.exit(0)"],
+      cwd: directory,
+      env: {},
+      background: true,
+      parentProcessId: null,
+      parentPid: null,
+      shell: false,
+      processesDir: path.dirname(directory),
+    }));
+
+    const script = `require(${JSON.stringify(shimModule)})`
+      + `.runManagedProcessShim(${JSON.stringify(configPath)})`
+      + `.catch(error => { console.error(error); process.exitCode = 1; });`;
+    const shim = spawn(process.execPath, ["-r", "ts-node/register/transpile-only", "-e", script], {
+      cwd: path.resolve(__dirname, "../.."),
+      stdio: ["ignore", "ignore", "pipe"],
+    });
+    let stderr = "";
+    shim.stderr!.setEncoding("utf8");
+    shim.stderr!.on("data", (chunk) => { stderr += chunk; });
+
+    try {
+      const result = await new Promise<{ code: number | null; signal: NodeJS.Signals | null }>((resolve, reject) => {
+        const timer = setTimeout(() => {
+          shim.kill("SIGKILL");
+          reject(new Error(`Shim PID ${shim.pid} did not exit after its command completed`));
+        }, 10000);
+        shim.once("exit", (code, signal) => {
+          clearTimeout(timer);
+          resolve({ code, signal });
+        });
+      });
+
+      expect(stderr).toBe("");
+      expect(result).toEqual({ code: 0, signal: null });
+      const status = JSON.parse(fs.readFileSync(path.join(directory, "status.json"), "utf8"));
+      expect(status).toMatchObject({ shimPid: shim.pid, state: "exited", exitCode: 0 });
+      expect(() => process.kill(shim.pid!, 0)).toThrow();
+    } finally {
+      if (shim.exitCode === null && shim.signalCode === null) shim.kill("SIGKILL");
+      fs.rmSync(directory, { recursive: true, force: true });
+    }
+  });
+});

package/tests/processors/Base64ImageDetector.test.ts

@@ -220,6 +220,27 @@ describe("Base64ImageDetector", () => {
       expect(content[0].image_url.url).toBe(imageDataUrl);
     });
 
+    it("should not promote a compressed image URL placeholder to image content", () => {
+      const toolResponseJson = JSON.stringify({
+        type: "image_url",
+        image_url: {
+          url: "[COMPRESSED_JSON_PROPERTY - 24614 tokens]\nKey: compressed_image_url",
+          detail: "high",
+        },
+      });
+      const modifiedMessages: Message[] = [
+        {
+          role: "tool",
+          content: toolResponseJson,
+          tool_call_id: "call_compressed_image",
+        },
+      ];
+
+      detector.createProcessor()([], modifiedMessages);
+
+      expect(modifiedMessages[0].content).toBe(toolResponseJson);
+    });
+
     it("should process tool messages with plain base64 string", () => {
       const validPngBase64 =
         "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg==";

package/tests/processors/TokenCompressor.test.ts

@@ -415,6 +415,24 @@ describe("TokenCompressor", () => {
     });
   });
 
+  describe("image content compression", () => {
+    it("keeps image URLs intact when expanded", () => {
+      const imageUrl = `data:image/png;base64,${"A".repeat(20_000)}`;
+      const content = JSON.stringify({
+        type: "image_url",
+        image_url: { url: imageUrl, detail: "high" },
+      });
+
+      const compressed = tokenCompressor.compressContent(content);
+      const key = compressed.match(/Key:\s*(\S+)/)?.[1];
+
+      expect(key).toBeDefined();
+      const expanded = tokenCompressor.retrieveFullString(key!);
+      expect(expanded).toBe(content);
+      expect(expanded).not.toContain("[COMPRESSED_JSON_PROPERTY");
+    });
+  });
+
   describe("tool function integration", () => {
     it("should register expandTokens function correctly", () => {
       const toolsServiceCalls = mockToolsService.addFunctions.mock.calls;

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

@@ -0,0 +1,93 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+
+const registerPublicKey = jest.fn();
+const exchangePublicKeyJwt = jest.fn();
+const storeJwt = jest.fn();
+const getOrCreatePublicKey = jest.fn();
+const getConfig = jest.fn();
+const updateConfig = jest.fn();
+
+jest.mock("../../../src/auth/keyAuth", () => ({ registerPublicKey, exchangePublicKeyJwt, storeJwt }));
+jest.mock("../../../src/auth/keyManager", () => ({ getOrCreatePublicKey }));
+jest.mock("../../../src/config", () => ({ getConfig, updateConfig }));
+
+import { decodeJwtPayload, extractOrgIdFromJwt, registerIdentity } from "../../../src/auth/registerIdentity";
+
+function makeJwt(payload: Record<string, unknown>): string {
+  return `${Buffer.from("{}").toString("base64url")}.${Buffer.from(JSON.stringify(payload)).toString("base64url")}.sig`;
+}
+
+describe("registerIdentity", () => {
+  const originalCwd = process.cwd();
+  let workDir: string;
+  const sourceJwt = makeJwt({ org: "org-test" });
+  const publicKeyBase64 = Buffer.alloc(32, 5).toString("base64");
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.spyOn(console, "log").mockImplementation(() => undefined);
+    workDir = fs.mkdtempSync(path.join(os.tmpdir(), "knowhow-register-identity-"));
+    fs.mkdirSync(path.join(workDir, ".knowhow"), { recursive: true });
+    fs.writeFileSync(path.join(workDir, ".knowhow", ".jwt"), sourceJwt);
+    process.chdir(workDir);
+    getOrCreatePublicKey.mockReturnValue({
+      publicKeyBase64,
+      fingerprint: "SHA256:test",
+      privateKeyPath: path.join(workDir, ".knowhow", "keys", "id_ed25519"),
+    });
+    registerPublicKey.mockResolvedValue(undefined);
+    exchangePublicKeyJwt.mockResolvedValue("identity.jwt.token");
+    getConfig.mockResolvedValue({ modelProviders: [] });
+    updateConfig.mockResolvedValue(undefined);
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    fs.rmSync(workDir, { recursive: true, force: true });
+    jest.restoreAllMocks();
+  });
+
+  it("registers from the project JWT and stores the exchanged JWT", async () => {
+    await registerIdentity({ apiUrl: "https://api.example" });
+    expect(registerPublicKey).toHaveBeenCalledWith(sourceJwt, publicKeyBase64, "https://api.example");
+    expect(exchangePublicKeyJwt).toHaveBeenCalledWith("org-test", "https://api.example", undefined);
+    expect(storeJwt).toHaveBeenCalledWith("identity.jwt.token");
+    expect(updateConfig).toHaveBeenCalledWith(expect.objectContaining({
+      orgId: "org-test",
+      modelProviders: [{ provider: "knowhow" }],
+      cliIdentityPath: expect.stringContaining("id_ed25519"),
+    }));
+  });
+
+  it("uses an explicitly selected identity", async () => {
+    await registerIdentity({ identityPath: "/keys/id", apiUrl: "https://api.example" });
+    expect(getOrCreatePublicKey).toHaveBeenCalledWith("/keys/id");
+    expect(exchangePublicKeyJwt).toHaveBeenCalledWith("org-test", "https://api.example", "/keys/id");
+  });
+
+  it("requires a nonempty project JWT", async () => {
+    fs.writeFileSync(path.join(workDir, ".knowhow", ".jwt"), " ");
+    await expect(registerIdentity()).rejects.toThrow("JWT file is empty");
+    expect(registerPublicKey).not.toHaveBeenCalled();
+  });
+
+  it("does not replace the JWT when registration fails", async () => {
+    registerPublicKey.mockRejectedValue(new Error("registration failed"));
+    await expect(registerIdentity()).rejects.toThrow("registration failed");
+    expect(storeJwt).not.toHaveBeenCalled();
+  });
+});
+
+describe("JWT organization extraction", () => {
+  it("decodes payload and accepts canonical org", () => {
+    expect(decodeJwtPayload(makeJwt({ org: "one" }))).toMatchObject({ org: "one" });
+    expect(extractOrgIdFromJwt(makeJwt({ org: "one" }))).toBe("one");
+  });
+
+  it("rejects malformed and organization-less JWTs", () => {
+    expect(() => decodeJwtPayload("invalid")).toThrow("Invalid JWT format");
+    expect(() => extractOrgIdFromJwt(makeJwt({ sub: "user" }))).toThrow("organization claim");
+  });
+});

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

@@ -9,7 +9,7 @@ const setupServices = jest.fn().mockResolvedValue(undefined);
 jest.mock("../../../src/chat", () => ({ startChat }));
 jest.mock("../../../src/commands/services", () => ({ setupServices }));
 
-import { addAgentsCommand } from "../../../src/commands/agents";
+import { addAgentsCommand, getStatus } from "../../../src/commands/agents";
 
 describe("agents resume terminal UX", () => {
   let previousCwd: string;
@@ -66,3 +66,46 @@ describe("agents resume terminal UX", () => {
     );
   });
 });
+
+describe("agents effective status", () => {
+  let previousCwd: string;
+  let tempDir: string;
+
+  beforeEach(() => {
+    previousCwd = process.cwd();
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "knowhow-agent-status-"));
+    process.chdir(tempDir);
+  });
+
+  afterEach(() => {
+    process.chdir(previousCwd);
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  test("keeps a running status when the recorded process is alive", () => {
+    expect(getStatus("task", { status: "running", pid: process.pid })).toBe(
+      "running"
+    );
+  });
+
+  test("reports a running task as failed when its process exited", () => {
+    expect(getStatus("task", { status: "running", pid: 2_147_483_647 })).toBe(
+      "failed"
+    );
+  });
+
+  test("reports old legacy running records without a pid as stale", () => {
+    expect(
+      getStatus("task", {
+        status: "running",
+        lastUpdate: new Date(Date.now() - 10 * 60 * 1000).toISOString(),
+      })
+    ).toBe("stale");
+  });
+
+  test("never overrides a persisted terminal status", () => {
+    expect(getStatus("task", { status: "completed", pid: process.pid })).toBe(
+      "completed"
+    );
+  });
+});

package/tests/unit/services/LazyToolsService.test.ts

@@ -26,4 +26,28 @@ describe("LazyToolsService persisted tool restoration", () => {
       "finalAnswer",
     ]);
   });
+
+  test("calls a registered hidden tool without making it prompt-visible", async () => {
+    const tools = new LazyToolsService();
+    tools.addTools([tool("hiddenTool")]);
+    tools.setFunction("hiddenTool", ({ value }: { value: string }) => `got:${value}`);
+
+    expect(tools.getToolNames()).not.toContain("hiddenTool");
+    expect(tools.getFunctionNames()).toContain("hiddenTool");
+
+    const result = await tools.callTool({
+      id: "hidden-call",
+      type: "function",
+      function: {
+        name: "hiddenTool",
+        arguments: JSON.stringify({ value: "test" }),
+      },
+    });
+
+    expect(result.functionResp).toBe("got:test");
+    expect(tools.getToolNames()).not.toContain("hiddenTool");
+    expect(tools.listAvailableTools()).toMatchObject({
+      disabled: expect.arrayContaining(["hiddenTool"]),
+    });
+  });
 });

package/ts_build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@tyvm/knowhow",
-    "version": "0.0.147",
+    "version": "0.0.149",
     "description": "ai cli with plugins and agents",
     "main": "ts_build/src/index.js",
     "bin": {

package/ts_build/src/agents/base/base.d.ts

@@ -192,5 +192,5 @@ export declare abstract class BaseAgent implements IAgent {
         content: string;
     } | null;
     getTaskBreakdown(messages: Message[]): Promise<string>;
-    compressMessages(messages: Message[], startIndex: number, endIndex: number): Promise<Message[]>;
+    compressMessages(messages: Message[]): Promise<Message[]>;
 }

package/ts_build/src/agents/base/base.js

@@ -647,8 +647,6 @@ let BaseAgent = class BaseAgent {
             messages = this.formatInputMessages(messages);
             this.updateCurrentThread(messages);
             const isMissingTool = this.isRequiredToolMissing();
-            const startIndex = 0;
-            const endIndex = messages.length;
             messages = await this.messageProcessor.processMessages(messages, "pre_call");
             const interruptResponse = {
                 choices: [
@@ -784,7 +782,7 @@ let BaseAgent = class BaseAgent {
                     ? `Compacting messages (manual /compact request): ${contextTokens} tokens`
                     : `Compressing messages: ${contextTokens} tokens exceeds ${this.getCompressThreshold()}`);
                 this._forceCompact = false;
-                messages = await this.compressMessages(messages, startIndex, endIndex);
+                messages = await this.compressMessages(messages);
                 this.startNewThread(messages);
                 this.lastPromptTokens = 0;
             }
@@ -1041,8 +1039,7 @@ let BaseAgent = class BaseAgent {
         const response = await this.createAgentCompletion({
             model,
             messages: taskBreakdownMessages,
-            tools: this.getEnabledTools(),
-            tool_choice: "auto",
+            tool_choice: "none",
             long_ttl_cache: this.runTime() > 300_000,
             ...(this.reasoningEffort !== undefined && {
                 reasoning_effort: this.reasoningEffort,
@@ -1051,13 +1048,24 @@ let BaseAgent = class BaseAgent {
                 reasoning_summary: this.summarizeReasoning,
             }),
         });
-        this.taskBreakdown = response.choices[0].message.content;
+        const breakdownContent = response.choices
+            .map((c) => c.message.content)
+            .filter((s) => typeof s === "string" && s.trim().length > 0)
+            .join("\n\n");
+        this.taskBreakdown = breakdownContent || "";
         this.log(`task breakdown cost: ${response.usd_cost}`);
-        return this.taskBreakdown;
+        return this.taskBreakdown || undefined;
     }
-    async compressMessages(messages, startIndex, endIndex) {
-        this.log(`Compressing messages from ${startIndex} to ${endIndex}, total messages: ${messages.length}`);
-        const toCompress = messages.slice(startIndex, endIndex);
+    async compressMessages(messages) {
+        let resumeIndex = messages.length - 1;
+        while (resumeIndex >= 0 &&
+            messages[resumeIndex].role !== "assistant") {
+            resumeIndex--;
+        }
+        const compressionEnd = resumeIndex === -1 ? messages.length : resumeIndex;
+        const toCompress = messages.slice(0, compressionEnd);
+        const resumeMessages = messages.slice(compressionEnd);
+        this.log(`Compressing messages from 0 to ${compressionEnd}, resuming from ${resumeIndex}, total messages: ${messages.length}`);
         const toCompressPrompt = `We are compressing our conversation to save memory.
     Please summarize the conversation so far, so that we may continue the original task with a smaller context
 
@@ -1067,14 +1075,13 @@ let BaseAgent = class BaseAgent {
     3. Next Steps - what we're about to do next to continue the user's original request.
     4. Tasks remaining - what tasks are left from the initial task breakdown.
 
-    Our initial task breakdown: ${this.taskBreakdown}
+    ${this.taskBreakdown ? `Our initial task breakdown: ${this.taskBreakdown}` : ""}
 
-    This summary will become the agent's only memory of the past, all other messages will be dropped:
+    This summary will replace the older history. The latest agent interaction will remain verbatim:
 
       `;
-        const model = this.getModel();
         const compressMessagesPayload = [
-            ...messages,
+            ...toCompress,
             {
                 role: "user",
                 content: toCompressPrompt,
@@ -1082,28 +1089,30 @@ let BaseAgent = class BaseAgent {
         ];
         const response = await this.createAgentCompletion({
             messages: compressMessagesPayload,
+            tool_choice: "none",
         });
-        const summaries = response.choices.map((c) => c.message.content);
+        const summaries = response.choices
+            .map((c) => c.message.content)
+            .filter((s) => typeof s === "string" && s.trim().length > 0);
         this.summaries.push(...summaries);
         const startMessages = [
             {
                 role: "user",
                 content: `
-        Initial task breakdown:
-        ${this.taskBreakdown}
+        ${this.taskBreakdown ? `Initial task breakdown:\n        ${this.taskBreakdown}` : "(No task breakdown available — summarize what you know from context above)"}
 
         We have just compressed the conversation to save memory:
-        ${JSON.stringify(summaries)}
+        ${summaries.length > 0 ? JSON.stringify(summaries) : "(summary unavailable — please continue from the task breakdown above)"}
 
         Please continue the task from where we left off
         `,
             },
         ];
-        const systemMesasges = toCompress.filter((m) => m.role === "system");
+        const systemMessages = toCompress.filter((m) => m.role === "system");
         const newMessages = [
-            ...systemMesasges,
+            ...systemMessages,
             ...startMessages,
-            ...messages.slice(endIndex),
+            ...resumeMessages,
         ];
         const oldLength = this.getMessagesLength(messages);
         const newLength = this.getMessagesLength(newMessages);