@tyvm/knowhow 0.0.157 → 0.0.159

package/README.md

@@ -49,7 +49,23 @@ If you want to paste a token manually:
 knowhow login --jwt
 ```
 
-After login, Knowhow stores your JWT in `.knowhow/.jwt` and updates `knowhow.json` so models can route through the Knowhow proxy.
+Authentication belongs to a named remote. `origin` is available by default and
+points to the production API. To use another compatible backend:
+
+```bash
+knowhow remote add dev https://api.dev.knowhow.tyvm.ai
+knowhow remote use dev
+knowhow login
+```
+
+Use `knowhow remote list` to show remotes and `knowhow remote get-url` to show
+the selected API. Each entry in `.knowhow/knowhow.json` stores its name, API URL,
+organization ID, and JWT path. Tokens remain independent: production uses
+`.knowhow/.jwt`, development uses `.knowhow/.jwt.dev`, localhost uses
+`.knowhow/.jwt.local`, and arbitrary hosts receive a host-specific filename.
+
+`KNOWHOW_API_URL` remains an explicit per-process override, which is useful when
+you only want to select a remote for one terminal command.
 
 ### First steps after setup
 Start the interactive chat:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tyvm/knowhow",
-  "version": "0.0.157",
+  "version": "0.0.159",
   "description": "ai cli with plugins and agents",
   "main": "ts_build/src/index.js",
   "bin": {
@@ -58,7 +58,7 @@
     "@inquirer/editor": "^4.2.18",
     "@modelcontextprotocol/sdk": "^1.13.3",
     "@simplewebauthn/server": "^13.3.0",
-    "@tyvm/knowhow-tunnel": "0.0.5",
+    "@tyvm/knowhow-tunnel": "0.0.6",
     "commander": "^14.0.0",
     "diff": "^5.2.0",
     "express": "^4.19.2",

package/src/agents/base/base.ts

@@ -49,6 +49,13 @@ type CachedChatCompletion = { messages: ChatCompletion["messages"] } & Partial<
   Omit<ChatCompletion, "messages">
 >;
 
+interface CompletedCompaction {
+  compressionEnd: number;
+  originalPrefix: Message[];
+  replacementPrefix: Message[];
+  summary: string;
+}
+
 /**
  * A source is anything that can (a) start producing data, (b) hand each datum to
  * a callback, and (c) be torn down. This is the unified contract behind
@@ -128,6 +135,12 @@ export abstract class BaseAgent implements IAgent {
   // regardless of whether the token threshold has been reached.
   protected _forceCompact = false;
 
+  // Compaction is intentionally detached from the main agent loop. A failed
+  // attempt is cleared so a later turn can retry without ending the task.
+  private _compactionPromise: Promise<void> | null = null;
+  private _completedCompaction: CompletedCompaction | null = null;
+  private _compactionGeneration = 0;
+
   // Interrupt support: resolves the currently awaited tool call or completion
   private _interruptResolve: (() => void) | null = null;
   // A monotonically-increasing token identifying the active interruptible window.
@@ -287,6 +300,10 @@ export abstract class BaseAgent implements IAgent {
   }
 
   newTask(taskId?: string) {
+    // Invalidate any detached compaction still finishing for the previous task.
+    this._compactionGeneration++;
+    this._compactionPromise = null;
+    this._completedCompaction = null;
     this.currentThread = 0;
     this.threads = [];
     this.taskBreakdown = "";
@@ -571,7 +588,11 @@ export abstract class BaseAgent implements IAgent {
     return this.totalCostUsd;
   }
 
-  adjustTokenUsage(usage: any, messages?: Message[]) {
+  adjustTokenUsage(
+    usage: any,
+    messages?: Message[],
+    updateLastPromptTokens = true
+  ) {
     if (!usage) return;
     // Support both OpenAI-style (prompt_tokens/completion_tokens) and Anthropic-style (input_tokens/output_tokens)
     const inputTokens = usage.input_tokens ?? usage.prompt_tokens ?? 0;
@@ -593,7 +614,7 @@ export abstract class BaseAgent implements IAgent {
     // (i.e. when there are input tokens) so a usage-less interrupt stub doesn't
     // reset it to 0.
     const promptTokens = inputTokens + cacheReadTokens + cacheWriteTokens;
-    if (promptTokens > 0) {
+    if (updateLastPromptTokens && promptTokens > 0) {
       this.lastPromptTokens = promptTokens;
     }
 
@@ -641,9 +662,10 @@ export abstract class BaseAgent implements IAgent {
     params: CachedChatCompletion,
     options: {
       interruptValue?: CompletionResponse;
+      updateLastPromptTokens?: boolean;
     } = {}
   ): Promise<CompletionResponse> {
-    const { interruptValue } = options;
+    const { interruptValue, updateLastPromptTokens = true } = options;
 
     // If you change the tools, or any of this, you bust cache
     // only safe to change messages
@@ -668,7 +690,11 @@ export abstract class BaseAgent implements IAgent {
       : await callPromise;
 
     this.adjustTotalCostUsd(response?.usd_cost);
-    this.adjustTokenUsage(response?.usage, params.messages);
+    this.adjustTokenUsage(
+      response?.usage,
+      params.messages,
+      updateLastPromptTokens
+    );
 
     return response;
   }
@@ -1276,28 +1302,59 @@ export abstract class BaseAgent implements IAgent {
       // prompt token count from the last completion response over the
       // whitespace-based estimate — so it compares real tokens against the
       // real (token-based) compress threshold.
+      const completedCompaction = this._completedCompaction;
+      this._completedCompaction = null;
+      let appliedCompaction = false;
+
+      if (completedCompaction) {
+        const currentPrefix = messages.slice(
+          0,
+          completedCompaction.compressionEnd
+        );
+        const prefixIsUnchanged = currentPrefix.every(
+          (message, index) =>
+            message === completedCompaction.originalPrefix[index] ||
+            JSON.stringify(message) ===
+              JSON.stringify(completedCompaction.originalPrefix[index])
+        );
+
+        if (
+          currentPrefix.length === completedCompaction.compressionEnd &&
+          prefixIsUnchanged
+        ) {
+          messages = [
+            ...completedCompaction.replacementPrefix,
+            ...messages.slice(completedCompaction.compressionEnd),
+          ];
+          this.summaries.push(completedCompaction.summary);
+          this.startNewThread(messages);
+          this.lastPromptTokens = 0;
+          appliedCompaction = true;
+        } else {
+          this.log(
+            "Discarding completed compaction because its source prefix changed; a later turn will retry",
+            "warn"
+          );
+        }
+      }
+
       const contextTokens = this.getContextTokenCount(messages);
       const overThreshold =
         contextTokens > this.getCompressThreshold() &&
         messages.length > this.compressMinMessages;
 
-      if (overThreshold || this._forceCompact) {
-        const taskBreakdown = await this.getTaskBreakdown(messages);
+      if (
+        !appliedCompaction &&
+        !this._compactionPromise &&
+        (overThreshold || this._forceCompact)
+      ) {
         this.log(
           this._forceCompact
-            ? `Compacting messages (manual /compact request): ${contextTokens} tokens`
-            : `Compressing messages: ${contextTokens} tokens exceeds ${this.getCompressThreshold()}`
+            ? `Starting background compaction (manual /compact request): ${contextTokens} tokens`
+            : `Starting background compaction: ${contextTokens} tokens exceeds ${this.getCompressThreshold()}`
         );
         this._forceCompact = false;
-        messages = await this.compressMessages(messages);
-        this.startNewThread(messages);
-        // Reset the real-token tracker. compressMessages() ran a completion over
-        // the older history, so lastPromptTokens reflects the compression input
-        // rather than the newly reconstructed thread. Zeroing it makes
-        // getContextTokenCount() estimate the new thread until the next regular
-        // completion reports fresh usage, preventing an immediate false
-        // re-compaction on the following iteration.
-        this.lastPromptTokens = 0;
+        this.startBackgroundCompaction(messages);
       }
 
       if (["assistant", "tool"].includes(messages[messages.length - 1].role)) {
@@ -1683,7 +1740,61 @@ export abstract class BaseAgent implements IAgent {
     return [...content, ...finalAnswer].join("\n\n");
   }
 
-  async getTaskBreakdown(messages: Message[]) {
+  private startBackgroundCompaction(messages: Message[]): void {
+    const snapshot = messages.slice();
+    let resumeIndex = snapshot.length - 1;
+    while (resumeIndex >= 0 && snapshot[resumeIndex].role !== "assistant") {
+      resumeIndex--;
+    }
+    const compressionEnd =
+      resumeIndex === -1 ? snapshot.length : resumeIndex;
+    const generation = this._compactionGeneration;
+
+    const promise = (async () => {
+      const taskBreakdown = await this.getTaskBreakdown(snapshot, false);
+      if (generation !== this._compactionGeneration) return;
+      this.taskBreakdown = taskBreakdown;
+      let summary = "";
+      const compactedSnapshot = await this.compressMessages(
+        snapshot,
+        (generatedSummary) => {
+          summary = generatedSummary;
+        },
+        taskBreakdown
+      );
+      if (generation !== this._compactionGeneration) return;
+
+      const preservedSnapshotLength = snapshot.length - compressionEnd;
+      this._completedCompaction = {
+        compressionEnd,
+        originalPrefix: snapshot.slice(0, compressionEnd),
+        replacementPrefix: compactedSnapshot.slice(
+          0,
+          compactedSnapshot.length - preservedSnapshotLength
+        ),
+        summary,
+      };
+      this.log("Background compaction completed; it will be applied next turn");
+    })();
+
+    this._compactionPromise = promise;
+    promise
+      .catch((error) => {
+        if (generation === this._compactionGeneration) {
+          this.log(
+            `Background compaction failed; a later turn will retry: ${error}`,
+            "warn"
+          );
+        }
+      })
+      .finally(() => {
+        if (this._compactionPromise === promise) {
+          this._compactionPromise = null;
+        }
+      });
+  }
+
+  async getTaskBreakdown(messages: Message[], cacheResult = true) {
     if (this.taskBreakdown) {
       return this.taskBreakdown;
     }
@@ -1708,10 +1819,13 @@ export abstract class BaseAgent implements IAgent {
       },
     ] as Message[];
 
-    const response = await this.createAgentCompletion({
-      messages: taskBreakdownMessages,
-      tool_choice: "none",
-    });
+    const response = await this.createAgentCompletion(
+      {
+        messages: taskBreakdownMessages,
+        tool_choice: "none",
+      },
+      { updateLastPromptTokens: false }
+    );
 
     const breakdownContent = this.extractContentFromMessages(
       response.choices?.map((c) => c.message)
@@ -1726,12 +1840,18 @@ export abstract class BaseAgent implements IAgent {
       );
     }
 
-    this.taskBreakdown = breakdownContent;
+    if (cacheResult) {
+      this.taskBreakdown = breakdownContent;
+    }
     this.log(`task breakdown cost: ${response.usd_cost}`);
-    return this.taskBreakdown;
+    return breakdownContent;
   }
 
-  async compressMessages(messages: Message[]) {
+  async compressMessages(
+    messages: Message[],
+    onSummary?: (summary: string) => void,
+    taskBreakdown = this.taskBreakdown
+  ) {
     // Preserve the latest agent interaction exactly. Starting the resumed thread
     // at the final assistant message keeps its tool calls, every tool response,
     // and any subsequent user messages together as one protocol-valid unit.
@@ -1757,8 +1877,8 @@ export abstract class BaseAgent implements IAgent {
     4. Tasks remaining - what tasks are left from the initial task breakdown.
 
     ${
-      this.taskBreakdown
-        ? `Our initial task breakdown: ${this.taskBreakdown}`
+      taskBreakdown
+        ? `Our initial task breakdown: ${taskBreakdown}`
         : ""
     }
 
@@ -1774,10 +1894,13 @@ export abstract class BaseAgent implements IAgent {
       },
     ] as Message[];
 
-    const response = await this.createAgentCompletion({
-      messages: compressMessagesPayload,
-      tool_choice: "none",
-    });
+    const response = await this.createAgentCompletion(
+      {
+        messages: compressMessagesPayload,
+        tool_choice: "none",
+      },
+      { updateLastPromptTokens: false }
+    );
 
     const summary = this.extractContentFromMessages(
       response.choices?.map((c) => c.message)
@@ -1788,15 +1911,19 @@ export abstract class BaseAgent implements IAgent {
       throw new Error("Compaction summary request returned no text content");
     }
 
-    this.summaries.push(summary);
+    if (onSummary) {
+      onSummary(summary);
+    } else {
+      this.summaries.push(summary);
+    }
 
     const startMessages = [
       {
         role: "user",
         content: `
         ${
-          this.taskBreakdown
-            ? `Initial task breakdown:\n        ${this.taskBreakdown}`
+          taskBreakdown
+            ? `Initial task breakdown:\n        ${taskBreakdown}`
             : "(No task breakdown available — summarize what you know from context above)"
         }
 

