@tyvm/knowhow 0.0.148 → 0.0.150

package/src/processors/Base64ImageDetector.ts

@@ -251,6 +251,24 @@ export class Base64ImageProcessor {
     }
   }
 
+  private isUsableImageUrl(url: unknown): url is string {
+    if (typeof url !== "string") return false;
+
+    // Data URLs are only usable when they contain an image format this processor
+    // recognizes. In particular, reject TokenCompressor placeholders that happen
+    // to be located inside an otherwise valid-looking image_url content part.
+    if (url.startsWith("data:")) {
+      return this.isBase64Image(url).isImage;
+    }
+
+    try {
+      const parsed = new URL(url);
+      return parsed.protocol === "http:" || parsed.protocol === "https:";
+    } catch {
+      return false;
+    }
+  }
+
   private processToolMessageContent(message: Message): void {
     // Tool messages have string content that might be a JSON string containing image data
     if (typeof message.content === "string" && message.content.trim()) {
@@ -267,13 +285,19 @@ export class Base64ImageProcessor {
         //  model to see a raw base64 JSON string instead of an actual image.)
         const candidates = Array.isArray(parsed) ? parsed : [parsed];
         const isImagePart = (p: any) =>
-          p && p.type === "image_url" && p.image_url?.url;
+          p &&
+          p.type === "image_url" &&
+          this.isUsableImageUrl(p.image_url?.url);
         const isTextPart = (p: any) =>
           p && p.type === "text" && typeof p.text === "string";
+        const hasInvalidImagePart = candidates.some(
+          (p: any) => p?.type === "image_url" && !isImagePart(p)
+        );
 
-        // Only rewrite the content if it actually contains at least one image
-        // part; otherwise leave the original tool text untouched.
-        if (candidates.some(isImagePart)) {
+        // Only rewrite content containing valid provider-ready images. If an
+        // image URL was compressed or is malformed, preserve the JSON as text so
+        // the agent can inspect/expand it instead of failing the next API call.
+        if (!hasInvalidImagePart && candidates.some(isImagePart)) {
           message.content = candidates.filter(
             (p) => isImagePart(p) || isTextPart(p)
           );

package/src/processors/JsonCompressor.ts

@@ -398,6 +398,20 @@ export class JsonCompressor {
     }
 
 
+    // Image content parts must remain atomic. Compressing a data URL independently
+    // leaves a valid-looking image_url object whose URL is only a placeholder.
+    // The containing response can still be compressed, but expanding it must
+    // restore an image part with its usable URL intact.
+    if (
+      obj &&
+      typeof obj === "object" &&
+      !Array.isArray(obj) &&
+      obj.type === "image_url" &&
+      typeof obj.image_url?.url === "string"
+    ) {
+      return obj;
+    }
+
     // Handle objects - try low-signal detection first, then process properties (depth-first)
     if (obj && typeof obj === "object") {
       // Check if this exact object (by original content) is a duplicate

package/src/processors/TokenCompressor.ts

@@ -45,6 +45,22 @@ export class TokenCompressor implements JsonCompressorStorage {
   // JSON compression handler
   private jsonCompressor: JsonCompressor;
 
+
+  /**
+   * Tool names whose responses should never be compressed.
+   * These are compression/retrieval tools themselves - compressing their output
+   * would prevent the agent from seeing the uncompressed data it just retrieved.
+   */
+  static DO_NOT_COMPRESS: ReadonlySet<string> = new Set([
+    "expandTokens",
+    "grepToolResponse",
+    "jqToolResponse",
+    "tailToolResponse",
+    "listStoredToolResponses",
+    "loadImageAsBase64" // need a proper way to do this
+  ]);
+
+
   constructor(toolsService?: ToolsService) {
     this.jsonCompressor = new JsonCompressor(
       this,
@@ -290,19 +306,6 @@ export class TokenCompressor implements JsonCompressorStorage {
     }
   }
 
-  /**
-   * Tool names whose responses should never be compressed.
-   * These are compression/retrieval tools themselves - compressing their output
-   * would prevent the agent from seeing the uncompressed data it just retrieved.
-   */
-  static readonly COMPRESSION_TOOL_NAMES: ReadonlySet<string> = new Set([
-    "expandTokens",
-    "grepToolResponse",
-    "jqToolResponse",
-    "tailToolResponse",
-    "listStoredToolResponses",
-  ]);
-
   createProcessor(
     filterFn?: (msg: Message) => boolean
   ): MessageProcessorFunction {
@@ -344,7 +347,7 @@ export class TokenCompressor implements JsonCompressorStorage {
         if (
           message.role === "tool" &&
           message.name &&
-          TokenCompressor.COMPRESSION_TOOL_NAMES.has(message.name)
+          TokenCompressor.DO_NOT_COMPRESS.has(message.name)
         ) {
           continue;
         }

package/src/services/AgentService.ts

@@ -76,14 +76,14 @@ export class AgentService {
     return this.agentContext ?? { Tools: this.tools, Events: this.events };
   }
 
-  public getAgent(name: string): IAgent {
+  public getAgent<T extends IAgent = IAgent>(name: string): T {
     const agent = this.agents.get(name);
     if (!agent) {
       throw new Error(
         `Agent ${name} not found. Options are: ${this.listAgents()}`
       );
     }
-    return agent;
+    return agent as T;
   }
 
   public listAgents(): string[] {

package/src/services/AgentSyncFs.ts

@@ -87,6 +87,47 @@ export class AgentSyncFs {
     }
   }
 
+  /**
+   * Clean up old managed-process directories (.knowhow/processes/<id>/) that
+   * were created by spawnManaged / execCommand.  These are identified by the
+   * presence of a status.json file inside the directory.  Only directories
+   * older than maxAgeMs are removed.
+   */
+  static async cleanupOldManagedProcessDirs(maxAgeMs: number): Promise<void> {
+    try {
+      const processesPath = path.dirname(AgentSyncFs.sharedBasePath);
+
+      try {
+        await fs.access(processesPath);
+      } catch {
+        return;
+      }
+
+      const entries = await fs.readdir(processesPath, { withFileTypes: true });
+      const now = Date.now();
+
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const dirPath = path.join(processesPath, entry.name);
+        const statusPath = path.join(dirPath, "status.json");
+
+        try {
+          await fs.access(statusPath);
+          const stats = await fs.stat(dirPath);
+          const age = now - stats.mtimeMs;
+          if (age > maxAgeMs) {
+            console.log(`🧹 Cleaning up old process directory: ${entry.name}`);
+            await fs.rm(dirPath, { recursive: true, force: true });
+          }
+        } catch {
+          // No status.json or can't stat — skip (e.g. the agents/ subdir)
+        }
+      }
+    } catch (error) {
+      console.error(`❌ Error during managed process dir cleanup:`, error);
+    }
+  }
+
   /**
    * Update task status
    */
@@ -617,6 +658,7 @@ export class AgentSyncFs {
 
       // Also clean up old execCommand background log files in .knowhow/processes/*.txt
       await AgentSyncFs.cleanupOldProcessLogs(threeDaysMs);
+      await AgentSyncFs.cleanupOldManagedProcessDirs(threeDaysMs);
     } catch (error) {
       console.error(`❌ Error during cleanup:`, error);
     }

package/src/services/modules/computerUse.ts

@@ -26,13 +26,15 @@ export interface Region extends Point, Size {}
 export type MouseButton = "left" | "right" | "middle";
 
 export interface OverlayPrimitive {
-  kind: "rect" | "circle" | "line" | "point";
+  kind: "rect" | "circle" | "line" | "point" | "text";
   x: number;
   y: number;
   width?: number;
   height?: number;
   x2?: number;
   y2?: number;
+  text?: string;
+  fontSize?: number;
   color?: string;
   lineWidth?: number;
 }

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

@@ -0,0 +1,23 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { saveHashes } from "../../src/hashes";
+
+describe("saveHashes", () => {
+  it("creates the .knowhow directory in a fresh checkout", async () => {
+    const originalCwd = process.cwd();
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "knowhow-hashes-"));
+
+    try {
+      process.chdir(tempDir);
+      await saveHashes({ build: { input: "abc123" } });
+
+      expect(
+        JSON.parse(fs.readFileSync(".knowhow/.hashes.json", "utf8"))
+      ).toEqual({ build: { input: "abc123" } });
+    } finally {
+      process.chdir(originalCwd);
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+});

package/ts_build/package.json

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

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

@@ -1039,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,
@@ -1049,9 +1048,13 @@ 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) {
         let resumeIndex = messages.length - 1;
@@ -1072,7 +1075,7 @@ 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 replace the older history. The latest agent interaction will remain verbatim:
 
@@ -1086,18 +1089,20 @@ 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
         `,