package/src/auth/browserLogin.ts

@@ -8,6 +8,7 @@ import * as path from "path";
 import { KNOWHOW_API_URL } from "../services/KnowhowClient";
 import { Spinner } from "./spinner";
 import { BrowserLoginError } from "./errors";
+import { storeJwtForApi } from "./jwtStore";
 
 // TypeScript interfaces for the CLI Login API
 
@@ -199,19 +200,7 @@ export class BrowserLoginService {
    * Securely stores the JWT token to the file system
    */
   private async storeJwt(jwt: string): Promise<void> {
-    const configDir = `${process.cwd()}/.knowhow`;
-    const jwtFile = `${configDir}/.jwt`;
-
-    // Ensure directory exists
-    if (!fs.existsSync(configDir)) {
-      fs.mkdirSync(configDir, { recursive: true });
-    }
-
-    // Write JWT to file
-    fs.writeFileSync(jwtFile, jwt, { mode: 0o600 });
-
-    // Ensure file has correct permissions (readable only by owner)
-    fs.chmodSync(jwtFile, 0o600);
+    storeJwtForApi(jwt, this.baseUrl);
   }
 
   /**

package/src/auth/environmentAuth.ts

@@ -0,0 +1,51 @@
+import { Config } from "../types";
+import { loadJwtFromDisk } from "./jwtStore";
+import { createRemote, findRemoteForApi, registerRemote } from "../remotes";
+
+/** Stable config key for authentication state owned by one API deployment. */
+export function getApiEnvironmentKey(apiUrl: string): string {
+  try {
+    const url = new URL(apiUrl);
+    return `${url.protocol}//${url.host}`.toLowerCase();
+  } catch {
+    return apiUrl.replace(/\/+$/, "").toLowerCase();
+  }
+}
+
+/** Read an organization claim without trusting the JWT for authorization. */
+export function getOrgIdFromJwt(jwt: string): string | undefined {
+  try {
+    const payload = JSON.parse(
+      Buffer.from(jwt.split(".")[1] ?? "", "base64url").toString("utf8")
+    ) as Record<string, unknown>;
+    const orgId = payload.org ?? payload.orgId ?? payload.org_id ?? payload.organizationId;
+    return typeof orgId === "string" && orgId ? orgId : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Resolve the org for the selected API without leaking another environment's org. */
+export function getOrgIdForApi(config: Config, apiUrl: string): string | undefined {
+  const remote = findRemoteForApi(config, apiUrl);
+  if (remote?.orgId) return remote.orgId;
+
+  // Read old orgIds only until this API has been represented as a remote.
+  const environmentKey = getApiEnvironmentKey(apiUrl);
+  const configured = config.orgIds?.[environmentKey];
+  if (configured) return configured;
+
+  const tokenOrgId = getOrgIdFromJwt(loadJwtFromDisk(apiUrl));
+  if (tokenOrgId) return tokenOrgId;
+
+  return config.remotes || (config.orgIds && Object.keys(config.orgIds).length > 0)
+    ? undefined
+    : config.orgId;
+}
+
+/** Record authentication state on the remote that owns it. */
+export function setOrgIdForApi(config: Config, apiUrl: string, orgId: string): void {
+  const remote = findRemoteForApi(config, apiUrl) ?? createRemote("origin", apiUrl);
+  registerRemote(config, { ...remote, orgId });
+  delete config.orgId;
+}

package/src/auth/jwtStore.ts

@@ -0,0 +1,70 @@
+import fs from "fs";
+import path from "path";
+import { findRemoteForApiSync, resolveJwtPath } from "../remotes";
+
+const PRODUCTION_API_HOST = "api.knowhow.tyvm.ai";
+
+/** Return a readable, environment-specific JWT filename for an API URL. */
+export function getJwtFileName(apiUrl: string): string {
+  try {
+    const { hostname, port } = new URL(apiUrl);
+    const normalizedHost = hostname.toLowerCase();
+
+    if (normalizedHost === PRODUCTION_API_HOST) return ".jwt";
+    if (
+      normalizedHost === "localhost" ||
+      normalizedHost === "::1" ||
+      normalizedHost.startsWith("127.")
+    ) {
+      return ".jwt.local";
+    }
+    if (normalizedHost === "api.dev.knowhow.tyvm.ai" || normalizedHost.includes(".dev.")) {
+      return ".jwt.dev";
+    }
+
+    const environment = `${normalizedHost}${port ? `-${port}` : ""}`
+      .replace(/[^a-z0-9.-]+/g, "-")
+      .replace(/^-+|-+$/g, "");
+    return environment ? `.jwt.${environment}` : ".jwt";
+  } catch {
+    return ".jwt";
+  }
+}
+
+export function getJwtFilePath(
+  apiUrl: string,
+  configDir = path.join(process.cwd(), ".knowhow")
+): string {
+  return path.join(configDir, getJwtFileName(apiUrl));
+}
+
+/**
+ * Load the JWT selected for an environment. The optional legacy path provides
+ * the directory for configs that historically pointed at `.jwt`.
+ */
+export function loadJwtFromDisk(apiUrl: string, legacyPath?: string): string {
+  const basePath = legacyPath ?? path.join(process.cwd(), ".knowhow", ".jwt");
+  const configuredPath = findRemoteForApiSync(apiUrl)?.jwtPath;
+  const jwtPath = configuredPath
+    ? resolveJwtPath(configuredPath)
+    : path.join(path.dirname(basePath), getJwtFileName(apiUrl));
+  return fs.existsSync(jwtPath)
+    ? fs.readFileSync(jwtPath, "utf8").trim()
+    : "";
+}
+
+/** Atomically store a JWT in the file selected for the API environment. */
+export function storeJwtForApi(jwt: string, apiUrl: string, configuredPath?: string): string {
+  const jwtFilePath = configuredPath ? resolveJwtPath(configuredPath) : getJwtFilePath(apiUrl);
+  const directory = path.dirname(jwtFilePath);
+  const temporaryPath = `${jwtFilePath}.${process.pid}.tmp`;
+  fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+  try {
+    fs.writeFileSync(temporaryPath, jwt, { mode: 0o600, flag: "wx" });
+    fs.renameSync(temporaryPath, jwtFilePath);
+    fs.chmodSync(jwtFilePath, 0o600);
+  } finally {
+    fs.rmSync(temporaryPath, { force: true });
+  }
+  return jwtFilePath;
+}

package/src/auth/keyAuth.ts

@@ -1,8 +1,7 @@
-import fs from "fs";
 import os from "os";
-import path from "path";
 import http from "../utils/http";
 import { getCliUserAgent } from "./browserLogin";
+import { storeJwtForApi } from "./jwtStore";
 import {
   getDefaultPrivateKeyPath,
   keyPairExists,
@@ -101,7 +100,7 @@ export async function authenticateWithKey(
   if (!keyPairExists(privateKeyPath) && !keyPairExists()) return false;
 
   try {
-    storeJwt(await exchangeAvailablePublicKeyJwt(orgId, apiUrl, privateKeyPath));
+    storeJwt(await exchangeAvailablePublicKeyJwt(orgId, apiUrl, privateKeyPath), apiUrl);
     return true;
   } catch (error: unknown) {
     // The identity is not registered for this environment/org (or was revoked).
@@ -138,16 +137,6 @@ export async function registerPublicKey(
   );
 }
 
-export function storeJwt(jwt: string): void {
-  const jwtFilePath = path.join(process.cwd(), ".knowhow", ".jwt");
-  const directory = path.dirname(jwtFilePath);
-  const temporaryPath = `${jwtFilePath}.${process.pid}.tmp`;
-  fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
-  try {
-    fs.writeFileSync(temporaryPath, jwt, { mode: 0o600, flag: "wx" });
-    fs.renameSync(temporaryPath, jwtFilePath);
-    fs.chmodSync(jwtFilePath, 0o600);
-  } finally {
-    fs.rmSync(temporaryPath, { force: true });
-  }
+export function storeJwt(jwt: string, apiUrl: string = DEFAULT_API_URL): void {
+  storeJwtForApi(jwt, apiUrl);
 }

package/src/auth/registerIdentity.ts

@@ -1,8 +1,9 @@
-import fs from "fs";
 import path from "path";
 import { getOrCreatePublicKey } from "./keyManager";
 import { registerPublicKey, exchangePublicKeyJwt, storeJwt } from "./keyAuth";
 import { getConfig, updateConfig } from "../config";
+import { getJwtFilePath, loadJwtFromDisk } from "./jwtStore";
+import { setOrgIdForApi } from "./environmentAuth";
 
 export interface RegisterIdentityOptions {
   /** Optional Ed25519 private-key path. Defaults to ~/.knowhow/keys/id_ed25519. */
@@ -36,30 +37,29 @@ export function extractOrgIdFromJwt(jwt: string): string {
 }
 
 /**
- * Register a CLI identity using the JWT already stored in the current project's
- * .knowhow/.jwt, then replace that JWT with one obtained via key authentication.
+ * Register a CLI identity using the JWT stored for the selected API, then
+ * replace that JWT with one obtained via key authentication.
  * This is intentionally generic: authorization scope is derived by the backend
  * from the verified source JWT.
  */
 export async function registerIdentity(options: RegisterIdentityOptions = {}): Promise<void> {
   const apiUrl = options.apiUrl ?? process.env.KNOWHOW_API_URL ?? "https://api.knowhow.tyvm.ai";
-  const jwtPath = path.join(process.cwd(), ".knowhow", ".jwt");
-  if (!fs.existsSync(jwtPath)) throw new Error(`JWT file not found: ${jwtPath}`);
-  const sourceJwt = fs.readFileSync(jwtPath, "utf8").trim();
+  const jwtPath = getJwtFilePath(apiUrl);
+  const sourceJwt = loadJwtFromDisk(apiUrl);
   if (!sourceJwt) throw new Error(`JWT file is empty: ${jwtPath}`);
 
   const orgId = extractOrgIdFromJwt(sourceJwt);
   const keyPair = getOrCreatePublicKey(options.identityPath);
   await registerPublicKey(sourceJwt, keyPair.publicKeyBase64, apiUrl);
   const identityJwt = await exchangePublicKeyJwt(orgId, apiUrl, options.identityPath);
-  storeJwt(identityJwt);
+  storeJwt(identityJwt, apiUrl);
 
   const config = await getConfig();
   if (!config.modelProviders) config.modelProviders = [];
   if (!config.modelProviders.some((provider: { provider: string }) => provider.provider === "knowhow")) {
     config.modelProviders.push({ provider: "knowhow" });
   }
-  config.orgId = orgId;
+  setOrgIdForApi(config, apiUrl, orgId);
   config.cliIdentityPath = path.resolve(options.identityPath ?? keyPair.privateKeyPath);
   await updateConfig(config);
 

package/src/cli.ts

@@ -63,6 +63,7 @@ import { addAgentsCommand } from "./commands/agents";
 import { addHashCommand } from "./commands/hash";
 import { addSandboxCommand } from "./commands/sandbox";
 import { addProcessesCommand } from "./commands/processes";
+import { addRemoteCommand } from "./commands/remote";
 
 // Handle unhandled promise rejections gracefully — particularly from MCP SDK
 // which fires errors via event emitters that can bypass Promise.allSettled.
@@ -106,6 +107,7 @@ async function main() {
   // Register all commands
   addInitCommand(program);
   addLoginCommand(program);
+  addRemoteCommand(program);
   addUpdateCommand(program);
   addGenerateCommand(program);
   addEmbedCommands(program);

package/src/clients/index.ts

@@ -31,6 +31,7 @@ import { ModelProvider } from "../types";
 import { getConfig, getConfigSync } from "../config";
 import { loadKnowhowJwt, KNOWHOW_API_URL } from "../services/KnowhowClient";
 import { keyPairExists } from "../auth/keyManager";
+import { getOrgIdForApi } from "../auth/environmentAuth";
 import { ContextLimits } from "./contextLimits";
 import { OpenAiTextPricing } from "./pricing/openai";
 import { AnthropicTextPricing } from "./pricing/anthropic";
@@ -112,8 +113,9 @@ const BUILT_IN_PROVIDER_REGISTRY: Record<string, ProviderRegistryEntry> = {
     createClient: (entry: ModelProvider) => {
       if (!loadKnowhowJwt()) {
         const config = getConfigSync();
+        const orgId = getOrgIdForApi(config, KNOWHOW_API_URL);
         if (
-          !config.orgId ||
+          !orgId ||
           (!keyPairExists(config.cliIdentityPath) && !keyPairExists())
         )
           return null;
@@ -1030,7 +1032,9 @@ export class AIClient {
   /**
    * Returns the context window limit (in tokens) for a given model.
    * Delegates to the registered client's getContextLimit() if available.
-   * Falls back to the global ContextLimits table.
+   * Falls back to the global ContextLimits table, stripping any leading
+   * provider prefix (e.g. "openai/gpt-5.6-sol" → "gpt-5.6-sol") so that
+   * proxied providers like "knowhow" resolve correctly.
    */
   getContextLimit(
     provider: string,
@@ -1040,9 +1044,25 @@ export class AIClient {
     if (client?.getContextLimit) {
       return client.getContextLimit(model);
     }
-    const contextLimit = ContextLimits[model];
-    if (contextLimit === undefined) return undefined;
-    return { contextLimit, threshold: contextLimit };
+    // Try the model as-is first, then strip leading "provider/" prefixes
+    // (e.g. "openai/gpt-5.6-sol" used with the "knowhow" proxy provider).
+    const candidates = [model];
+    if (model.includes("/")) {
+      const parts = model.split("/");
+      for (let i = 1; i < parts.length; i++) {
+        candidates.push(parts.slice(i).join("/"));
+      }
+    }
+    for (const candidate of candidates) {
+      const contextLimit = ContextLimits[candidate];
+      if (contextLimit !== undefined) {
+        const pricing = OpenAiTextPricing[candidate];
+        const threshold =
+          pricing && "input_gt_200k" in pricing ? 200_000 : contextLimit;
+        return { contextLimit, threshold };
+      }
+    }
+    return undefined;
   }
 
   /**