claudish 7.40.0 → 7.42.0

package/dist/index.js

@@ -729,7 +729,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "7.40.0";
+var VERSION = "7.42.0";
 
 // src/logger.ts
 var exports_logger = {};
@@ -27958,6 +27958,26 @@ var init_provider_definitions = __esm(() => {
       isDirectApi: true,
       description: "Antigravity subscription (ag@; go@ deprecated)"
     },
+    {
+      name: "devin",
+      displayName: "Devin",
+      transport: "devin",
+      baseUrl: "https://server.codeium.com",
+      baseUrlEnvVars: ["WINDSURF_API_SERVER_URL"],
+      apiPath: "/exa.api_server_pb.ApiServerService/GetChatMessage",
+      apiKeyEnvVar: "",
+      apiKeyDescription: "Devin CLI session token (~/.local/share/devin/credentials.toml)",
+      apiKeyUrl: "https://devin.ai/",
+      shortcuts: ["dv", "devin"],
+      shortestPrefix: "dv",
+      legacyPrefixes: [
+        { prefix: "dv/", stripPrefix: true },
+        { prefix: "devin/", stripPrefix: true }
+      ],
+      modelDiscovery: { path: "", format: "devin-connect" },
+      isDirectApi: true,
+      description: "Devin subscription (dv@, devin@)"
+    },
     {
       name: "gemini-codeassist",
       displayName: "Gemini Code Assist",
@@ -28570,7 +28590,8 @@ var init_remote_provider_types = __esm(() => {
     "minimax-coding",
     "kimi-coding",
     "glm-coding",
-    "qwen-cloud"
+    "qwen-cloud",
+    "devin"
   ]);
   PROVIDER_ALIAS = {
     google: "gemini",
@@ -29275,7 +29296,7 @@ class BaseAPIFormat {
     }
   }
 }
-var EFFORT_ORDER, NON_ANTHROPIC_REASONING_FIELDS, DefaultAPIFormat;
+var EFFORT_ORDER, EFFORT_LEVELS, NON_ANTHROPIC_REASONING_FIELDS, DefaultAPIFormat;
 var init_base_api_format = __esm(() => {
   init_remote_provider_types();
   init_logger();
@@ -29283,6 +29304,7 @@ var init_base_api_format = __esm(() => {
   init_tool_name_utils();
   init_openai_tools();
   EFFORT_ORDER = ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
+  EFFORT_LEVELS = EFFORT_ORDER;
   NON_ANTHROPIC_REASONING_FIELDS = [
     "reasoning_effort",
     "enable_thinking",
@@ -31551,19 +31573,101 @@ var init_codex_credential = __esm(() => {
   init_api_key_credential();
 });
 
-// src/auth/oauth-registry.ts
-import { existsSync as existsSync11, readFileSync as readFileSync9 } from "fs";
+// src/providers/devin/devin-credentials.ts
+import { readFileSync as readFileSync9 } from "fs";
 import { homedir as homedir13 } from "os";
 import { join as join13 } from "path";
+function devinCredentialsPath() {
+  return credentialsPathOverride ?? join13(homedir13(), ".local", "share", "devin", "credentials.toml");
+}
+function readTomlString(source, key) {
+  const match = source.match(new RegExp(`^\\s*${key}\\s*=\\s*"([^"]*)"`, "m"));
+  const value = match?.[1]?.trim();
+  return value ? value : undefined;
+}
+function readCredentialsFile() {
+  const path = devinCredentialsPath();
+  if (fileCache && fileCache.path === path)
+    return fileCache.value;
+  let value = {};
+  try {
+    const source = readFileSync9(path, "utf8");
+    value = {
+      apiKey: readTomlString(source, "windsurf_api_key"),
+      serverUrl: readTomlString(source, "api_server_url")
+    };
+  } catch {}
+  fileCache = { path, value };
+  return value;
+}
+function readDevinApiKey() {
+  const fromEnv = realValue(process.env[DEVIN_API_KEY_ENV]);
+  if (fromEnv?.trim())
+    return fromEnv.trim();
+  const fromConfig = realValue(getApiKey(DEVIN_API_KEY_ENV));
+  if (fromConfig?.trim())
+    return fromConfig.trim();
+  const fromFile = readCredentialsFile().apiKey;
+  return fromFile?.trim() ? fromFile.trim() : undefined;
+}
+function hasDevinCredentials() {
+  return readDevinApiKey() !== undefined;
+}
+function readDevinServerUrl() {
+  const fromEnv = realValue(process.env[DEVIN_SERVER_URL_ENV])?.trim();
+  const url2 = fromEnv || readCredentialsFile().serverUrl || DEFAULT_DEVIN_SERVER_URL;
+  return url2.replace(/\/+$/, "");
+}
+var DEVIN_API_KEY_ENV = "WINDSURF_API_KEY", DEVIN_SERVER_URL_ENV = "WINDSURF_API_SERVER_URL", DEFAULT_DEVIN_SERVER_URL = "https://server.codeium.com", credentialsPathOverride = null, fileCache = null;
+var init_devin_credentials = __esm(() => {
+  init_env_placeholder();
+  init_profile_config();
+});
+
+// src/auth/credentials/devin-credential.ts
+function devinAuthHeaders(apiKey) {
+  return {
+    authorization: `Basic ${apiKey}-${apiKey}`,
+    "connect-protocol-version": "1"
+  };
+}
+
+class DevinCredentialProvider {
+  catalogName = "devin";
+  async isAvailable() {
+    try {
+      return hasDevinCredentials();
+    } catch {
+      return false;
+    }
+  }
+  async getRequestAuth() {
+    const apiKey = readDevinApiKey();
+    if (!apiKey) {
+      const err = new Error("No Devin credential. Sign in with the Devin CLI (`devin login`), or set WINDSURF_API_KEY. " + "Expected ~/.local/share/devin/credentials.toml.");
+      err.terminal = true;
+      throw err;
+    }
+    return { headers: devinAuthHeaders(apiKey) };
+  }
+}
+var init_devin_credential = __esm(() => {
+  init_devin_credentials();
+});
+
+// src/auth/oauth-registry.ts
+import { existsSync as existsSync11, readFileSync as readFileSync10 } from "fs";
+import { homedir as homedir14 } from "os";
+import { join as join14 } from "path";
 function hasValidOAuthCredentials(descriptor) {
-  const credPath = join13(homedir13(), ".claudish", descriptor.credentialFile);
+  const credPath = join14(homedir14(), ".claudish", descriptor.credentialFile);
   if (!existsSync11(credPath))
     return false;
   if (descriptor.validationMode === "file-exists") {
     return true;
   }
   try {
-    const data = JSON.parse(readFileSync9(credPath, "utf-8"));
+    const data = JSON.parse(readFileSync10(credPath, "utf-8"));
     if (!data.access_token)
       return false;
     if (data.refresh_token)
@@ -31668,9 +31772,9 @@ var init_gemini_credential = __esm(() => {
 // src/auth/kimi-oauth.ts
 import { exec as exec3 } from "child_process";
 import { randomBytes as randomBytes3 } from "crypto";
-import { closeSync as closeSync4, existsSync as existsSync12, openSync as openSync4, readFileSync as readFileSync10, unlinkSync as unlinkSync4, writeSync as writeSync4 } from "fs";
-import { homedir as homedir14, hostname as hostname3, platform, release as release2 } from "os";
-import { join as join14 } from "path";
+import { closeSync as closeSync4, existsSync as existsSync12, openSync as openSync4, readFileSync as readFileSync11, unlinkSync as unlinkSync4, writeSync as writeSync4 } from "fs";
+import { homedir as homedir15, hostname as hostname3, platform, release as release2 } from "os";
+import { join as join15 } from "path";
 import { promisify as promisify3 } from "util";
 
 class KimiOAuth {
@@ -31698,23 +31802,23 @@ class KimiOAuth {
     return this.credentials !== null && !!this.credentials.refresh_token;
   }
   getCredentialsPath() {
-    const claudishDir = join14(homedir14(), ".claudish");
-    return join14(claudishDir, "kimi-oauth.json");
+    const claudishDir = join15(homedir15(), ".claudish");
+    return join15(claudishDir, "kimi-oauth.json");
   }
   getDeviceIdPath() {
-    const claudishDir = join14(homedir14(), ".claudish");
-    return join14(claudishDir, "kimi-device-id");
+    const claudishDir = join15(homedir15(), ".claudish");
+    return join15(claudishDir, "kimi-device-id");
   }
   loadOrCreateDeviceId() {
     const deviceIdPath = this.getDeviceIdPath();
-    const claudishDir = join14(homedir14(), ".claudish");
+    const claudishDir = join15(homedir15(), ".claudish");
     if (!existsSync12(claudishDir)) {
       const { mkdirSync: mkdirSync7 } = __require("fs");
       mkdirSync7(claudishDir, { recursive: true });
     }
     if (existsSync12(deviceIdPath)) {
       try {
-        const deviceId2 = readFileSync10(deviceIdPath, "utf-8").trim();
+        const deviceId2 = readFileSync11(deviceIdPath, "utf-8").trim();
         if (deviceId2) {
           return deviceId2;
         }
@@ -31973,7 +32077,7 @@ Details: ${e.message}`);
       return null;
     }
     try {
-      const data = readFileSync10(credPath, "utf-8");
+      const data = readFileSync11(credPath, "utf-8");
       const credentials2 = JSON.parse(data);
       if (!credentials2.access_token || !credentials2.refresh_token || !credentials2.expires_at || !credentials2.scope || !credentials2.token_type) {
         log("[KimiOAuth] Invalid credentials file structure");
@@ -31988,7 +32092,7 @@ Details: ${e.message}`);
   }
   saveCredentials(credentials2) {
     const credPath = this.getCredentialsPath();
-    const claudishDir = join14(homedir14(), ".claudish");
+    const claudishDir = join15(homedir15(), ".claudish");
     if (!existsSync12(claudishDir)) {
       const { mkdirSync: mkdirSync7 } = __require("fs");
       mkdirSync7(claudishDir, { recursive: true });
@@ -32164,8 +32268,8 @@ var init_native_anthropic_credential = __esm(() => {
 // src/auth/vertex-auth.ts
 import { exec as exec4 } from "child_process";
 import { existsSync as existsSync13 } from "fs";
-import { homedir as homedir15 } from "os";
-import { join as join15 } from "path";
+import { homedir as homedir16 } from "os";
+import { join as join16 } from "path";
 import { promisify as promisify4 } from "util";
 
 class VertexAuthManager {
@@ -32220,7 +32324,7 @@ class VertexAuthManager {
   }
   async tryADC() {
     try {
-      const adcPath = join15(homedir15(), ".config/gcloud/application_default_credentials.json");
+      const adcPath = join16(homedir16(), ".config/gcloud/application_default_credentials.json");
       if (!existsSync13(adcPath)) {
         log("[VertexAuth] ADC credentials file not found");
         return null;
@@ -32284,7 +32388,7 @@ function validateVertexOAuthConfig() {
 ` + `  export VERTEX_PROJECT='your-gcp-project-id'
 ` + "  export VERTEX_LOCATION='us-central1'  # optional";
   }
-  const adcPath = join15(homedir15(), ".config/gcloud/application_default_credentials.json");
+  const adcPath = join16(homedir16(), ".config/gcloud/application_default_credentials.json");
   const hasADC = existsSync13(adcPath);
   const hasServiceAccount = !!process.env.GOOGLE_APPLICATION_CREDENTIALS;
   if (!hasADC && !hasServiceAccount) {
@@ -32405,6 +32509,7 @@ class CredentialAuthority {
     authority.register(makeCodexCredential(), ["openai-codex"]);
     authority.register(new GeminiCodeAssistCredentialProvider, ["gemini-codeassist"]);
     authority.register(new AntigravityCredentialProvider, ["antigravity"]);
+    authority.register(new DevinCredentialProvider, ["devin"]);
     authority.register(makeKimiCredential(), ["kimi"]);
     authority.register(makeKimiCodingCredential(), ["kimi-coding"]);
     authority.register(new VertexCredentialProvider, ["vertex"]);
@@ -32416,6 +32521,7 @@ class CredentialAuthority {
       "openai-codex",
       "gemini-codeassist",
       "antigravity",
+      "devin",
       "kimi",
       "kimi-coding",
       "vertex",
@@ -32447,6 +32553,7 @@ var init_authority = __esm(() => {
   init_antigravity_credential();
   init_api_key_credential();
   init_codex_credential();
+  init_devin_credential();
   init_gemini_credential();
   init_kimi_credential();
   init_local_credential();
@@ -33282,7 +33389,8 @@ function createStreamingState() {
     tools: new Map,
     toolIds: new Set,
     lastActivity: Date.now(),
-    accumulatedText: ""
+    accumulatedText: "",
+    finishReason: null
   };
 }
 function createStreamingResponseHandler(c, response, adapter, target, middlewareManager, onTokenUpdate, toolSchemas, toolNameMap, priorInputTokens, behavior) {
@@ -33440,7 +33548,12 @@ data: ${JSON.stringify(d)}
           send("error", { type: "error", error: { type: "api_error", message: err } });
         } else {
           const hasStructuredTools = Array.from(state.tools.values()).some((t) => t.started);
-          const stopReason = textToolCalls.length > 0 || hasStructuredTools ? "tool_use" : "end_turn";
+          const truncated = state.finishReason === "length";
+          const refused = state.finishReason === "content_filter";
+          const stopReason = refused ? "refusal" : truncated ? "max_tokens" : textToolCalls.length > 0 || hasStructuredTools ? "tool_use" : "end_turn";
+          if (truncated || refused) {
+            log(`[Streaming] Upstream finish_reason=${state.finishReason} \u2192 stop_reason=${stopReason} (${state.accumulatedText.length} chars produced)`);
+          }
           send("message_delta", {
             type: "message_delta",
             delta: { stop_reason: stopReason, stop_sequence: null },
@@ -33503,6 +33616,8 @@ data: ${JSON.stringify(d)}
               }
               const delta = chunk.choices?.[0]?.delta;
               const finishReason = chunk.choices?.[0]?.finish_reason;
+              if (finishReason)
+                state.finishReason = finishReason;
               if (delta?.content || finishReason) {
                 log(`[Streaming] Chunk: content=${delta?.content?.length || 0} chars, finish_reason=${finishReason || "null"}`);
               }
@@ -33515,8 +33630,9 @@ data: ${JSON.stringify(d)}
                     metadata: streamMetadata
                   });
                 }
-                if (delta.reasoning_content) {
-                  behavior?.onAssistantText?.(delta.reasoning_content, "reasoning");
+                const reasoningText = delta.reasoning_content || delta.reasoning;
+                if (reasoningText) {
+                  behavior?.onAssistantText?.(reasoningText, "reasoning");
                   state.lastActivity = Date.now();
                   if (!state.reasoningStarted) {
                     state.reasoningIdx = state.curIdx++;
@@ -33530,7 +33646,7 @@ data: ${JSON.stringify(d)}
                   send("content_block_delta", {
                     type: "content_block_delta",
                     index: state.reasoningIdx,
-                    delta: { type: "thinking_delta", thinking: delta.reasoning_content }
+                    delta: { type: "thinking_delta", thinking: reasoningText }
                   });
                 }
                 const txt = delta.content || "";
@@ -33799,54 +33915,14 @@ var init_openai_compat = __esm(() => {
 });
 
 // src/adapters/gemini-api-format.ts
-var REASONING_PATTERNS, REASONING_CONTINUATION_PATTERNS, GeminiAPIFormat;
+var GeminiAPIFormat;
 var init_gemini_api_format = __esm(() => {
   init_gemini_schema();
   init_openai_compat();
   init_logger();
   init_base_api_format();
-  REASONING_PATTERNS = [
-    /^Wait,?\s+I(?:'m|\s+am)\s+\w+ing\b/i,
-    /^Wait,?\s+(?:if|that|the|this|I\s+(?:need|should|will|have|already))/i,
-    /^Wait[.!]?\s*$/i,
-    /^Let\s+me\s+(think|check|verify|see|look|analyze|consider|first|start)/i,
-    /^Let's\s+(check|see|look|start|first|try|think|verify|examine|analyze)/i,
-    /^I\s+need\s+to\s+/i,
-    /^O[kK](?:ay)?[.,!]?\s*(?:so|let|I|now|first)?/i,
-    /^[Hh]mm+/,
-    /^So[,.]?\s+(?:I|let|first|now|the)/i,
-    /^(?:First|Next|Then|Now)[,.]?\s+(?:I|let|we)/i,
-    /^(?:Thinking\s+about|Considering)/i,
-    /^I(?:'ll|\s+will)\s+(?:first|now|start|begin|try|check|fix|look|examine|modify|create|update|read|investigate|adjust|improve|integrate|mark|also|verify|need|rethink|add|help|use|run|search|find|explore|analyze|review|test|implement|write|make|set|get|see|open|close|save|load|fetch|call|send|build|compile|execute|process|handle|parse|format|validate|clean|clear|remove|delete|move|copy|rename|install|configure|setup|initialize|prepare|work|continue|proceed|ensure|confirm)/i,
-    /^I\s+should\s+/i,
-    /^I\s+will\s+(?:first|now|start|verify|check|create|modify|look|need|also|add|help|use|run|search|find|explore|analyze|review|test|implement|write)/i,
-    /^(?:Debug|Checking|Verifying|Looking\s+at):/i,
-    /^I\s+also\s+(?:notice|need|see|want)/i,
-    /^The\s+(?:goal|issue|problem|idea|plan)\s+is/i,
-    /^In\s+the\s+(?:old|current|previous|new|existing)\s+/i,
-    /^`[^`]+`\s+(?:is|has|does|needs|should|will|doesn't|hasn't)/i
-  ];
-  REASONING_CONTINUATION_PATTERNS = [
-    /^And\s+(?:then|I|now|so)/i,
-    /^And\s+I(?:'ll|\s+will)/i,
-    /^But\s+(?:I|first|wait|actually|the|if)/i,
-    /^Actually[,.]?\s+/i,
-    /^Also[,.]?\s+(?:I|the|check|note)/i,
-    /^\d+\.\s+(?:I|First|Check|Run|Create|Update|Read|Modify|Add|Fix|Look)/i,
-    /^-\s+(?:I|First|Check|Run|Create|Update|Read|Modify|Add|Fix)/i,
-    /^Or\s+(?:I|just|we|maybe|perhaps)/i,
-    /^Since\s+(?:I|the|this|we|it)/i,
-    /^Because\s+(?:I|the|this|we|it)/i,
-    /^If\s+(?:I|the|this|we|it)\s+/i,
-    /^This\s+(?:is|means|requires|should|will|confirms|suggests)/i,
-    /^That\s+(?:means|is|should|will|explains|confirms)/i,
-    /^Lines?\s+\d+/i,
-    /^The\s+`[^`]+`\s+(?:is|has|contains|needs|should)/i
-  ];
   GeminiAPIFormat = class GeminiAPIFormat extends BaseAPIFormat {
     toolCallMap = new Map;
-    inReasoningBlock = false;
-    reasoningBlockDepth = 0;
     convertMessages(claudeRequest, _filterIdentityFn) {
       const messages = [];
       if (claudeRequest.messages) {
@@ -34056,58 +34132,12 @@ CRITICAL INSTRUCTION FOR OUTPUT FORMAT:
       }
     }
     processTextContent(textContent, _accumulatedText) {
-      if (!textContent || textContent.trim() === "") {
-        return { cleanedText: textContent, extractedToolCalls: [], wasTransformed: false };
-      }
-      const lines = textContent.split(`
-`);
-      const cleanedLines = [];
-      let wasFiltered = false;
-      for (const line of lines) {
-        const trimmed2 = line.trim();
-        if (!trimmed2) {
-          cleanedLines.push(line);
-          continue;
-        }
-        if (this.isReasoningLine(trimmed2)) {
-          log(`[GeminiAPIFormat] Filtered reasoning: "${trimmed2.substring(0, 50)}..."`);
-          wasFiltered = true;
-          this.inReasoningBlock = true;
-          this.reasoningBlockDepth++;
-          continue;
-        }
-        if (this.inReasoningBlock && this.isReasoningContinuation(trimmed2)) {
-          log(`[GeminiAPIFormat] Filtered reasoning continuation: "${trimmed2.substring(0, 50)}..."`);
-          wasFiltered = true;
-          continue;
-        }
-        if (this.inReasoningBlock && trimmed2.length > 20 && !this.isReasoningContinuation(trimmed2)) {
-          this.inReasoningBlock = false;
-          this.reasoningBlockDepth = 0;
-        }
-        cleanedLines.push(line);
-      }
-      const cleanedText = cleanedLines.join(`
-`);
-      return {
-        cleanedText: wasFiltered ? cleanedText : textContent,
-        extractedToolCalls: [],
-        wasTransformed: wasFiltered
-      };
-    }
-    isReasoningLine(line) {
-      return REASONING_PATTERNS.some((pattern) => pattern.test(line));
-    }
-    isReasoningContinuation(line) {
-      return REASONING_CONTINUATION_PATTERNS.some((pattern) => pattern.test(line));
+      return { cleanedText: textContent, extractedToolCalls: [], wasTransformed: false };
     }
     getStreamFormat() {
       return "gemini-sse";
     }
-    reset() {
-      this.inReasoningBlock = false;
-      this.reasoningBlockDepth = 0;
-    }
+    reset() {}
     getContextWindow() {
       return 1048576;
     }
@@ -34690,9 +34720,9 @@ var init_antigravity2 = __esm(() => {
 });
 
 // src/auth/quota/sources/codex.ts
-import { existsSync as existsSync14, readFileSync as readFileSync11 } from "fs";
-import { homedir as homedir16 } from "os";
-import { join as join16 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync12 } from "fs";
+import { homedir as homedir17 } from "os";
+import { join as join17 } from "path";
 function formatWindowMinutes(minutes) {
   if (!Number.isFinite(minutes) || minutes <= 0)
     return "";
@@ -34706,7 +34736,7 @@ function formatWindowMinutes(minutes) {
   return `${hours}h${minutes % 60}m`;
 }
 function credentialsPath() {
-  return join16(homedir16(), ".claudish", "codex-oauth.json");
+  return join17(homedir17(), ".claudish", "codex-oauth.json");
 }
 function planLabel(planType) {
   if (!planType)
@@ -34758,10 +34788,10 @@ function scrapeCodexHeaders(headers) {
 }
 function resolveProbeModel() {
   try {
-    const cachePath = join16(homedir16(), ".codex", "models_cache.json");
+    const cachePath = join17(homedir17(), ".codex", "models_cache.json");
     if (!existsSync14(cachePath))
       return;
-    const cache2 = JSON.parse(readFileSync11(cachePath, "utf-8"));
+    const cache2 = JSON.parse(readFileSync12(cachePath, "utf-8"));
     for (const m of cache2.models ?? []) {
       const slug = m?.slug ?? m?.id;
       if (typeof slug === "string" && slug.length > 0)
@@ -34775,7 +34805,7 @@ function readCodexCredentials() {
     const path = credentialsPath();
     if (!existsSync14(path))
       return;
-    return JSON.parse(readFileSync11(path, "utf-8"));
+    return JSON.parse(readFileSync12(path, "utf-8"));
   } catch {
     return;
   }
@@ -35187,8 +35217,8 @@ var init_harness = __esm(() => {
 
 // src/behavior/journal.ts
 import { appendFile as appendFile2, mkdir, readFile, rename, stat, writeFile } from "fs/promises";
-import { homedir as homedir17 } from "os";
-import { dirname as dirname6, join as join17 } from "path";
+import { homedir as homedir18 } from "os";
+import { dirname as dirname6, join as join18 } from "path";
 function classifyPath(observed, expected) {
   if (!observed)
     return "not_applicable";
@@ -35200,7 +35230,7 @@ function classifyPath(observed, expected) {
   return dirOf(observed) === dirOf(expected) ? "same_dir_wrong_name" : "outside_expected_dir";
 }
 function journalPath() {
-  return join17(homedir17(), ".claudish", "behavior-journal.jsonl");
+  return join18(homedir18(), ".claudish", "behavior-journal.jsonl");
 }
 async function prune(path) {
   const content = await readFile(path, "utf8");
@@ -35261,8 +35291,8 @@ __export(exports_aggregate, {
 });
 import { createHash as createHash4, randomBytes as randomBytes4 } from "crypto";
 import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync7 } from "fs";
-import { homedir as homedir18 } from "os";
-import { dirname as dirname7, join as join18 } from "path";
+import { homedir as homedir19 } from "os";
+import { dirname as dirname7, join as join19 } from "path";
 function contextBucket(inputTokens) {
   if (inputTokens < 50000)
     return "0-50k";
@@ -35380,7 +35410,7 @@ function pendingReports() {
   return [...sessions.values()].map(toReport);
 }
 function outboxPath() {
-  return join18(homedir18(), ".claudish", "behavior-outbox.jsonl");
+  return join19(homedir19(), ".claudish", "behavior-outbox.jsonl");
 }
 function spoolPendingSync(path = outboxPath()) {
   if (sessions.size === 0)
@@ -35603,10 +35633,10 @@ __export(exports_live_log, {
   recordLiveDivergence: () => recordLiveDivergence
 });
 import { appendFile as appendFile3 } from "fs/promises";
-import { homedir as homedir19 } from "os";
-import { join as join19 } from "path";
+import { homedir as homedir20 } from "os";
+import { join as join20 } from "path";
 function defaultPath() {
-  return join19(homedir19(), ".claudish", "behavior-divergences.jsonl");
+  return join20(homedir20(), ".claudish", "behavior-divergences.jsonl");
 }
 async function recordLiveDivergence(entry, path = defaultPath()) {
   try {
@@ -36263,9 +36293,9 @@ var init_hooks = __esm(() => {
 });
 
 // src/behavior/observer/corpus.ts
-import { appendFileSync as appendFileSync3, readFileSync as readFileSync12, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
-import { homedir as homedir20 } from "os";
-import { join as join20 } from "path";
+import { appendFileSync as appendFileSync3, readFileSync as readFileSync13, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { homedir as homedir21 } from "os";
+import { join as join21 } from "path";
 function directoryOf2(filePath) {
   const slash = filePath.lastIndexOf("/");
   return slash > 0 ? filePath.slice(0, slash) : undefined;
@@ -36287,7 +36317,7 @@ function writeTargetsOf(row) {
 function replayTranscript(file2) {
   let text;
   try {
-    text = readFileSync12(file2, "utf8");
+    text = readFileSync13(file2, "utf8");
   } catch {
     return [];
   }
@@ -36344,26 +36374,26 @@ function listTranscripts(root) {
     return files;
   }
   for (const project of projects) {
-    const dir = join20(root, project);
+    const dir = join21(root, project);
     try {
       if (!statSync2(dir).isDirectory())
         continue;
       for (const f of readdirSync2(dir)) {
         if (f.endsWith(".jsonl"))
-          files.push(join20(dir, f));
+          files.push(join21(dir, f));
       }
     } catch {}
   }
   return files;
 }
 function buildCorpus(options = {}) {
-  const root = options.projectsRoot ?? join20(homedir20(), ".claude", "projects");
+  const root = options.projectsRoot ?? join21(homedir21(), ".claude", "projects");
   const files = listTranscripts(root);
   const records = [];
   for (const f of files)
     records.push(...replayTranscript(f));
   if (options.write && records.length > 0) {
-    const outputPath = options.outputPath ?? join20(homedir20(), ".claudish", "behavior-divergences.jsonl");
+    const outputPath = options.outputPath ?? join21(homedir21(), ".claudish", "behavior-divergences.jsonl");
     try {
       appendFileSync3(outputPath, `${records.map((r) => JSON.stringify(r)).join(`
 `)}
@@ -37128,13 +37158,13 @@ var init_model_parser = __esm(() => {
 import {
   existsSync as existsSync15,
   mkdirSync as mkdirSync8,
-  readFileSync as readFileSync13,
+  readFileSync as readFileSync14,
   renameSync,
   unlinkSync as unlinkSync5,
   writeFileSync as writeFileSync7
 } from "fs";
-import { homedir as homedir21 } from "os";
-import { join as join21 } from "path";
+import { homedir as homedir22 } from "os";
+import { join as join22 } from "path";
 function ensureDir() {
   if (!existsSync15(CLAUDISH_DIR)) {
     mkdirSync8(CLAUDISH_DIR, { recursive: true });
@@ -37144,7 +37174,7 @@ function readFromDisk() {
   try {
     if (!existsSync15(BUFFER_FILE))
       return [];
-    const raw = readFileSync13(BUFFER_FILE, "utf-8");
+    const raw = readFileSync14(BUFFER_FILE, "utf-8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed.events))
       return [];
@@ -37169,7 +37199,7 @@ function writeToDisk(events) {
     ensureDir();
     const trimmed2 = enforceSizeCap([...events]);
     const payload = { version: 1, events: trimmed2 };
-    const tmpFile = join21(CLAUDISH_DIR, `stats-buffer.tmp.${process.pid}.json`);
+    const tmpFile = join22(CLAUDISH_DIR, `stats-buffer.tmp.${process.pid}.json`);
     writeFileSync7(tmpFile, JSON.stringify(payload, null, 2), "utf-8");
     renameSync(tmpFile, BUFFER_FILE);
     memoryCache = trimmed2;
@@ -37242,8 +37272,8 @@ function syncFlushOnExit() {
 var BUFFER_MAX_BYTES, CLAUDISH_DIR, BUFFER_FILE, memoryCache = null, eventsSinceLastFlush = 0, flushScheduled = false;
 var init_stats_buffer = __esm(() => {
   BUFFER_MAX_BYTES = 64 * 1024;
-  CLAUDISH_DIR = join21(homedir21(), ".claudish");
-  BUFFER_FILE = join21(CLAUDISH_DIR, "stats-buffer.json");
+  CLAUDISH_DIR = join22(homedir22(), ".claudish");
+  BUFFER_FILE = join22(CLAUDISH_DIR, "stats-buffer.json");
   process.on("exit", syncFlushOnExit);
   process.on("SIGTERM", () => {
     try {
@@ -38357,9 +38387,9 @@ function compareByReleaseDateDesc(a, b) {
 }
 
 // src/model-loader.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync9, readFileSync as readFileSync14, writeFileSync as writeFileSync8 } from "fs";
-import { homedir as homedir22 } from "os";
-import { join as join22 } from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync9, readFileSync as readFileSync15, writeFileSync as writeFileSync8 } from "fs";
+import { homedir as homedir23 } from "os";
+import { join as join23 } from "path";
 function groupRecommendedModels(entries) {
   const byId = new Map;
   const categoryOrder = new Map;
@@ -38471,7 +38501,7 @@ async function getRecommendedModels(opts = {}) {
   }
   if (!forceRefresh && existsSync16(RECOMMENDED_MODELS_CACHE_PATH)) {
     try {
-      const cacheData = JSON.parse(readFileSync14(RECOMMENDED_MODELS_CACHE_PATH, "utf-8"));
+      const cacheData = JSON.parse(readFileSync15(RECOMMENDED_MODELS_CACHE_PATH, "utf-8"));
       if (cacheData.models && cacheData.models.length > 0 && isFreshEnough(cacheData)) {
         _cachedRecommendedModels = cacheData;
         return cacheData;
@@ -38487,7 +38517,7 @@ async function getRecommendedModels(opts = {}) {
       if (data.models && data.models.length > 0) {
         _cachedRecommendedModels = data;
         try {
-          const cacheDir = join22(homedir22(), ".claudish");
+          const cacheDir = join23(homedir23(), ".claudish");
           mkdirSync9(cacheDir, { recursive: true });
           writeFileSync8(RECOMMENDED_MODELS_CACHE_PATH, JSON.stringify(data), "utf-8");
         } catch {}
@@ -38502,7 +38532,7 @@ function getRecommendedModelsSync() {
     return _cachedRecommendedModels;
   if (existsSync16(RECOMMENDED_MODELS_CACHE_PATH)) {
     try {
-      const cacheData = JSON.parse(readFileSync14(RECOMMENDED_MODELS_CACHE_PATH, "utf-8"));
+      const cacheData = JSON.parse(readFileSync15(RECOMMENDED_MODELS_CACHE_PATH, "utf-8"));
       if (cacheData.models && cacheData.models.length > 0 && isFreshEnough(cacheData)) {
         _cachedRecommendedModels = cacheData;
         return cacheData;
@@ -38626,7 +38656,7 @@ var _cachedModelInfo = null, _cachedModelIds = null, _cachedRecommendedModels =
 var init_model_loader = __esm(() => {
   init_cache_ttl();
   FIREBASE_RECOMMENDED_URL = `${FIREBASE_BASE_URL}?catalog=recommended`;
-  RECOMMENDED_MODELS_CACHE_PATH = join22(homedir22(), ".claudish", "recommended-models-cache.json");
+  RECOMMENDED_MODELS_CACHE_PATH = join23(homedir23(), ".claudish", "recommended-models-cache.json");
   FIREBASE_SLUG_TO_PROVIDER_NAME = {
     openai: "openai",
     google: "google",
@@ -38694,6 +38724,279 @@ var init_context_window_fallback = __esm(() => {
   inFlight2 = new Map;
 });
 
+// src/providers/devin/proto-codec.ts
+function cat(parts) {
+  let total = 0;
+  for (const part of parts)
+    total += part.length;
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+function varint(n) {
+  let value = BigInt(n);
+  const out = [];
+  do {
+    let byte = Number(value & 0x7fn);
+    value >>= 7n;
+    if (value > 0n)
+      byte |= 128;
+    out.push(byte);
+  } while (value > 0n);
+  return new Uint8Array(out);
+}
+function tag(fieldNumber, wireType) {
+  return varint(fieldNumber << 3 | wireType);
+}
+function bytes(fieldNumber, value) {
+  const body = typeof value === "string" ? textEncoder.encode(value) : value;
+  return cat([tag(fieldNumber, 2), varint(body.length), body]);
+}
+function vint(fieldNumber, value) {
+  return cat([tag(fieldNumber, 0), varint(value)]);
+}
+function msg(...parts) {
+  return cat(parts);
+}
+function writeUint32BE(target, offset, value) {
+  target[offset] = value >>> 24 & 255;
+  target[offset + 1] = value >>> 16 & 255;
+  target[offset + 2] = value >>> 8 & 255;
+  target[offset + 3] = value & 255;
+}
+function readUint32BE(source, offset) {
+  return (source[offset] << 24 | source[offset + 1] << 16 | source[offset + 2] << 8 | source[offset + 3]) >>> 0;
+}
+function envelope(payload, flags = 0) {
+  const out = new Uint8Array(FRAME_HEADER_BYTES + payload.length);
+  out[0] = flags;
+  writeUint32BE(out, 1, payload.length);
+  out.set(payload, FRAME_HEADER_BYTES);
+  return out;
+}
+function readVarintAt(buf, p) {
+  let value = 0n;
+  let shift = 0n;
+  let offset = p;
+  while (offset < buf.length) {
+    const byte = buf[offset++];
+    value |= BigInt(byte & 127) << shift;
+    if ((byte & 128) === 0)
+      break;
+    shift += 7n;
+  }
+  return [value, offset];
+}
+function parseTLV(buf) {
+  const out = [];
+  let p = 0;
+  while (p < buf.length) {
+    const start = p;
+    let rawTag;
+    [rawTag, p] = readVarintAt(buf, p);
+    const no = Number(rawTag >> 3n);
+    const wire = Number(rawTag & 7n);
+    if (no === 0)
+      break;
+    let payloadStart = p;
+    if (wire === 0) {
+      [, p] = readVarintAt(buf, p);
+    } else if (wire === 1) {
+      p += 8;
+    } else if (wire === 5) {
+      p += 4;
+    } else if (wire === 2) {
+      let len;
+      [len, p] = readVarintAt(buf, p);
+      payloadStart = p;
+      p += Number(len);
+    } else {
+      break;
+    }
+    if (p > buf.length)
+      break;
+    out.push({ no, wire, raw: buf.subarray(start, p), payload: buf.subarray(payloadStart, p) });
+  }
+  return out;
+}
+function readVarintValue(tlv) {
+  if (tlv.wire !== 0)
+    return 0;
+  const [value] = readVarintAt(tlv.payload, 0);
+  return Number(value);
+}
+function readFloat32LE(tlv) {
+  if (tlv.wire !== 5 || tlv.payload.length < 4)
+    return 0;
+  const view = new DataView(tlv.payload.buffer, tlv.payload.byteOffset, tlv.payload.byteLength);
+  return view.getFloat32(0, true);
+}
+function readString(tlv) {
+  return textDecoder.decode(tlv.payload);
+}
+function createFrameReader() {
+  let pending = new Uint8Array(0);
+  return (chunk) => {
+    if (chunk.length > 0) {
+      if (pending.length === 0) {
+        pending = chunk;
+      } else {
+        const merged = new Uint8Array(pending.length + chunk.length);
+        merged.set(pending, 0);
+        merged.set(chunk, pending.length);
+        pending = merged;
+      }
+    }
+    const frames = [];
+    let offset = 0;
+    while (offset + FRAME_HEADER_BYTES <= pending.length) {
+      const flags = pending[offset];
+      const length = readUint32BE(pending, offset + 1);
+      const end = offset + FRAME_HEADER_BYTES + length;
+      if (end > pending.length)
+        break;
+      frames.push({ flags, payload: pending.slice(offset + FRAME_HEADER_BYTES, end) });
+      offset = end;
+    }
+    if (offset > 0)
+      pending = pending.slice(offset);
+    return frames;
+  };
+}
+var FRAME_HEADER_BYTES = 5, FRAME_FLAG_END_OF_STREAM = 2, textEncoder, textDecoder;
+var init_proto_codec = __esm(() => {
+  textEncoder = new TextEncoder;
+  textDecoder = new TextDecoder;
+});
+
+// src/handlers/shared/devin-stream-head-sniffer.ts
+function classifyDevinStreamError(code, message) {
+  const lowerCode = code.toLowerCase();
+  if (RETRYABLE_CODES.has(lowerCode))
+    return "retryable";
+  if (TERMINAL_CODES.has(lowerCode))
+    return "terminal";
+  if (lowerCode === "resource_exhausted") {
+    return QUOTA_MESSAGE_RE.test(message) ? "terminal" : "retryable";
+  }
+  if (RETRYABLE_MESSAGE_RE.test(message))
+    return "retryable";
+  return "terminal";
+}
+async function sniffDevinStreamHead(response, opts = {}) {
+  const budgetMs = opts.budgetMs ?? DEVIN_SNIFF_BUDGET_MS;
+  const logMsg = opts.log ?? (() => {});
+  if (!response.body)
+    return { kind: "clean", response };
+  const reader = response.body.getReader();
+  const consumed = [];
+  const nextFrames = createFrameReader();
+  const decoder = new TextDecoder;
+  const deadline = Date.now() + budgetMs;
+  const replayResponse = () => {
+    const buffered = consumed.slice();
+    const body = new ReadableStream({
+      start: async (controller) => {
+        try {
+          for (const chunk of buffered)
+            controller.enqueue(chunk);
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+              break;
+            if (value)
+              controller.enqueue(value);
+          }
+          controller.close();
+        } catch (error46) {
+          try {
+            controller.error(error46);
+          } catch {}
+        }
+      },
+      cancel: () => {
+        reader.cancel().catch(() => {});
+      }
+    });
+    return new Response(body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+  };
+  try {
+    while (true) {
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) {
+        logMsg(`[DevinSniff] budget ${budgetMs}ms elapsed with no verdict \u2014 streaming through`);
+        return { kind: "clean", response: replayResponse() };
+      }
+      let timer;
+      const timeout = new Promise((resolve2) => {
+        timer = setTimeout(() => resolve2("timeout"), remaining);
+      });
+      let result;
+      try {
+        result = await Promise.race([reader.read(), timeout]);
+      } finally {
+        if (timer)
+          clearTimeout(timer);
+      }
+      if (result === "timeout") {
+        logMsg(`[DevinSniff] budget ${budgetMs}ms elapsed mid-read \u2014 streaming through`);
+        return { kind: "clean", response: replayResponse() };
+      }
+      if (result.done)
+        return { kind: "clean", response: replayResponse() };
+      if (!result.value)
+        continue;
+      consumed.push(result.value);
+      for (const frame of nextFrames(result.value)) {
+        if (frame.flags !== FRAME_FLAG_END_OF_STREAM) {
+          return { kind: "clean", response: replayResponse() };
+        }
+        const raw = decoder.decode(frame.payload).trim();
+        if (!raw || raw === "{}") {
+          return { kind: "clean", response: replayResponse() };
+        }
+        let code = "unknown";
+        let message = raw;
+        try {
+          const parsed = JSON.parse(raw);
+          code = String(parsed?.error?.code ?? parsed?.code ?? "unknown");
+          message = String(parsed?.error?.message ?? parsed?.message ?? raw);
+        } catch {}
+        const kind = classifyDevinStreamError(code, message);
+        logMsg(`[DevinSniff] in-stream error ${code} classified ${kind}: ${message.slice(0, 200)}`);
+        reader.cancel().catch(() => {});
+        return { kind, code, message };
+      }
+    }
+  } catch (error46) {
+    logMsg(`[DevinSniff] read failed (${error46}) \u2014 handing stream to parser`);
+    return { kind: "clean", response: replayResponse() };
+  }
+}
+var DEVIN_SNIFF_BUDGET_MS = 12000, RETRYABLE_CODES, TERMINAL_CODES, RETRYABLE_MESSAGE_RE, QUOTA_MESSAGE_RE;
+var init_devin_stream_head_sniffer = __esm(() => {
+  init_proto_codec();
+  RETRYABLE_CODES = new Set(["unavailable", "internal", "deadline_exceeded", "aborted"]);
+  TERMINAL_CODES = new Set([
+    "permission_denied",
+    "unauthenticated",
+    "invalid_argument",
+    "not_found",
+    "failed_precondition",
+    "unimplemented"
+  ]);
+  RETRYABLE_MESSAGE_RE = /third-party model provider is experiencing issues|overloaded|temporarily unavailable|try again|please retry/i;
+  QUOTA_MESSAGE_RE = /quota|out of credits|credit balance|billing|plan limit|exceeded your/i;
+});
+
 // src/handlers/shared/stream-head-sniffer.ts
 function isRetryableStreamError(code, type, message) {
   if (RETRYABLE_ERROR_CODES.has(code))
@@ -39166,6 +39469,350 @@ var init_anthropic_sse = __esm(() => {
   init_logger();
 });
 
+// src/handlers/shared/stream-parsers/devin-connect.ts
+function createDevinConnectStream(_c, response, opts) {
+  const encoder = new TextEncoder;
+  let isClosed = false;
+  let pingInterval = null;
+  const stream = new ReadableStream({
+    async start(controller) {
+      const send = (event, data) => {
+        if (!isClosed) {
+          controller.enqueue(encoder.encode(`event: ${event}
+data: ${JSON.stringify(data)}
+
+`));
+        }
+      };
+      const msgId = `msg_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+      let finalized2 = false;
+      let curIdx = 0;
+      let textIdx = -1;
+      let textStarted = false;
+      let thinkingIdx = -1;
+      let thinkingStarted = false;
+      let inputTokens = 0;
+      let outputTokens = 0;
+      let sawUsage = false;
+      let rawStopReason = null;
+      let servedModel = "";
+      let toolBlocksEmitted = 0;
+      let current = null;
+      let lastActivity = Date.now();
+      const textDecoder2 = new TextDecoder;
+      const reasoningDecoder = new TextDecoder;
+      send("message_start", {
+        type: "message_start",
+        message: {
+          id: msgId,
+          type: "message",
+          role: "assistant",
+          content: [],
+          model: opts.modelName,
+          stop_reason: null,
+          stop_sequence: null,
+          usage: messageStartUsage(opts.priorInputTokens)
+        }
+      });
+      send("ping", { type: "ping" });
+      pingInterval = setInterval(() => {
+        if (!isClosed && Date.now() - lastActivity > 1000) {
+          send("ping", { type: "ping" });
+        }
+      }, 1000);
+      const closeThinking = () => {
+        if (!thinkingStarted)
+          return;
+        send("content_block_stop", { type: "content_block_stop", index: thinkingIdx });
+        thinkingStarted = false;
+      };
+      const closeText = () => {
+        if (!textStarted)
+          return;
+        send("content_block_stop", { type: "content_block_stop", index: textIdx });
+        textStarted = false;
+      };
+      const closeCurrentTool = () => {
+        if (!current || current.closed)
+          return;
+        const call = current;
+        current = null;
+        if (call.buffered) {
+          let args = call.args;
+          if (opts.repairToolArgs) {
+            try {
+              const repaired = opts.repairToolArgs(call.name, args);
+              if (typeof repaired === "string" && repaired !== args) {
+                log(`[DevinConnect] tool call repaired: ${call.name}`);
+                args = repaired;
+              }
+            } catch (err) {
+              log(`[DevinConnect] repairToolArgs threw for ${call.name}: ${err}`);
+            }
+          }
+          send("content_block_delta", {
+            type: "content_block_delta",
+            index: call.blockIndex,
+            delta: { type: "input_json_delta", partial_json: args || "{}" }
+          });
+        } else if (!call.args) {
+          send("content_block_delta", {
+            type: "content_block_delta",
+            index: call.blockIndex,
+            delta: { type: "input_json_delta", partial_json: "{}" }
+          });
+        }
+        send("content_block_stop", { type: "content_block_stop", index: call.blockIndex });
+        call.closed = true;
+      };
+      const finalize = (reason, errorMessage) => {
+        if (finalized2)
+          return;
+        finalized2 = true;
+        closeCurrentTool();
+        closeThinking();
+        closeText();
+        if (servedModel && servedModel !== opts.modelName) {
+          log(`[DevinConnect] served model: ${servedModel} (requested ${opts.modelName})`);
+        }
+        if (sawUsage) {
+          log(`[DevinConnect] usage: input=${inputTokens}, output=${outputTokens}` + (rawStopReason !== null ? `, raw stop_reason=${rawStopReason}` : ""));
+        }
+        opts.onTokenUpdate?.(inputTokens, outputTokens);
+        if (reason === "error") {
+          log(`[DevinConnect] stream error: ${errorMessage}`);
+          send("error", { type: "error", error: { type: "api_error", message: errorMessage } });
+        } else {
+          send("message_delta", {
+            type: "message_delta",
+            delta: {
+              stop_reason: toolBlocksEmitted > 0 ? "tool_use" : "end_turn",
+              stop_sequence: null
+            },
+            usage: {
+              ...inputTokens > 0 ? { input_tokens: inputTokens } : {},
+              output_tokens: outputTokens
+            }
+          });
+          opts.onTurnEnd?.();
+          send("message_stop", { type: "message_stop" });
+        }
+        if (!isClosed) {
+          isClosed = true;
+          if (pingInterval) {
+            clearInterval(pingInterval);
+            pingInterval = null;
+          }
+          try {
+            controller.close();
+          } catch {}
+        }
+      };
+      const readUsageGroup = (payload) => {
+        for (const entry of parseTLV(payload)) {
+          if (entry.no !== USAGE_ENTRY || entry.wire !== 2)
+            continue;
+          let key = "";
+          let value = null;
+          for (const field of parseTLV(entry.payload)) {
+            if (field.no === USAGE_ENTRY_KEY && field.wire === 2) {
+              key = readString(field);
+            } else if (field.no === USAGE_ENTRY_STAT && field.wire === 2) {
+              for (const stat2 of parseTLV(field.payload)) {
+                if (stat2.no === USAGE_STAT_VALUE && stat2.wire === 5) {
+                  value = Math.round(readFloat32LE(stat2));
+                }
+              }
+            }
+          }
+          if (key === USAGE_KEY_INPUT) {
+            inputTokens = value ?? 0;
+            sawUsage = true;
+          } else if (key === USAGE_KEY_OUTPUT) {
+            outputTokens = value ?? 0;
+            sawUsage = true;
+          }
+        }
+      };
+      const readToolCall = (payload) => {
+        let id = "";
+        let name = "";
+        let fragment = null;
+        for (const field of parseTLV(payload)) {
+          if (field.no === TOOL_ID && field.wire === 2)
+            id = readString(field);
+          else if (field.no === TOOL_NAME && field.wire === 2)
+            name = readString(field);
+          else if (field.no === TOOL_ARGS_FRAGMENT && field.wire === 2)
+            fragment = field;
+        }
+        if (name) {
+          closeCurrentTool();
+          closeThinking();
+          closeText();
+          const restored = opts.toolNameMap?.get(name) ?? name;
+          const blockIndex = curIdx++;
+          const toolId = id || `toolu_${Date.now()}_${blockIndex}`;
+          current = {
+            id: toolId,
+            name: restored,
+            blockIndex,
+            buffered: opts.shouldBufferTool?.(restored) ?? false,
+            args: "",
+            decoder: new TextDecoder,
+            closed: false
+          };
+          toolBlocksEmitted++;
+          opts.onToolCallObserved?.(restored);
+          send("content_block_start", {
+            type: "content_block_start",
+            index: blockIndex,
+            content_block: { type: "tool_use", id: toolId, name: restored, input: {} }
+          });
+        }
+        if (!fragment)
+          return;
+        const chunk = current ? current.decoder.decode(fragment.payload, { stream: true }) : readString(fragment);
+        if (!chunk)
+          return;
+        if (!current) {
+          log("[DevinConnect] argument fragment with no open tool call, dropping");
+          return;
+        }
+        current.args += chunk;
+        if (!current.buffered) {
+          send("content_block_delta", {
+            type: "content_block_delta",
+            index: current.blockIndex,
+            delta: { type: "input_json_delta", partial_json: chunk }
+          });
+        }
+      };
+      const readMessageFrame = (payload) => {
+        for (const field of parseTLV(payload)) {
+          lastActivity = Date.now();
+          if (field.no === FIELD_TEXT && field.wire === 2) {
+            const text = textDecoder2.decode(field.payload, { stream: true });
+            if (!text)
+              continue;
+            closeCurrentTool();
+            closeThinking();
+            if (!textStarted) {
+              textIdx = curIdx++;
+              send("content_block_start", {
+                type: "content_block_start",
+                index: textIdx,
+                content_block: { type: "text", text: "" }
+              });
+              textStarted = true;
+            }
+            opts.onAssistantText?.(text, "text");
+            send("content_block_delta", {
+              type: "content_block_delta",
+              index: textIdx,
+              delta: { type: "text_delta", text }
+            });
+          } else if (field.no === FIELD_REASONING && field.wire === 2) {
+            const thinking = reasoningDecoder.decode(field.payload, { stream: true });
+            if (!thinking)
+              continue;
+            closeCurrentTool();
+            if (!thinkingStarted) {
+              thinkingIdx = curIdx++;
+              send("content_block_start", {
+                type: "content_block_start",
+                index: thinkingIdx,
+                content_block: { type: "thinking", thinking: "" }
+              });
+              thinkingStarted = true;
+            }
+            opts.onAssistantText?.(thinking, "reasoning");
+            send("content_block_delta", {
+              type: "content_block_delta",
+              index: thinkingIdx,
+              delta: { type: "thinking_delta", thinking }
+            });
+          } else if (field.no === FIELD_TOOL_CALL && field.wire === 2) {
+            readToolCall(field.payload);
+          } else if (field.no === FIELD_STOP_REASON && field.wire === 0) {
+            rawStopReason = readVarintValue(field);
+          } else if (field.no === FIELD_META && field.wire === 2) {
+            for (const sub of parseTLV(field.payload)) {
+              if (sub.no === META_SERVED_MODEL && sub.wire === 2) {
+                const uid = readString(sub);
+                if (uid && uid !== servedModel) {
+                  servedModel = uid;
+                  opts.onServedModel?.(uid);
+                }
+              }
+            }
+          } else if (field.no === FIELD_USAGE && field.wire === 2) {
+            readUsageGroup(field.payload);
+          }
+        }
+      };
+      try {
+        const body = response.body;
+        if (!body) {
+          finalize("error", "Devin returned no response body");
+          return;
+        }
+        const reader = body.getReader();
+        const nextFrames = createFrameReader();
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done)
+            break;
+          if (!value)
+            continue;
+          for (const frame of nextFrames(value)) {
+            if (frame.flags === FRAME_FLAG_END_OF_STREAM) {
+              const raw = new TextDecoder().decode(frame.payload).trim();
+              if (!raw || raw === "{}") {
+                finalize("done");
+                return;
+              }
+              let code = "unknown";
+              let message = raw;
+              try {
+                const parsed = JSON.parse(raw);
+                code = String(parsed?.error?.code ?? parsed?.code ?? "unknown");
+                message = String(parsed?.error?.message ?? parsed?.message ?? raw);
+              } catch {}
+              opts.onApiError?.(code, message);
+              finalize("error", `${code}: ${message}`);
+              return;
+            }
+            readMessageFrame(frame.payload);
+          }
+        }
+        finalize("done");
+      } catch (e) {
+        finalize("error", String(e));
+      }
+    },
+    cancel() {
+      isClosed = true;
+      if (pingInterval) {
+        clearInterval(pingInterval);
+        pingInterval = null;
+      }
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    }
+  });
+}
+var FIELD_TEXT = 3, FIELD_STOP_REASON = 5, FIELD_TOOL_CALL = 6, FIELD_META = 7, FIELD_REASONING = 9, FIELD_USAGE = 28, TOOL_ID = 1, TOOL_NAME = 2, TOOL_ARGS_FRAGMENT = 3, META_SERVED_MODEL = 9, USAGE_ENTRY = 2, USAGE_ENTRY_KEY = 5, USAGE_ENTRY_STAT = 4, USAGE_STAT_VALUE = 2, USAGE_KEY_INPUT = "input_tokens", USAGE_KEY_OUTPUT = "output_tokens";
+var init_devin_connect = __esm(() => {
+  init_logger();
+  init_proto_codec();
+});
+
 // src/handlers/shared/stream-parsers/gemini-sse.ts
 function createGeminiSseStream(_c, response, opts) {
   const encoder = new TextEncoder;
@@ -39193,6 +39840,7 @@ data: ${JSON.stringify(data)}
       const toolCalls = new Map;
       let accumulatedText = "";
       let lastActivity = Date.now();
+      let truncated = false;
       send("message_start", {
         type: "message_start",
         message: {
@@ -39244,9 +39892,13 @@ data: ${JSON.stringify(data)}
           send("error", { type: "error", error: { type: "api_error", message: err } });
         } else {
           const hasToolCalls = toolCalls.size > 0;
+          const stopReason = truncated ? "max_tokens" : hasToolCalls ? "tool_use" : "end_turn";
+          if (truncated) {
+            log("[GeminiSSE] finishReason=MAX_TOKENS \u2192 stop_reason=max_tokens");
+          }
           send("message_delta", {
             type: "message_delta",
-            delta: { stop_reason: hasToolCalls ? "tool_use" : "end_turn", stop_sequence: null },
+            delta: { stop_reason: stopReason, stop_sequence: null },
             usage: {
               ...inputTokens > 0 ? { input_tokens: inputTokens } : {},
               output_tokens: outputTokens
@@ -39295,8 +39947,9 @@ data: ${JSON.stringify(data)}
               if (candidate?.content?.parts) {
                 for (const part of candidate.content.parts) {
                   lastActivity = Date.now();
-                  if (part.thought || part.thoughtText) {
-                    const thinkingContent = part.thought || part.thoughtText;
+                  const isThoughtPart = part.thought === true;
+                  const thinkingContent = isThoughtPart ? part.text ?? "" : part.thoughtText;
+                  if (thinkingContent) {
                     if (!thinkingStarted) {
                       thinkingIdx = curIdx++;
                       send("content_block_start", {
@@ -39312,7 +39965,7 @@ data: ${JSON.stringify(data)}
                       delta: { type: "thinking_delta", thinking: thinkingContent }
                     });
                   }
-                  if (part.text) {
+                  if (part.text && !isThoughtPart) {
                     if (thinkingStarted) {
                       send("content_block_stop", {
                         type: "content_block_stop",
@@ -39324,6 +39977,10 @@ data: ${JSON.stringify(data)}
                     if (opts.adapter) {
                       const res = opts.adapter.processTextContent(part.text, accumulatedText);
                       cleanedText = res.cleanedText || "";
+                      if (!cleanedText) {
+                        log(`[gemini-sse] adapter emptied ${part.text.length} chars of visible text \u2014 passing the original through`);
+                        cleanedText = part.text;
+                      }
                       accumulatedText += cleanedText;
                     } else {
                       accumulatedText += cleanedText;
@@ -39401,6 +40058,7 @@ data: ${JSON.stringify(data)}
               }
               if (candidate?.finishReason) {
                 if (candidate.finishReason === "STOP" || candidate.finishReason === "MAX_TOKENS") {
+                  truncated = candidate.finishReason === "MAX_TOKENS";
                   await finalize("done");
                   return;
                 }
@@ -39976,8 +40634,8 @@ var init_openai_responses_sse = __esm(() => {
 
 // src/handlers/shared/token-tracker.ts
 import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync9 } from "fs";
-import { homedir as homedir23 } from "os";
-import { dirname as dirname8, join as join23 } from "path";
+import { homedir as homedir24 } from "os";
+import { dirname as dirname8, join as join24 } from "path";
 function stripProviderPrefix(name) {
   const at = name.indexOf("@");
   return at === -1 ? name : name.slice(at + 1);
@@ -40139,7 +40797,7 @@ class TokenTracker {
         };
       }
       const override = process.env.CLAUDISH_TOKEN_FILE;
-      const outPath = override || join23(homedir23(), ".claudish", `tokens-${this.port}.json`);
+      const outPath = override || join24(homedir24(), ".claudish", `tokens-${this.port}.json`);
       mkdirSync10(dirname8(outPath), { recursive: true });
       writeFileSync9(outPath, JSON.stringify(data), "utf-8");
     } catch (e) {
@@ -40237,10 +40895,10 @@ class ComposedHandler {
     if (!this.getModelSupportsVision()) {
       const imageBlocks = [];
       for (let msgIdx = 0;msgIdx < messages.length; msgIdx++) {
-        const msg = messages[msgIdx];
-        if (Array.isArray(msg.content)) {
-          for (let partIdx = 0;partIdx < msg.content.length; partIdx++) {
-            const part = msg.content[partIdx];
+        const msg2 = messages[msgIdx];
+        if (Array.isArray(msg2.content)) {
+          for (let partIdx = 0;partIdx < msg2.content.length; partIdx++) {
+            const part = msg2.content[partIdx];
             if (part.type === "image_url" || part.type === "image" || part.type === "document") {
               imageBlocks.push({ msgIdx, partIdx, block: part });
             }
@@ -40264,25 +40922,25 @@ class ComposedHandler {
             };
           }
           log(`[ComposedHandler] Vision proxy described ${descriptions.length} image(s)`);
-          for (const msg of messages) {
-            if (Array.isArray(msg.content)) {
-              msg.content = msg.content.filter((part) => part.type !== "image" && part.type !== "document");
-              if (msg.content.length === 1 && msg.content[0].type === "text") {
-                msg.content = msg.content[0].text;
-              } else if (msg.content.length === 0) {
-                msg.content = "";
+          for (const msg2 of messages) {
+            if (Array.isArray(msg2.content)) {
+              msg2.content = msg2.content.filter((part) => part.type !== "image" && part.type !== "document");
+              if (msg2.content.length === 1 && msg2.content[0].type === "text") {
+                msg2.content = msg2.content[0].text;
+              } else if (msg2.content.length === 0) {
+                msg2.content = "";
               }
             }
           }
         } else {
           log("[ComposedHandler] Stripping image/document blocks (vision not supported)");
-          for (const msg of messages) {
-            if (Array.isArray(msg.content)) {
-              msg.content = msg.content.filter((part) => part.type !== "image_url" && part.type !== "image" && part.type !== "document");
-              if (msg.content.length === 1 && msg.content[0].type === "text") {
-                msg.content = msg.content[0].text;
-              } else if (msg.content.length === 0) {
-                msg.content = "";
+          for (const msg2 of messages) {
+            if (Array.isArray(msg2.content)) {
+              msg2.content = msg2.content.filter((part) => part.type !== "image_url" && part.type !== "image" && part.type !== "document");
+              if (msg2.content.length === 1 && msg2.content[0].type === "text") {
+                msg2.content = msg2.content[0].text;
+              } else if (msg2.content.length === 0) {
+                msg2.content = "";
               }
             }
           }
@@ -40320,7 +40978,7 @@ class ComposedHandler {
     const behaviorSession = this.behaviorEngine.startSession({
       modelId: this.bareModelName,
       providerName: this.provider.name,
-      isNativeAnthropic: /^claude[-.]/i.test(this.bareModelName) || this.provider.name === "anthropic"
+      isNativeAnthropic: !this.options.forceForeignModel && (/^claude[-.]/i.test(this.bareModelName) || this.provider.name === "anthropic")
     });
     if (!behaviorSession.isNoop) {
       behaviorSession.applyRequest(claudeRequest, claudeRequest.tools ?? [], tools, messages);
@@ -40376,13 +41034,14 @@ class ComposedHandler {
     }
     const endpoint = this.provider.getEndpoint(this.targetModel);
     const headers = await this.provider.getHeaders();
-    headers["Content-Type"] = "application/json";
+    const serialized = this.provider.serializeBody?.(requestPayload);
+    headers["Content-Type"] = serialized?.contentType ?? "application/json";
     log(`[${this.provider.displayName}] Calling API: ${endpoint}`);
     const requestInit = this.provider.getRequestInit?.() || {};
     const doFetch = () => fetch(endpoint, {
       method: "POST",
       headers,
-      body: JSON.stringify(requestPayload),
+      body: serialized?.body ?? JSON.stringify(requestPayload),
       ...requestInit
     });
     let response;
@@ -40391,9 +41050,9 @@ class ComposedHandler {
     } catch (error46) {
       const conn = classifyConnectionError(error46);
       if (conn) {
-        const msg = buildConnectionErrorMessage(conn.kind, this.provider.displayName, endpoint);
-        log(`[${this.provider.displayName}] ${msg} (code=${conn.code})`);
-        logStderr(`Error: ${msg}`);
+        const msg2 = buildConnectionErrorMessage(conn.kind, this.provider.displayName, endpoint);
+        log(`[${this.provider.displayName}] ${msg2} (code=${conn.code})`);
+        logStderr(`Error: ${msg2}`);
         reportError({
           error: error46,
           providerName: this.provider.name,
@@ -40425,7 +41084,7 @@ class ComposedHandler {
             invocation_mode: this.options.invocationMode ?? "auto-route"
           });
         } catch {}
-        return c.json(wrapAnthropicError(400, msg, "connection_error"), 400);
+        return c.json(wrapAnthropicError(400, msg2, "connection_error"), 400);
       }
       throw error46;
     }
@@ -40442,12 +41101,12 @@ class ComposedHandler {
         try {
           await this.provider.forceRefreshAuth();
           const retryHeaders = await this.provider.getHeaders();
-          retryHeaders["Content-Type"] = "application/json";
+          retryHeaders["Content-Type"] = serialized?.contentType ?? "application/json";
           const retryInit = this.provider.getRequestInit?.() || {};
           const retryResp = await fetch(endpoint, {
             method: "POST",
             headers: retryHeaders,
-            body: JSON.stringify(requestPayload),
+            body: serialized?.body ?? JSON.stringify(requestPayload),
             ...retryInit
           });
           if (retryResp.ok) {
@@ -40627,6 +41286,48 @@ class ComposedHandler {
       }
       response = settled.response;
     }
+    if (this.resolveStreamFormat() === "connect-proto") {
+      const settled = await this.settleDevinStreamHead(response, () => this.provider.enqueueRequest ? this.provider.enqueueRequest(doFetch) : doFetch());
+      if (settled.kind !== "ok") {
+        const isTerminal2 = settled.kind === "terminal";
+        const httpStatus2 = isTerminal2 ? 400 : 503;
+        const surfaced = isTerminal2 ? `${this.provider.displayName} rejected the request (${settled.code}): ${settled.message}` : `${this.provider.displayName} is overloaded upstream (${settled.code}): ${settled.message} ` + `claudish retried ${settled.attempts}\xD7 over ` + `${Math.round(STREAM_RETRY_DELAYS_MS.slice(0, settled.attempts).reduce((sum, ms) => sum + ms, 0) / 1000)}s without success.`;
+        logStderr(`Error: ${surfaced}`);
+        reportError({
+          error: new Error(settled.message),
+          providerName: this.provider.name,
+          providerDisplayName: this.provider.displayName,
+          streamFormat: this.provider.streamFormat,
+          modelId: this.targetModel,
+          httpStatus: httpStatus2,
+          isStreaming: true,
+          retryAttempted: !isTerminal2,
+          isInteractive: this.isInteractive,
+          providerErrorType: settled.code
+        });
+        try {
+          recordStats({
+            model_id: this.targetModel,
+            provider_name: this.provider.name,
+            stream_format: this.provider.streamFormat,
+            latency_ms: Math.round(performance.now() - startTime),
+            success: false,
+            http_status: httpStatus2,
+            error_class: isTerminal2 ? "client_error" : "server_error",
+            error_code: settled.code,
+            token_strategy: this.options.tokenStrategy ?? "standard",
+            adapter_name: this.getActiveAdapterName(),
+            middleware_names: this.middlewareManager.getActiveNames(this.bareModelName),
+            fallback_used: fallbackMeta !== undefined,
+            fallback_chain: fallbackMeta?.chain,
+            fallback_attempts: fallbackMeta?.attempts,
+            invocation_mode: this.options.invocationMode ?? "auto-route"
+          });
+        } catch {}
+        return isTerminal2 ? c.json(wrapAnthropicError(400, surfaced, "invalid_request_error"), 400) : c.json(wrapAnthropicError(503, surfaced, "overloaded_error"), 503);
+      }
+      response = settled.response;
+    }
     latencyMs = Math.round(performance.now() - startTime);
     const httpStatus = response.status;
     this.capturePlanUsage(response);
@@ -40705,6 +41406,55 @@ class ComposedHandler {
       response = next;
     }
   }
+  async settleDevinStreamHead(initial, reissue) {
+    const rewrite = this.provider.rewriteInStreamError?.bind(this.provider);
+    let response = initial;
+    for (let attempt = 0;; attempt++) {
+      const verdict = await sniffDevinStreamHead(response, { log });
+      if (verdict.kind === "clean")
+        return { kind: "ok", response: verdict.response };
+      if (verdict.kind === "terminal") {
+        const message = rewrite?.(verdict.code, verdict.message) ?? verdict.message;
+        log(`[${this.provider.displayName}] terminal in-stream error ${verdict.code}`);
+        return { kind: "terminal", code: verdict.code, message };
+      }
+      const delayMs = STREAM_RETRY_DELAYS_MS[attempt];
+      if (delayMs === undefined) {
+        log(`[${this.provider.displayName}] in-stream ${verdict.code} persisted after ` + `${attempt} retries \u2014 surfacing 503 so the client can retry`);
+        return {
+          kind: "exhausted",
+          code: verdict.code,
+          message: verdict.message,
+          attempts: attempt
+        };
+      }
+      log(`[${this.provider.displayName}] in-stream ${verdict.code} before any output \u2014 ` + `retry ${attempt + 1}/${STREAM_RETRY_DELAYS_MS.length} in ${delayMs / 1000}s`);
+      await new Promise((resolve2) => setTimeout(resolve2, delayMs));
+      let next;
+      try {
+        next = await reissue();
+      } catch (error46) {
+        log(`[${this.provider.displayName}] retry fetch failed: ${error46}`);
+        return {
+          kind: "exhausted",
+          code: verdict.code,
+          message: `${verdict.message} (retry could not reach the provider: ${error46})`,
+          attempts: attempt + 1
+        };
+      }
+      if (!next.ok) {
+        const body = await next.text().catch(() => "");
+        log(`[${this.provider.displayName}] retry returned HTTP ${next.status}`);
+        return {
+          kind: "exhausted",
+          code: `http_${next.status}`,
+          message: body.slice(0, 500) || `HTTP ${next.status}`,
+          attempts: attempt + 1
+        };
+      }
+      response = next;
+    }
+  }
   resolveStreamFormat() {
     return this.provider.overrideStreamFormat?.() ?? this.explicitAdapter?.getStreamFormat() ?? this.modelAdapter?.getStreamFormat() ?? this.getAdapter().getStreamFormat();
   }
@@ -40790,6 +41540,23 @@ class ComposedHandler {
           priorInputTokens
         });
       }
+      case "connect-proto":
+        return createDevinConnectStream(c, response, {
+          modelName: this.bareModelName,
+          onTokenUpdate,
+          priorInputTokens,
+          onApiError,
+          toolNameMap,
+          onServedModel: (uid) => {
+            if (uid !== this.bareModelName)
+              this.tokenTracker.setActiveModelName(uid);
+          },
+          repairToolArgs: (name, argsJson) => behaviorSession?.repairToolCall(name, argsJson) ?? null,
+          shouldBufferTool: (name) => behaviorSession?.interceptsTool(name) ?? false,
+          onAssistantText: (text, kind) => behaviorSession?.observeText(text, kind),
+          onToolCallObserved: (name) => behaviorSession?.observeToolCall(name),
+          onTurnEnd: () => behaviorSession?.finishTurn()
+        });
       case "ollama-jsonl":
         return createOllamaJsonlStream(c, response, {
           modelName: this.bareModelName,
@@ -40894,10 +41661,12 @@ var init_composed_handler = __esm(() => {
   init_anthropic_error();
   init_connection_error();
   init_context_window_fallback();
+  init_devin_stream_head_sniffer();
   init_openai_compat();
   init_quota_exhaustion();
   init_stream_head_sniffer();
   init_anthropic_sse();
+  init_devin_connect();
   init_gemini_sse();
   init_ollama_jsonl();
   init_openai_responses_sse();
@@ -40906,6 +41675,209 @@ var init_composed_handler = __esm(() => {
   STREAM_RETRY_DELAYS_MS = [3000, 15000, 30000];
 });
 
+// src/providers/devin/devin-request.ts
+import { randomUUID as randomUUID4 } from "crypto";
+function encodeChatMetadata(meta3) {
+  const version2 = meta3.clientVersion ?? DEVIN_CLI_VERSION;
+  return msg(bytes(1, "devin-cli"), bytes(2, version2), bytes(3, meta3.apiKey), bytes(4, "en"), bytes(5, meta3.platform ?? process.platform), bytes(7, version2), bytes(12, "chisel"), bytes(28, "chisel"));
+}
+function encodeMessage(message) {
+  const parts = [
+    bytes(1, message.id ?? randomUUID4()),
+    vint(2, DEVIN_ROLE[message.role])
+  ];
+  if (message.text)
+    parts.push(bytes(3, message.text));
+  if (message.toolCall) {
+    parts.push(bytes(6, msg(bytes(1, message.toolCall.id), bytes(2, message.toolCall.name), bytes(3, message.toolCall.argumentsJson))));
+  }
+  if (message.toolCallId)
+    parts.push(bytes(7, message.toolCallId));
+  return msg(...parts);
+}
+function encodeTool(tool) {
+  return msg(bytes(1, tool.name), bytes(2, tool.description ?? ""), bytes(3, tool.parametersJson));
+}
+function encodeRequestBodyParts(req) {
+  const parts = [];
+  if (req.system)
+    parts.push(bytes(2, req.system));
+  for (const message of req.messages)
+    parts.push(bytes(3, encodeMessage(message)));
+  parts.push(vint(7, req.modelEnum ?? DEFAULT_MODEL_ENUM));
+  for (const tool of req.tools ?? [])
+    parts.push(bytes(10, encodeTool(tool)));
+  parts.push(bytes(21, req.modelUid));
+  return parts;
+}
+function encodeDevinRequest(req, meta3) {
+  const body = msg(bytes(1, encodeChatMetadata(meta3)), ...encodeRequestBodyParts(req));
+  return envelope(body);
+}
+function describeDevinRequestForLog(req) {
+  const roles = { user: 0, assistant: 0, tool_result: 0 };
+  let toolCalls = 0;
+  for (const message of req.messages) {
+    roles[message.role]++;
+    if (message.toolCall)
+      toolCalls++;
+  }
+  const size = encodeRequestBodyParts(req).reduce((total, part) => total + part.length, 0);
+  const fields = [
+    `uid=${req.modelUid}`,
+    `enum=${req.modelEnum ?? DEFAULT_MODEL_ENUM}`,
+    `messages=${req.messages.length}`,
+    `(user ${roles.user}/assistant ${roles.assistant}/tool_result ${roles.tool_result}`,
+    `calls ${toolCalls})`,
+    `tools=${req.tools?.length ?? 0}`,
+    `system=${req.system?.length ?? 0}ch`
+  ];
+  fields.push(`body=${size}B (excl. metadata)`);
+  return fields.join(" ");
+}
+var DEVIN_CLI_VERSION = "3000.3.27", DEFAULT_MODEL_ENUM = 5, DEVIN_ROLE;
+var init_devin_request = __esm(() => {
+  init_proto_codec();
+  DEVIN_ROLE = {
+    user: 1,
+    assistant: 2,
+    tool_result: 4
+  };
+});
+
+// src/providers/devin/devin-models.ts
+var exports_devin_models = {};
+__export(exports_devin_models, {
+  getServedDevinModels: () => getServedDevinModels,
+  fetchDevinModelConfigs: () => fetchDevinModelConfigs,
+  fetchDevinAllowedUids: () => fetchDevinAllowedUids,
+  _resetDevinModelCache: () => _resetDevinModelCache
+});
+function unaryMetadata(apiKey) {
+  return msg(bytes(1, "chisel"), bytes(2, DEVIN_CLI_VERSION), bytes(3, apiKey), bytes(4, "en"), bytes(5, process.platform), bytes(7, DEVIN_CLI_VERSION));
+}
+async function postUnary(path, apiKey) {
+  const url2 = `${readDevinServerUrl()}${path}`;
+  try {
+    const response = await fetch(url2, {
+      method: "POST",
+      headers: {
+        authorization: `Basic ${apiKey}-${apiKey}`,
+        "content-type": "application/proto",
+        "connect-protocol-version": "1"
+      },
+      body: msg(bytes(1, unaryMetadata(apiKey))),
+      signal: AbortSignal.timeout(UNARY_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+      log(`[Devin] ${path} failed: HTTP ${response.status}`);
+      return null;
+    }
+    return new Uint8Array(await response.arrayBuffer());
+  } catch (err) {
+    log(`[Devin] ${path} error: ${err}`);
+    return null;
+  }
+}
+function decodeModelDetails(payload) {
+  let maxOutput = 0;
+  let family = "";
+  for (const sub of parseTLV(payload)) {
+    if (sub.no === 13 && sub.wire === 0)
+      maxOutput = readVarintValue(sub);
+    else if (sub.no === 23 && sub.wire === 2)
+      family = readString(sub);
+  }
+  return { maxOutput, family };
+}
+function decodeModelConfig(payload) {
+  let uid = "";
+  let displayName = "";
+  let contextWindow = 0;
+  let details = { maxOutput: 0, family: "" };
+  for (const field of parseTLV(payload)) {
+    if (field.no === 22 && field.wire === 2)
+      uid = readString(field);
+    else if (field.no === 1 && field.wire === 2)
+      displayName = readString(field);
+    else if (field.no === 18 && field.wire === 0)
+      contextWindow = readVarintValue(field);
+    else if (field.no === 23 && field.wire === 2)
+      details = decodeModelDetails(field.payload);
+  }
+  if (!uid)
+    return null;
+  return { uid, displayName: displayName || uid, contextWindow, ...details };
+}
+function topLevelDelimited(body, fieldNumber) {
+  return parseTLV(body).filter((field) => field.no === fieldNumber && field.wire === 2);
+}
+async function fetchDevinModelConfigs(apiKey) {
+  const body = await postUnary(MODEL_CONFIGS_PATH, apiKey);
+  if (!body)
+    return [];
+  const configs = [];
+  for (const field of topLevelDelimited(body, 1)) {
+    const config2 = decodeModelConfig(field.payload);
+    if (config2)
+      configs.push(config2);
+  }
+  log(`[Devin] GetCliModelConfigs: ${configs.length} configs`);
+  return configs;
+}
+async function fetchDevinAllowedUids(apiKey) {
+  const body = await postUnary(TEAM_SETTINGS_PATH, apiKey);
+  if (!body)
+    return [];
+  const uids = [];
+  for (const field of topLevelDelimited(body, 7)) {
+    const uid = readString(field).trim();
+    if (uid)
+      uids.push(uid);
+  }
+  log(`[Devin] GetCliTeamSettings: ${uids.length} allowed uids`);
+  return uids;
+}
+async function getServedDevinModels(opts) {
+  const now = Date.now();
+  if (!opts?.force && rosterCache && now - rosterCacheAt < ROSTER_TTL_MS)
+    return rosterCache;
+  const apiKey = opts?.apiKey ?? readDevinApiKey();
+  if (!apiKey)
+    return rosterCache ?? [];
+  try {
+    const [configs, allowed] = await Promise.all([
+      fetchDevinModelConfigs(apiKey),
+      fetchDevinAllowedUids(apiKey)
+    ]);
+    if (configs.length === 0)
+      return rosterCache ?? [];
+    const entitled = new Set(allowed);
+    const served = configs.filter((config2) => config2.contextWindow > 0 && (entitled.size === 0 || entitled.has(config2.uid)));
+    if (entitled.size === 0) {
+      log("[Devin] entitlement unknown \u2014 using the full config list (superset)");
+    }
+    rosterCache = served;
+    rosterCacheAt = now;
+    return served;
+  } catch (err) {
+    log(`[Devin] served-model discovery error: ${err}`);
+    return rosterCache ?? [];
+  }
+}
+function _resetDevinModelCache() {
+  rosterCache = null;
+  rosterCacheAt = 0;
+}
+var MODEL_CONFIGS_PATH = "/exa.api_server_pb.ApiServerService/GetCliModelConfigs", TEAM_SETTINGS_PATH = "/exa.seat_management_pb.SeatManagementService/GetCliTeamSettings", ROSTER_TTL_MS, UNARY_TIMEOUT_MS = 1e4, rosterCache = null, rosterCacheAt = 0;
+var init_devin_models = __esm(() => {
+  init_logger();
+  init_devin_credentials();
+  init_devin_request();
+  init_proto_codec();
+  ROSTER_TTL_MS = 5 * 60 * 1000;
+});
+
 // src/providers/model-discovery.ts
 function resolveBaseUrl(catalogName) {
   const def = getProviderByName(catalogName);
@@ -40966,6 +41938,22 @@ async function discoverProviderModels(providerName) {
   const descriptor = def?.modelDiscovery;
   if (!def || !descriptor)
     return [];
+  if (descriptor.format === "devin-connect") {
+    const { getServedDevinModels: getServedDevinModels2 } = await Promise.resolve().then(() => (init_devin_models(), exports_devin_models));
+    const served = await getServedDevinModels2();
+    if (served.length === 0) {
+      log(`[model-discovery:${providerName}] no models for this subscription`);
+      return [];
+    }
+    const models2 = served.map((model) => ({
+      id: model.uid,
+      displayName: model.displayName,
+      contextWindow: model.contextWindow
+    }));
+    log(`[model-discovery:${providerName}] discovered ${models2.length} models`);
+    _cache.set(providerName, { models: models2, expiresAt: Date.now() + CACHE_TTL_MS });
+    return models2;
+  }
   const baseUrl = resolveBaseUrl(providerName);
   if (!baseUrl)
     return [];
@@ -41140,24 +42128,24 @@ async function discoverViaOpenAIModels(endpoint, headers, cacheKey) {
 function classifyFetchError(e, endpoint) {
   const name = e?.name ?? "";
   const code = e?.cause?.code ?? "";
-  const msg = e instanceof Error ? e.message : String(e);
+  const msg2 = e instanceof Error ? e.message : String(e);
   const url2 = tryParseUrl(endpoint);
   const host = url2?.host ?? endpoint;
   const isLocal = !!url2 && /^(localhost|127\.0\.0\.1|0\.0\.0\.0|::1)$/i.test(url2.hostname);
-  if (name === "TimeoutError" || name === "AbortError" || /timeout/i.test(msg)) {
+  if (name === "TimeoutError" || name === "AbortError" || /timeout/i.test(msg2)) {
     return `${host} unresponsive (>${FETCH_TIMEOUT_MS2 / 1000}s) \u2014 check if the server is overloaded`;
   }
   if (code === "ENOTFOUND" || code === "EAI_AGAIN") {
     return `cannot resolve host ${url2?.hostname ?? endpoint} \u2014 check the URL`;
   }
-  const isConnRefused = code === "ECONNREFUSED" || code === "ECONNRESET" || /unable to connect|connection refused|fetch failed/i.test(msg);
+  const isConnRefused = code === "ECONNREFUSED" || code === "ECONNRESET" || /unable to connect|connection refused|fetch failed/i.test(msg2);
   if (isConnRefused) {
     if (isLocal) {
       return `${host} not reachable \u2014 is the server running? Press u to change URL.`;
     }
     return `${host} not reachable \u2014 check the URL or network. Press u to change.`;
   }
-  return `${host}: ${msg}`;
+  return `${host}: ${msg2}`;
 }
 function tryParseUrl(s) {
   try {
@@ -42184,6 +43172,10 @@ function buildCredentialHint(modelName, providers) {
       lines.push(`  Run:  claudish ${hint.loginFlag}  (authenticate via OAuth)`);
       hasOption = true;
     }
+    if (hint.note) {
+      lines.push(`  ${hint.note}`);
+      hasOption = true;
+    }
     if (hint.apiKeyEnvVar) {
       lines.push(`  Set:  export ${hint.apiKeyEnvVar}=your-key  (for ${provider})`);
       hasOption = true;
@@ -42206,6 +43198,10 @@ var init_routing_hints = __esm(() => {
     google: { loginFlag: "login gemini", apiKeyEnvVar: "GEMINI_API_KEY" },
     "gemini-codeassist": { loginFlag: "login gemini", apiKeyEnvVar: "GEMINI_API_KEY" },
     antigravity: { loginFlag: "login antigravity" },
+    devin: {
+      note: "Sign in with the Devin CLI (`devin login`) \u2014 claudish reads ~/.local/share/devin/credentials.toml",
+      apiKeyEnvVar: "WINDSURF_API_KEY"
+    },
     openai: { apiKeyEnvVar: "OPENAI_API_KEY" },
     "openai-codex": { loginFlag: "login codex", apiKeyEnvVar: "OPENAI_CODEX_API_KEY" },
     minimax: { apiKeyEnvVar: "MINIMAX_API_KEY" },
@@ -43108,10 +44104,10 @@ var init_signal_watcher = __esm(() => {
 
 // src/channel/session-manager.ts
 import { spawn } from "child_process";
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 import { createWriteStream, mkdirSync as mkdirSync11, writeFileSync as writeFileSync10 } from "fs";
-import { homedir as homedir24 } from "os";
-import { join as join24 } from "path";
+import { homedir as homedir25 } from "os";
+import { join as join25 } from "path";
 
 class SessionManager {
   sessions = new Map;
@@ -43123,20 +44119,20 @@ class SessionManager {
   constructor(options) {
     this.maxSessions = options?.maxSessions ?? DEFAULT_MAX_SESSIONS;
     this.scrollbackCapacity = options?.scrollbackCapacity ?? DEFAULT_SCROLLBACK;
-    this.sessionsDir = options?.sessionsDir ?? process.env.CLAUDISH_SESSIONS_DIR ?? join24(homedir24(), ".claudish", "sessions");
+    this.sessionsDir = options?.sessionsDir ?? process.env.CLAUDISH_SESSIONS_DIR ?? join25(homedir25(), ".claudish", "sessions");
     this.onStateChange = options?.onStateChange;
   }
   createSession(opts) {
     if (this.activeSessions >= this.maxSessions) {
       throw new Error(`Max sessions (${this.maxSessions}) reached`);
     }
-    const sessionId2 = randomUUID4().slice(0, 8);
+    const sessionId2 = randomUUID5().slice(0, 8);
     const timeout = Math.min(opts.timeoutSeconds ?? DEFAULT_TIMEOUT, MAX_TIMEOUT);
     const startedAt = new Date().toISOString();
-    const sessionDir = join24(this.sessionsDir, sessionId2);
+    const sessionDir = join25(this.sessionsDir, sessionId2);
     mkdirSync11(sessionDir, { recursive: true });
     if (opts.prompt) {
-      writeFileSync10(join24(sessionDir, "prompt.md"), opts.prompt, "utf-8");
+      writeFileSync10(join25(sessionDir, "prompt.md"), opts.prompt, "utf-8");
     }
     const args = [
       "--model",
@@ -43170,7 +44166,7 @@ class SessionManager {
         });
       }
     });
-    const outputLogStream = createWriteStream(join24(sessionDir, "output.log"));
+    const outputLogStream = createWriteStream(join25(sessionDir, "output.log"));
     const entry = {
       info: {
         sessionId: sessionId2,
@@ -43217,9 +44213,9 @@ class SessionManager {
       watcher.processExited(code);
       outputLogStream.end();
       if (entry.stderr) {
-        writeFileSync10(join24(sessionDir, "stderr.log"), entry.stderr, "utf-8");
+        writeFileSync10(join25(sessionDir, "stderr.log"), entry.stderr, "utf-8");
       }
-      writeFileSync10(join24(sessionDir, "meta.json"), JSON.stringify(entry.info, null, 2), "utf-8");
+      writeFileSync10(join25(sessionDir, "meta.json"), JSON.stringify(entry.info, null, 2), "utf-8");
       this.cleanupSigint();
     });
     proc.on("error", (err) => {
@@ -45295,8 +46291,8 @@ var init_openrouter_api_format = __esm(() => {
     convertMessages(claudeRequest, filterIdentityFn) {
       const messages = super.convertMessages(claudeRequest, filterIdentityFn);
       if (this.modelId.includes("grok") || this.modelId.includes("x-ai")) {
-        const msg = "IMPORTANT: When calling tools, you MUST use the OpenAI tool_calls format with JSON. NEVER use XML format like <xai:function_call>.";
-        this.appendToSystemPrompt(messages, msg);
+        const msg2 = "IMPORTANT: When calling tools, you MUST use the OpenAI tool_calls format with JSON. NEVER use XML format like <xai:function_call>.";
+        this.appendToSystemPrompt(messages, msg2);
       }
       if (this.modelId.includes("gemini") || this.modelId.includes("google/")) {
         const geminiMsg = `CRITICAL INSTRUCTION FOR OUTPUT FORMAT:
@@ -45616,12 +46612,12 @@ function rewriteAdvisorToolResults(payload, getAdviceFor) {
   if (!Array.isArray(messages))
     return [];
   const rewritten = [];
-  for (const msg of messages) {
-    if (!msg || typeof msg !== "object")
+  for (const msg2 of messages) {
+    if (!msg2 || typeof msg2 !== "object")
       continue;
-    if (msg.role !== "user")
+    if (msg2.role !== "user")
       continue;
-    const content = msg.content;
+    const content = msg2.content;
     if (!Array.isArray(content))
       continue;
     for (const block of content) {
@@ -45651,12 +46647,12 @@ function findPendingAdvisorToolResults(payload) {
   if (!Array.isArray(messages))
     return [];
   const found = [];
-  for (const msg of messages) {
-    if (!msg || typeof msg !== "object")
+  for (const msg2 of messages) {
+    if (!msg2 || typeof msg2 !== "object")
       continue;
-    if (msg.role !== "user")
+    if (msg2.role !== "user")
       continue;
-    const content = msg.content;
+    const content = msg2.content;
     if (!Array.isArray(content))
       continue;
     for (const block of content) {
@@ -46161,6 +47157,270 @@ var init_api_key_map = __esm(() => {
   };
 });
 
+// src/providers/devin/tool-descriptions.ts
+function currentMonthAndYear(now = new Date) {
+  return `${MONTHS[now.getMonth()]} ${now.getFullYear()}`;
+}
+function buildWebSearchDescription(monthAndYear) {
+  return `Runs a web search and lets you fold the results into your answer.
+
+- Reaches live sources, so it covers current events and material recent enough to post-date your
+  training data. This is the tool for any question that runs past your knowledge cutoff.
+- Results arrive as search-result blocks; links inside them are already written as markdown
+  hyperlinks.
+- The entire search happens within a single API call \u2014 there is nothing extra to orchestrate.
+
+NON-NEGOTIABLE OUTPUT REQUIREMENT \u2014 this is MANDATORY, and you must never skip it:
+  - Once you have answered the user's question, the very end of your response MUST carry a section
+    headed \`Sources:\`.
+  - Beneath that heading, list every URL from the search results that is relevant to the answer,
+    each written as a markdown hyperlink in the form [Title](URL).
+  - Leaving the sources section out is not an option, however short or obvious the answer looks.
+  - Shape of the finished response:
+
+    [your answer goes here]
+
+    Sources:
+    - [First page title](https://first.example/page)
+    - [Second page title](https://second.example/page)
+
+Other things worth knowing:
+  - Results can be confined by domain: \`allowed_domains\` restricts the search to specific sites,
+    \`blocked_domains\` keeps named sites out.
+  - Web search is served only within the United States.
+
+Dates in queries \u2014 get the year right:
+  - The present month is ${monthAndYear}. Any query about recent material, current documentation or
+    ongoing events MUST be qualified with that year.
+  - For example, asked for "latest React docs", search for React documentation carrying the current
+    year, not the one before it.`;
+}
+function buildDevinToolDescriptions(now = new Date) {
+  return new Map([
+    ["Read", READ_DESCRIPTION],
+    ["TaskOutput", TASK_OUTPUT_DESCRIPTION],
+    ["WebSearch", buildWebSearchDescription(currentMonthAndYear(now))]
+  ]);
+}
+function toolName(tool) {
+  if (!tool || typeof tool !== "object")
+    return;
+  const record4 = tool;
+  const nested = record4.function?.name;
+  if (typeof nested === "string")
+    return nested;
+  return typeof record4.name === "string" ? record4.name : undefined;
+}
+function applyDevinToolDescriptions(tools, descriptions = DEVIN_TOOL_DESCRIPTIONS) {
+  return tools.map((tool) => {
+    const name = toolName(tool);
+    const replacement = name === undefined ? undefined : descriptions.get(name);
+    if (replacement === undefined)
+      return tool;
+    const record4 = tool;
+    if (record4.function && typeof record4.function === "object") {
+      return {
+        ...record4,
+        function: { ...record4.function, description: replacement }
+      };
+    }
+    return { ...record4, description: replacement };
+  });
+}
+var MONTHS, READ_DESCRIPTION = `Retrieves the contents of a single file from the machine's local disk.
+
+Nothing on the host is out of bounds \u2014 assume you can open whatever you need. When the user hands
+you a path, take it at face value and try it; aiming at a file that turns out not to exist is
+harmless, the call simply comes back as an error.
+
+Calling conventions:
+- \`file_path\` has to be a fully-qualified absolute path. A relative path will not be accepted.
+- Left unbounded, the call hands back at most the first 2000 lines, counted from the top of the file.
+- If you already know which region of the file matters, ask for that region alone. On large files
+  this is the difference between a cheap call and an expensive one.
+- Output is formatted the way \`cat -n\` formats it: each line prefixed with its number, and the
+  numbering begins at 1.
+- Image files work (PNG, JPG and the rest). The picture itself is handed over for you to look at,
+  since the model behind this session takes visual input as well as text.
+- PDF documents work. Once a document runs past ten pages the \`pages\` argument becomes REQUIRED \u2014
+  give it the span you want, for instance \`pages: "1-5"\`. Leaving \`pages\` off a long PDF makes the
+  call fail outright. One request may cover twenty pages at most.
+- Jupyter notebooks (\`.ipynb\`) come back fully expanded: every cell together with the output that
+  cell produced, so source, prose and rendered figures all arrive in one piece.
+- Files only, never directories. To find out what a folder holds, reach for the shell tool
+  registered for this session.
+- Screenshots are a routine case. Whenever a path to a screenshot is supplied, view it through this
+  tool rather than by any other route; paths inside temporary directories are fine.
+- Opening a file that exists but holds nothing gives you a system-reminder notice standing in for
+  the file body.
+- Do not re-open a file just to confirm an edit you have already made. Had that Edit or Write
+  failed it would have raised an error at the time, and the harness keeps track of each file's
+  current state on your behalf.`, TASK_OUTPUT_DESCRIPTION = `DEPRECATED \u2014 in almost every case reach for Read instead.
+
+The reason it is deprecated: a task launched in the background already reports the path of its
+output file as part of the tool result, and a <task-notification> quoting that same path arrives
+once the task finishes. The path is in front of you either way, so routing back through this tool
+buys nothing.
+
+Which route to take, by task kind:
+- bash tasks \u2014 open the reported output path with Read. Both stdout and stderr are captured there.
+- local_agent tasks \u2014 take the answer straight from what the Agent tool returned. NEVER open the
+  \`.output\` file with Read. That entry is a symlink pointing at the subagent's ENTIRE conversation
+  transcript in JSONL form, and pulling it in WILL overflow your context window.
+- remote_agent tasks \u2014 open the reported output path with Read, exactly as for bash; it holds the
+  remote session's streamed output.
+
+If you call it anyway, this is what it does:
+- Fetches the output of a task that is either still running or already finished \u2014 a backgrounded
+  shell, an agent, or a remote session.
+- Identifies which task through the \`task_id\` parameter.
+- Replies with the task's output alongside its status.
+- \`block=true\` is the default and makes the call wait until the task has completed.
+- \`block=false\` returns straight away with whatever the status is at that moment.
+- The \`/tasks\` command lists the ids you can pass.
+- Every task flavour is supported: backgrounded shells, asynchronous agents, and remote sessions.`, DEVIN_TOOL_DESCRIPTIONS;
+var init_tool_descriptions = __esm(() => {
+  MONTHS = [
+    "January",
+    "February",
+    "March",
+    "April",
+    "May",
+    "June",
+    "July",
+    "August",
+    "September",
+    "October",
+    "November",
+    "December"
+  ];
+  DEVIN_TOOL_DESCRIPTIONS = buildDevinToolDescriptions();
+});
+
+// src/adapters/devin-api-format.ts
+function contentToText(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  const parts = [];
+  for (const part of content) {
+    if (typeof part === "string") {
+      parts.push(part);
+      continue;
+    }
+    if (part && typeof part === "object" && "text" in part) {
+      const { text } = part;
+      if (typeof text === "string")
+        parts.push(text);
+    }
+  }
+  return parts.join(`
+`);
+}
+var DEVIN_RELOCATION_NOTE, DEVIN_MINIMAL_SYSTEM = "You are a coding agent.", DevinAPIFormat;
+var init_devin_api_format = __esm(() => {
+  init_tool_descriptions();
+  init_base_api_format();
+  DEVIN_RELOCATION_NOTE = "You are a coding agent. Your complete operating instructions for this session are supplied " + "in the first user message, inside <system_instructions> tags. Treat everything inside those " + "tags as your system prompt and follow it exactly.";
+  DevinAPIFormat = class DevinAPIFormat extends BaseAPIFormat {
+    processTextContent(textContent, _accumulatedText) {
+      return {
+        cleanedText: textContent,
+        extractedToolCalls: [],
+        wasTransformed: false
+      };
+    }
+    shouldHandle(_modelId) {
+      return false;
+    }
+    getName() {
+      return "DevinAPIFormat";
+    }
+    getStreamFormat() {
+      return "connect-proto";
+    }
+    getContextWindow() {
+      return 0;
+    }
+    supportsVision() {
+      return false;
+    }
+    applyNativeReasoning(request, originalRequest) {
+      const effort = this.resolveEffortLevel(originalRequest);
+      if (effort)
+        request.effort = effort;
+      return request;
+    }
+    buildPayload(_claudeRequest, messages, tools) {
+      const systemParts = [];
+      const devinMessages = [];
+      for (const message of messages) {
+        const role = message?.role;
+        if (role === "system") {
+          const text = contentToText(message.content);
+          if (text)
+            systemParts.push(text);
+          continue;
+        }
+        if (role === "tool") {
+          devinMessages.push({
+            role: "tool_result",
+            text: contentToText(message.content),
+            toolCallId: message.tool_call_id
+          });
+          continue;
+        }
+        if (role === "assistant") {
+          const text = contentToText(message.content);
+          if (text)
+            devinMessages.push({ role: "assistant", text });
+          for (const call of message.tool_calls ?? []) {
+            devinMessages.push({
+              role: "assistant",
+              toolCall: {
+                id: call?.id ?? "",
+                name: call?.function?.name ?? "",
+                argumentsJson: call?.function?.arguments || "{}"
+              }
+            });
+          }
+          continue;
+        }
+        devinMessages.push({ role: "user", text: contentToText(message.content) });
+      }
+      const devinTools = applyDevinToolDescriptions(tools).map((tool) => ({
+        name: tool?.function?.name ?? tool?.name ?? "",
+        description: tool?.function?.description ?? tool?.description ?? "",
+        parametersJson: JSON.stringify(tool?.function?.parameters ?? tool?.parameters ?? { type: "object", properties: {} })
+      }));
+      let system;
+      if (systemParts.length > 0) {
+        devinMessages.unshift({
+          role: "user",
+          text: `<system_instructions>
+${systemParts.join(`
+
+`)}
+</system_instructions>`
+        });
+        system = DEVIN_RELOCATION_NOTE;
+      } else if (devinTools.length > 0) {
+        system = DEVIN_MINIMAL_SYSTEM;
+      }
+      const payload = {
+        modelUid: this.modelId,
+        messages: devinMessages
+      };
+      if (system)
+        payload.system = system;
+      if (devinTools.length > 0)
+        payload.tools = devinTools;
+      return payload;
+    }
+  };
+});
+
 // src/adapters/ollama-api-format.ts
 var OllamaAPIFormat;
 var init_ollama_api_format = __esm(() => {
@@ -46188,11 +47448,11 @@ var init_ollama_api_format = __esm(() => {
         messages.push({ role: "system", content });
       }
       if (claudeRequest.messages) {
-        for (const msg of claudeRequest.messages) {
-          if (msg.role === "user") {
-            messages.push(this.processUserMessage(msg));
-          } else if (msg.role === "assistant") {
-            messages.push(this.processAssistantMessage(msg));
+        for (const msg2 of claudeRequest.messages) {
+          if (msg2.role === "user") {
+            messages.push(this.processUserMessage(msg2));
+          } else if (msg2.role === "assistant") {
+            messages.push(this.processAssistantMessage(msg2));
           }
         }
       }
@@ -46217,10 +47477,10 @@ var init_ollama_api_format = __esm(() => {
     supportsVision() {
       return false;
     }
-    processUserMessage(msg) {
-      if (Array.isArray(msg.content)) {
+    processUserMessage(msg2) {
+      if (Array.isArray(msg2.content)) {
         const textParts = [];
-        for (const block of msg.content) {
+        for (const block of msg2.content) {
           if (block.type === "text") {
             textParts.push(block.text);
           } else if (block.type === "tool_result") {
@@ -46232,12 +47492,12 @@ var init_ollama_api_format = __esm(() => {
 
 `) };
       }
-      return { role: "user", content: msg.content };
+      return { role: "user", content: msg2.content };
     }
-    processAssistantMessage(msg) {
-      if (Array.isArray(msg.content)) {
+    processAssistantMessage(msg2) {
+      if (Array.isArray(msg2.content)) {
         const strings = [];
-        for (const block of msg.content) {
+        for (const block of msg2.content) {
           if (block.type === "text") {
             strings.push(block.text);
           } else if (block.type === "tool_use") {
@@ -46247,17 +47507,17 @@ var init_ollama_api_format = __esm(() => {
         return { role: "assistant", content: strings.join(`
 `) };
       }
-      return { role: "assistant", content: msg.content };
+      return { role: "assistant", content: msg2.content };
     }
   };
 });
 
 // src/providers/api-key-provenance.ts
-import { existsSync as existsSync17, readFileSync as readFileSync15 } from "fs";
-import { homedir as homedir25 } from "os";
-import { join as join25, resolve as resolve2 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync16 } from "fs";
+import { homedir as homedir26 } from "os";
+import { join as join26, resolve as resolve2 } from "path";
 function activeConfigPath() {
-  return activeGlobalConfigFile(join25(homedir25(), ".claudish", "config.json"));
+  return activeGlobalConfigFile(join26(homedir26(), ".claudish", "config.json"));
 }
 function configLayerLabel() {
   return getConfigFileOverride() ? activeConfigPath() : "~/.claudish/config.json";
@@ -46336,7 +47596,7 @@ function readDotenvKey(envVars) {
     const dotenvPath = resolve2(".env");
     if (!existsSync17(dotenvPath))
       return null;
-    const parsed = import_dotenv.parse(readFileSync15(dotenvPath, "utf-8"));
+    const parsed = import_dotenv.parse(readFileSync16(dotenvPath, "utf-8"));
     for (const v of envVars) {
       if (parsed[v])
         return parsed[v];
@@ -46351,7 +47611,7 @@ function readConfigKey(envVar) {
     const configPath = activeConfigPath();
     if (!existsSync17(configPath))
       return null;
-    const cfg = JSON.parse(readFileSync15(configPath, "utf-8"));
+    const cfg = JSON.parse(readFileSync16(configPath, "utf-8"));
     return cfg.apiKeys?.[envVar] || null;
   } catch {
     return null;
@@ -46363,6 +47623,161 @@ var init_api_key_provenance = __esm(() => {
   import_dotenv = __toESM(require_main(), 1);
 });
 
+// src/providers/devin/model-id-resolver.ts
+function parseDevinUidTier(uid) {
+  let base = uid.trim();
+  let fast = false;
+  if (base.toLowerCase().endsWith(FAST_SUFFIX)) {
+    fast = true;
+    base = base.slice(0, -FAST_SUFFIX.length);
+  }
+  const match2 = base.match(TIER_SUFFIX_RE);
+  const candidate = match2?.[1]?.toLowerCase();
+  return { tier: isEffortLevel(candidate) ? candidate : null, fast };
+}
+function effortIndex(level) {
+  return EFFORT_LEVELS.indexOf(level);
+}
+function resolveDevinModelUid(requested, effort, served) {
+  const req = requested.trim();
+  if (!req || served.length === 0)
+    return req || requested;
+  const lower = req.toLowerCase();
+  const exact = served.find((model) => model.uid.toLowerCase() === lower);
+  if (exact)
+    return exact.uid;
+  const prefix = `${lower}-`;
+  const candidates = served.filter((model) => model.family.toLowerCase() === lower || model.uid.toLowerCase().startsWith(prefix));
+  if (candidates.length === 0)
+    return req;
+  const nonFast = candidates.filter((model) => !parseDevinUidTier(model.uid).fast);
+  const pool = nonFast.length > 0 ? nonFast : candidates;
+  if (pool.length === 1)
+    return pool[0].uid;
+  const tiered = pool.map((model) => ({ model, tier: parseDevinUidTier(model.uid).tier })).filter((entry) => entry.tier !== null);
+  if (tiered.length === 0)
+    return pool[0].uid;
+  const target = effort ? effortIndex(effort) : EFFORT_LEVELS.length - 1;
+  let best = tiered[0];
+  let bestDistance = Number.POSITIVE_INFINITY;
+  for (const entry of tiered) {
+    const distance = Math.abs(effortIndex(entry.tier) - target);
+    if (distance < bestDistance || distance === bestDistance && effortIndex(entry.tier) > effortIndex(best.tier)) {
+      best = entry;
+      bestDistance = distance;
+    }
+  }
+  return best.model.uid;
+}
+var FAST_SUFFIX = "-fast", TIER_SUFFIX_RE;
+var init_model_id_resolver = __esm(() => {
+  init_base_api_format();
+  TIER_SUFFIX_RE = new RegExp(`-(${[...EFFORT_LEVELS].sort((a, b) => b.length - a.length).join("|")})$`, "i");
+});
+
+// src/providers/transport/devin.ts
+class DevinProviderTransport {
+  name = "devin";
+  displayName = "Devin";
+  streamFormat = "connect-proto";
+  modelName;
+  cachedAuth = null;
+  served = [];
+  resolvedUid;
+  constructor(modelName) {
+    this.modelName = modelName;
+    this.resolvedUid = modelName;
+  }
+  getEndpoint() {
+    return `${readDevinServerUrl()}${CHAT_PATH}`;
+  }
+  async getHeaders() {
+    if (this.cachedAuth)
+      return { ...this.cachedAuth.headers };
+    const apiKey = readDevinApiKey();
+    return apiKey ? devinAuthHeaders(apiKey) : {};
+  }
+  async refreshAuth() {
+    this.cachedAuth = await credentials.getRequestAuth("devin", { model: this.modelName });
+    this.served = await getServedDevinModels();
+    log(`[Devin] auth refreshed, model: ${this.modelName}, served roster: ${this.served.length} models`);
+  }
+  serializeBody(payload) {
+    const apiKey = readDevinApiKey();
+    if (!apiKey) {
+      const err = new Error("No Devin credential available when encoding the request.");
+      err.terminal = true;
+      throw err;
+    }
+    const request = payload;
+    this.resolvedUid = resolveDevinModelUid(request.modelUid || this.modelName, request.effort, this.served);
+    const resolved = { ...request, modelUid: this.resolvedUid };
+    if (this.resolvedUid !== this.modelName) {
+      log(`[Devin] model resolved: ${this.modelName} -> ${this.resolvedUid}`);
+    }
+    log(`[Devin] request ${describeDevinRequestForLog(resolved)}`);
+    return {
+      body: encodeDevinRequest(resolved, { apiKey }),
+      contentType: CHAT_CONTENT_TYPE
+    };
+  }
+  getContextWindow() {
+    if (this.served.length === 0)
+      return 0;
+    const uid = resolveDevinModelUid(this.modelName, undefined, this.served);
+    return this.served.find((model) => model.uid === uid)?.contextWindow ?? 0;
+  }
+  getActiveModelName() {
+    return this.resolvedUid !== this.modelName ? this.resolvedUid : undefined;
+  }
+  async discoverProbeModel(exclude) {
+    if (!readDevinApiKey()) {
+      return {
+        model: null,
+        reason: "no Devin credential \u2014 sign in with the Devin CLI (`devin login`), or set WINDSURF_API_KEY"
+      };
+    }
+    const served = await getServedDevinModels();
+    if (served.length === 0) {
+      return { model: null, reason: "Devin reported no models for this subscription" };
+    }
+    const ranked = [...served].sort((a, b) => {
+      const diff = b.contextWindow - a.contextWindow;
+      return diff !== 0 ? diff : a.uid.localeCompare(b.uid);
+    });
+    const candidate = ranked.find((model) => !exclude?.has(model.uid));
+    if (!candidate) {
+      return { model: null, reason: "every Devin model was already tried in this probe round" };
+    }
+    return { model: candidate.uid };
+  }
+  rewriteInStreamError(_code, message) {
+    if (this.served.length === 0)
+      return message;
+    if (this.served.some((model) => model.uid === this.resolvedUid))
+      return message;
+    const families = [...new Set(this.served.map((model) => model.family).filter(Boolean))].sort();
+    const stem = this.resolvedUid.split("-")[0]?.toLowerCase() ?? "";
+    const related = families.filter((f) => f.toLowerCase().startsWith(stem));
+    const ordered = [...related, ...families.filter((f) => !related.includes(f))];
+    const SHOWN = 12;
+    const shown = ordered.slice(0, SHOWN);
+    const more = ordered.length - shown.length;
+    const familyClause = shown.length > 0 ? ` Available families: ${shown.join(", ")}${more > 0 ? `, +${more} more` : ""}.` : "";
+    return `\`${this.resolvedUid}\` is not served by your Devin subscription.${familyClause} ` + "Run `claudish models dv@` to list the uids this subscription can call. " + `(Upstream said: ${message})`;
+  }
+}
+var CHAT_PATH = "/exa.api_server_pb.ApiServerService/GetChatMessage", CHAT_CONTENT_TYPE = "application/connect+proto";
+var init_devin = __esm(() => {
+  init_authority();
+  init_devin_credential();
+  init_logger();
+  init_devin_credentials();
+  init_devin_models();
+  init_devin_request();
+  init_model_id_resolver();
+});
+
 // src/providers/transport/gemini-apikey.ts
 class GeminiProviderTransport {
   name = "gemini";
@@ -46395,7 +47810,7 @@ var init_gemini_apikey = __esm(() => {
 });
 
 // src/providers/transport/gemini-codeassist.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 function createActivityRequestId4() {
   return Math.random().toString(36).substring(7);
 }
@@ -46504,21 +47919,21 @@ class GeminiCodeAssistProviderTransport {
     log(`[GeminiCodeAssist] Auth refreshed, project: ${this.projectId}, tier: ${this._displayName}, served: ${this.servedModels.join(",") || "(none)"}`);
   }
   transformPayload(payload) {
-    const envelope = this.cachedAuth?.transformPayload ? this.cachedAuth.transformPayload(payload) : this.buildEnvelope(payload, this.modelName);
-    this.lastEnvelope = envelope;
-    return envelope;
+    const envelope2 = this.cachedAuth?.transformPayload ? this.cachedAuth.transformPayload(payload) : this.buildEnvelope(payload, this.modelName);
+    this.lastEnvelope = envelope2;
+    return envelope2;
   }
   buildEnvelope(innerPayload, model) {
-    const envelope = {
+    const envelope2 = {
       model,
       project: this.projectId,
-      user_prompt_id: randomUUID5(),
+      user_prompt_id: randomUUID6(),
       request: innerPayload
     };
     if (this.tierId && this.tierId !== "free-tier") {
-      envelope.enabled_credit_types = ["GOOGLE_ONE_AI"];
+      envelope2.enabled_credit_types = ["GOOGLE_ONE_AI"];
     }
-    return envelope;
+    return envelope2;
   }
   async enqueueRequest(fetchFn) {
     const queue = GeminiRequestQueue.getInstance();
@@ -46845,11 +48260,12 @@ function createHandlerForProvider(ctx) {
   log(`[Proxy] Handler: provider=${ctx.provider.name}, model=${ctx.modelName}`);
   return profile.createHandler(ctx);
 }
-var geminiProfile, geminiCodeAssistProfile, antigravityProfile, openaiProfile, openaiCodexProfile, anthropicCompatProfile, glmProfile, openCodeZenProfile, ollamaCloudProfile, litellmProfile, vertexProfile, PROVIDER_PROFILES;
+var geminiProfile, geminiCodeAssistProfile, antigravityProfile, devinProfile, openaiProfile, openaiCodexProfile, anthropicCompatProfile, glmProfile, openCodeZenProfile, ollamaCloudProfile, litellmProfile, vertexProfile, PROVIDER_PROFILES;
 var init_provider_profiles = __esm(() => {
   init_anthropic_api_format();
   init_base_api_format();
   init_codex_api_format();
+  init_devin_api_format();
   init_gemini_api_format();
   init_litellm_api_format();
   init_ollama_api_format();
@@ -46862,6 +48278,7 @@ var init_provider_profiles = __esm(() => {
   init_runtime_providers();
   init_anthropic_compat();
   init_antigravity();
+  init_devin();
   init_gemini_apikey();
   init_gemini_codeassist();
   init_litellm();
@@ -46907,6 +48324,19 @@ var init_provider_profiles = __esm(() => {
       return handler;
     }
   };
+  devinProfile = {
+    createHandler(ctx) {
+      const transport = new DevinProviderTransport(ctx.modelName);
+      const adapter = new DevinAPIFormat(ctx.modelName);
+      const handler = new ComposedHandler(transport, ctx.targetModel, ctx.modelName, ctx.port, {
+        adapter,
+        forceForeignModel: true,
+        ...ctx.sharedOpts
+      });
+      log(`[Proxy] Created Devin handler (composed): ${ctx.modelName}`);
+      return handler;
+    }
+  };
   openaiProfile = {
     createHandler(ctx) {
       if (requiresResponsesApi(ctx.modelName)) {
@@ -47087,6 +48517,7 @@ var init_provider_profiles = __esm(() => {
     gemini: geminiProfile,
     "gemini-codeassist": geminiCodeAssistProfile,
     antigravity: antigravityProfile,
+    devin: devinProfile,
     openai: openaiProfile,
     "openai-codex": openaiCodexProfile,
     "x-ai": openaiProfile,
@@ -47825,9 +49256,9 @@ var init_poe = __esm(() => {
 });
 
 // src/services/pricing-cache.ts
-import { existsSync as existsSync18, readFileSync as readFileSync16, statSync as statSync4 } from "fs";
-import { homedir as homedir26 } from "os";
-import { join as join26 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync17, statSync as statSync4 } from "fs";
+import { homedir as homedir27 } from "os";
+import { join as join27 } from "path";
 function prefixMatch(modelName) {
   for (const [key, pricing] of pricingMap) {
     if (modelName.startsWith(key))
@@ -47870,7 +49301,7 @@ function loadDiskCache() {
     const stat2 = statSync4(CACHE_FILE);
     const age = Date.now() - stat2.mtimeMs;
     const isFresh = age < CACHE_TTL_MS3;
-    const raw2 = readFileSync16(CACHE_FILE, "utf-8");
+    const raw2 = readFileSync17(CACHE_FILE, "utf-8");
     const data = JSON.parse(raw2);
     for (const [key, pricing] of Object.entries(data)) {
       pricingMap.set(key, pricing);
@@ -47886,8 +49317,8 @@ var init_pricing_cache = __esm(() => {
   init_logger();
   init_catalog_query();
   pricingMap = new Map;
-  CACHE_DIR = join26(homedir26(), ".claudish");
-  CACHE_FILE = join26(CACHE_DIR, "pricing-cache.json");
+  CACHE_DIR = join27(homedir27(), ".claudish");
+  CACHE_FILE = join27(CACHE_DIR, "pricing-cache.json");
   CACHE_TTL_MS3 = 24 * 60 * 60 * 1000;
 });
 
@@ -48382,20 +49813,20 @@ var init_redact = __esm(() => {
 });
 
 // src/team-stats.ts
-import { existsSync as existsSync19, readFileSync as readFileSync17, writeFileSync as writeFileSync11 } from "fs";
-import { join as join27 } from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync18, writeFileSync as writeFileSync11 } from "fs";
+import { join as join28 } from "path";
 function statsDir(sessionPath) {
-  return join27(sessionPath, "stats");
+  return join28(sessionPath, "stats");
 }
 function tokenFileFor(sessionPath, anonId) {
-  return join27(statsDir(sessionPath), `${anonId}.json`);
+  return join28(statsDir(sessionPath), `${anonId}.json`);
 }
 function readTokenStats(sessionPath, anonId) {
   const path = tokenFileFor(sessionPath, anonId);
   if (!existsSync19(path))
     return null;
   try {
-    return JSON.parse(readFileSync17(path, "utf-8"));
+    return JSON.parse(readFileSync18(path, "utf-8"));
   } catch {
     return null;
   }
@@ -48472,10 +49903,10 @@ function renderTeamStats(sessionPath, manifest, status, opts) {
     if (stats?.is_free)
       anyFree = true;
     const name = model.length > nameWidth ? `${model.slice(0, nameWidth - 1)}\u2026` : model;
-    const bytes = m.outputSize > 0 ? fmtBytes(m.outputSize) : "";
+    const bytes2 = m.outputSize > 0 ? fmtBytes(m.outputSize) : "";
     const tokens = stats ? `${fmtTokens(inTok)}/${outTok > 0 ? fmtTokens(outTok) : "-"}` : "";
     const cost = stats ? fmtCost(stats.total_cost, stats.is_free) : "";
-    rows.push(`  ${id} ${name.padEnd(nameWidth)} ${fmtState(m.state)} ` + `${bytes.padStart(7)} ${tokens.padStart(12)} ${cost.padStart(7)}`.trimEnd());
+    rows.push(`  ${id} ${name.padEnd(nameWidth)} ${fmtState(m.state)} ` + `${bytes2.padStart(7)} ${tokens.padStart(12)} ${cost.padStart(7)}`.trimEnd());
   }
   const parts = [`${ids.length} models`];
   if (done)
@@ -48543,7 +49974,7 @@ ${segs.join(" \xB7 ")}`;
 }
 function writeStatusFile(sessionPath, manifest, status, opts) {
   try {
-    writeFileSync11(join27(sessionPath, "status.txt"), `${renderTeamStats(sessionPath, manifest, status, opts)}
+    writeFileSync11(join28(sessionPath, "status.txt"), `${renderTeamStats(sessionPath, manifest, status, opts)}
 `, "utf-8");
   } catch {}
 }
@@ -48571,11 +50002,11 @@ import {
   createWriteStream as createWriteStream2,
   existsSync as existsSync20,
   mkdirSync as mkdirSync12,
-  readFileSync as readFileSync18,
+  readFileSync as readFileSync19,
   readdirSync as readdirSync3,
   writeFileSync as writeFileSync12
 } from "fs";
-import { join as join28, resolve as resolve3 } from "path";
+import { join as join29, resolve as resolve3 } from "path";
 function classifyRunOutput(opts) {
   const { outputSize, stdoutTail, stderr, minOutputBytes } = opts;
   const apiError = API_ERROR_RE.exec(stdoutTail);
@@ -48636,18 +50067,18 @@ function setupSession(sessionPath, models, input) {
   if (models.length === 0) {
     throw new Error("At least one model is required");
   }
-  if (existsSync20(join28(sessionPath, "manifest.json"))) {
+  if (existsSync20(join29(sessionPath, "manifest.json"))) {
     throw new Error(`Session already exists at ${sessionPath}. Use a new directory path or delete the existing session first.`);
   }
   const sentinels = models.filter(isSentinelModel);
   if (sentinels.length > 0) {
     throw new Error(`Invalid model(s) for team run: ${sentinels.join(", ")}. These are Claude Code agent selectors, not external model IDs. Use real external models (e.g., "gemini-2.0-flash", "gpt-4o", "or@deepseek/deepseek-r1"). For Claude models, use a Task agent instead of the team tool.`);
   }
-  mkdirSync12(join28(sessionPath, "work"), { recursive: true });
-  mkdirSync12(join28(sessionPath, "errors"), { recursive: true });
+  mkdirSync12(join29(sessionPath, "work"), { recursive: true });
+  mkdirSync12(join29(sessionPath, "errors"), { recursive: true });
   if (input !== undefined) {
-    writeFileSync12(join28(sessionPath, "input.md"), input, "utf-8");
-  } else if (!existsSync20(join28(sessionPath, "input.md"))) {
+    writeFileSync12(join29(sessionPath, "input.md"), input, "utf-8");
+  } else if (!existsSync20(join29(sessionPath, "input.md"))) {
     throw new Error(`No input.md found at ${sessionPath} and no input provided`);
   }
   const ids = models.map((_, i) => String(i + 1).padStart(2, "0"));
@@ -48664,9 +50095,9 @@ function setupSession(sessionPath, models, input) {
       model: models[i],
       assignedAt: now
     };
-    mkdirSync12(join28(sessionPath, "work", anonId), { recursive: true });
+    mkdirSync12(join29(sessionPath, "work", anonId), { recursive: true });
   }
-  writeFileSync12(join28(sessionPath, "manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
+  writeFileSync12(join29(sessionPath, "manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
   const status = {
     startedAt: now,
     models: Object.fromEntries(Object.keys(manifest.models).map((id) => [
@@ -48680,17 +50111,17 @@ function setupSession(sessionPath, models, input) {
       }
     ]))
   };
-  writeFileSync12(join28(sessionPath, "status.json"), JSON.stringify(status, null, 2), "utf-8");
+  writeFileSync12(join29(sessionPath, "status.json"), JSON.stringify(status, null, 2), "utf-8");
   return manifest;
 }
 async function runModels(sessionPath, opts = {}) {
   const timeoutMs = (opts.timeout ?? 300) * 1000;
-  const manifest = JSON.parse(readFileSync18(join28(sessionPath, "manifest.json"), "utf-8"));
-  const statusPath = join28(sessionPath, "status.json");
-  const inputPath = join28(sessionPath, "input.md");
-  const inputContent = readFileSync18(inputPath, "utf-8");
+  const manifest = JSON.parse(readFileSync19(join29(sessionPath, "manifest.json"), "utf-8"));
+  const statusPath = join29(sessionPath, "status.json");
+  const inputPath = join29(sessionPath, "input.md");
+  const inputContent = readFileSync19(inputPath, "utf-8");
   const spawnPlan = await (opts.spawnPlanner ?? prehydrateCredentialsForSpawn)(Object.values(manifest.models).map((m) => m.model));
-  const statusCache = JSON.parse(readFileSync18(statusPath, "utf-8"));
+  const statusCache = JSON.parse(readFileSync19(statusPath, "utf-8"));
   function updateModelStatus(id, update) {
     statusCache.models[id] = { ...statusCache.models[id], ...update };
     writeFileSync12(statusPath, JSON.stringify(statusCache, null, 2), "utf-8");
@@ -48709,8 +50140,8 @@ async function runModels(sessionPath, opts = {}) {
   process.on("SIGINT", sigintHandler);
   const completionPromises = [];
   for (const [anonId, entry] of Object.entries(manifest.models)) {
-    const outputPath = join28(sessionPath, `response-${anonId}.md`);
-    const errorLogPath = join28(sessionPath, "errors", `${anonId}.log`);
+    const outputPath = join29(sessionPath, `response-${anonId}.md`);
+    const errorLogPath = join29(sessionPath, "errors", `${anonId}.log`);
     const spawnModel = spawnPlan.pinned.get(entry.model) ?? entry.model;
     const args = ["--model", spawnModel, "-y", "--stdin", "--quiet", ...opts.claudeFlags ?? []];
     updateModelStatus(anonId, {
@@ -48859,14 +50290,14 @@ async function runModels(sessionPath, opts = {}) {
             const rt = runtimes.get(id);
             const stderr = rt?.getStderr() ?? "";
             const stdoutTail = rt?.getStdoutTail() ?? "";
-            const bytes = rt?.getByteCount() ?? 0;
-            const detail = `Killed by the orchestrator after ${timeoutMs / 1000}s with ${bytes} B of stdout. ` + "In --quiet print mode the child emits its answer only at the end, so 0 B means " + `"did not finish", not "produced nothing".`;
+            const bytes2 = rt?.getByteCount() ?? 0;
+            const detail = `Killed by the orchestrator after ${timeoutMs / 1000}s with ${bytes2} B of stdout. ` + "In --quiet print mode the child emits its answer only at the end, so 0 B means " + `"did not finish", not "produced nothing".`;
             if (rt)
               persistErrorLog(rt.errorLogPath, `TIMEOUT: ${detail}`, stderr, stdoutTail);
             updateModelStatus(id, {
               state: "TIMEOUT",
               completedAt: new Date().toISOString(),
-              outputSize: bytes,
+              outputSize: bytes2,
               error: rt ? {
                 model: id,
                 command: rt.command,
@@ -48900,23 +50331,23 @@ async function judgeResponses(sessionPath, opts = {}) {
   const responses = {};
   for (const file2 of responseFiles) {
     const id = file2.replace(/^response-/, "").replace(/\.md$/, "");
-    responses[id] = readFileSync18(join28(sessionPath, file2), "utf-8");
+    responses[id] = readFileSync19(join29(sessionPath, file2), "utf-8");
   }
-  const input = readFileSync18(join28(sessionPath, "input.md"), "utf-8");
+  const input = readFileSync19(join29(sessionPath, "input.md"), "utf-8");
   const judgePrompt = buildJudgePrompt(input, responses);
-  writeFileSync12(join28(sessionPath, "judge-prompt.md"), judgePrompt, "utf-8");
+  writeFileSync12(join29(sessionPath, "judge-prompt.md"), judgePrompt, "utf-8");
   const judgeModels = opts.judges ?? getDefaultJudgeModels(sessionPath);
-  const judgePath = join28(sessionPath, "judging");
+  const judgePath = join29(sessionPath, "judging");
   mkdirSync12(judgePath, { recursive: true });
   setupSession(judgePath, judgeModels, judgePrompt);
   await runModels(judgePath, { claudeFlags: opts.claudeFlags });
   const votes = parseJudgeVotes(judgePath, Object.keys(responses));
   const verdict = aggregateVerdict(votes, Object.keys(responses));
-  writeFileSync12(join28(sessionPath, "verdict.md"), formatVerdict(verdict, sessionPath), "utf-8");
+  writeFileSync12(join29(sessionPath, "verdict.md"), formatVerdict(verdict, sessionPath), "utf-8");
   return verdict;
 }
 function getStatus(sessionPath) {
-  return JSON.parse(readFileSync18(join28(sessionPath, "status.json"), "utf-8"));
+  return JSON.parse(readFileSync19(join29(sessionPath, "status.json"), "utf-8"));
 }
 function fisherYatesShuffle(arr) {
   for (let i = arr.length - 1;i > 0; i--) {
@@ -48926,7 +50357,7 @@ function fisherYatesShuffle(arr) {
   return arr;
 }
 function getDefaultJudgeModels(sessionPath) {
-  const manifest = JSON.parse(readFileSync18(join28(sessionPath, "manifest.json"), "utf-8"));
+  const manifest = JSON.parse(readFileSync19(join29(sessionPath, "manifest.json"), "utf-8"));
   return Object.values(manifest.models).map((e) => e.model);
 }
 function buildJudgePrompt(input, responses) {
@@ -48989,7 +50420,7 @@ function parseJudgeVotes(judgePath, responseIds) {
     const judgeId = file2.replace(/^response-/, "").replace(/\.md$/, "");
     let content;
     try {
-      content = readFileSync18(join28(judgePath, file2), "utf-8");
+      content = readFileSync19(join29(judgePath, file2), "utf-8");
     } catch {
       continue;
     }
@@ -49041,7 +50472,7 @@ function aggregateVerdict(votes, responseIds) {
 function formatVerdict(verdict, sessionPath) {
   let manifest = null;
   try {
-    manifest = JSON.parse(readFileSync18(join28(sessionPath, "manifest.json"), "utf-8"));
+    manifest = JSON.parse(readFileSync19(join29(sessionPath, "manifest.json"), "utf-8"));
   } catch {}
   let output = `# Team Verdict
 
@@ -49096,14 +50527,14 @@ __export(exports_mcp_server, {
   parseAnthropicSse: () => parseAnthropicSse,
   formatTeamResult: () => formatTeamResult
 });
-import { existsSync as existsSync21, mkdirSync as mkdirSync13, readFileSync as readFileSync19, readdirSync as readdirSync4, writeFileSync as writeFileSync13 } from "fs";
-import { homedir as homedir27 } from "os";
-import { dirname as dirname9, join as join29, resolve as resolve4 } from "path";
+import { existsSync as existsSync21, mkdirSync as mkdirSync13, readFileSync as readFileSync20, readdirSync as readdirSync4, writeFileSync as writeFileSync13 } from "fs";
+import { homedir as homedir28 } from "os";
+import { dirname as dirname9, join as join30, resolve as resolve4 } from "path";
 import { fileURLToPath } from "url";
 async function loadAllModels(forceRefresh = false) {
   if (!forceRefresh && existsSync21(ALL_MODELS_CACHE_PATH2)) {
     try {
-      const cacheData = JSON.parse(readFileSync19(ALL_MODELS_CACHE_PATH2, "utf-8"));
+      const cacheData = JSON.parse(readFileSync20(ALL_MODELS_CACHE_PATH2, "utf-8"));
       const lastUpdated = new Date(cacheData.lastUpdated);
       const ageInDays = (Date.now() - lastUpdated.getTime()) / (1000 * 60 * 60 * 24);
       if (ageInDays <= CACHE_MAX_AGE_DAYS) {
@@ -49122,7 +50553,7 @@ async function loadAllModels(forceRefresh = false) {
     return models;
   } catch {
     if (existsSync21(ALL_MODELS_CACHE_PATH2)) {
-      const cacheData = JSON.parse(readFileSync19(ALL_MODELS_CACHE_PATH2, "utf-8"));
+      const cacheData = JSON.parse(readFileSync20(ALL_MODELS_CACHE_PATH2, "utf-8"));
       return cacheData.models || [];
     }
     return [];
@@ -49704,7 +51135,7 @@ Use with: run_prompt(model="${results2[0].model.id}", prompt="your prompt")`;
       let stderrFull = stderr_snippet || "";
       if (error_log_path) {
         try {
-          stderrFull = readFileSync19(error_log_path, "utf-8");
+          stderrFull = readFileSync20(error_log_path, "utf-8");
         } catch {}
       }
       const sessionData = {};
@@ -49712,16 +51143,16 @@ Use with: run_prompt(model="${results2[0].model.id}", prompt="your prompt")`;
         const sp = session_path;
         for (const file2 of ["status.json", "manifest.json", "input.md"]) {
           try {
-            sessionData[file2] = readFileSync19(join29(sp, file2), "utf-8");
+            sessionData[file2] = readFileSync20(join30(sp, file2), "utf-8");
           } catch {}
         }
         try {
-          const errorDir = join29(sp, "errors");
+          const errorDir = join30(sp, "errors");
           if (existsSync21(errorDir)) {
             for (const f of readdirSync4(errorDir)) {
               if (f.endsWith(".log")) {
                 try {
-                  sessionData[`errors/${f}`] = readFileSync19(join29(errorDir, f), "utf-8");
+                  sessionData[`errors/${f}`] = readFileSync20(join30(errorDir, f), "utf-8");
                 } catch {}
               }
             }
@@ -49731,7 +51162,7 @@ Use with: run_prompt(model="${results2[0].model.id}", prompt="your prompt")`;
           for (const f of readdirSync4(sp)) {
             if (f.startsWith("response-") && f.endsWith(".md")) {
               try {
-                const content = readFileSync19(join29(sp, f), "utf-8");
+                const content = readFileSync20(join30(sp, f), "utf-8");
                 sessionData[f] = content.slice(0, 200) + (content.length > 200 ? "... (truncated)" : "");
               } catch {}
             }
@@ -49740,9 +51171,9 @@ Use with: run_prompt(model="${results2[0].model.id}", prompt="your prompt")`;
       }
       let version2 = "unknown";
       try {
-        const pkgPath = join29(__dirname2, "../package.json");
+        const pkgPath = join30(__dirname2, "../package.json");
         if (existsSync21(pkgPath)) {
-          version2 = JSON.parse(readFileSync19(pkgPath, "utf-8")).version;
+          version2 = JSON.parse(readFileSync20(pkgPath, "utf-8")).version;
         }
       } catch {}
       const report = {
@@ -50146,8 +51577,8 @@ var init_mcp_server = __esm(() => {
   import_dotenv2.config({ quiet: true });
   __filename2 = fileURLToPath(import.meta.url);
   __dirname2 = dirname9(__filename2);
-  CLAUDISH_CACHE_DIR = join29(homedir27(), ".claudish");
-  ALL_MODELS_CACHE_PATH2 = join29(CLAUDISH_CACHE_DIR, "all-models.json");
+  CLAUDISH_CACHE_DIR = join30(homedir28(), ".claudish");
+  ALL_MODELS_CACHE_PATH2 = join30(CLAUDISH_CACHE_DIR, "all-models.json");
   NEXT_STEP = {
     nonzero_exit: "read the evidence log, then retry or drop the model",
     timeout: "raise `timeout`, or pick a faster model",
@@ -50172,7 +51603,7 @@ var exports_serve_command = {};
 __export(exports_serve_command, {
   serveCommand: () => serveCommand
 });
-import { existsSync as existsSync22, readFileSync as readFileSync20 } from "fs";
+import { existsSync as existsSync22, readFileSync as readFileSync21 } from "fs";
 function parseServeArgs(args) {
   const out = {};
   for (let i = 0;i < args.length; i++) {
@@ -50196,7 +51627,7 @@ function loadModelMap(path) {
   }
   let raw2;
   try {
-    raw2 = readFileSync20(path, "utf-8");
+    raw2 = readFileSync21(path, "utf-8");
   } catch (e) {
     throw new Error(`failed to read --models file ${path}: ${e instanceof Error ? e.message : String(e)}`);
   }
@@ -50273,7 +51704,7 @@ var exports_behavior_command = {};
 __export(exports_behavior_command, {
   behaviorCommand: () => behaviorCommand
 });
-import { existsSync as existsSync23, readFileSync as readFileSync21, writeFileSync as writeFileSync14 } from "fs";
+import { existsSync as existsSync23, readFileSync as readFileSync22, writeFileSync as writeFileSync14 } from "fs";
 function severityColor(sev) {
   if (sev === "fix")
     return green(sev);
@@ -50372,7 +51803,7 @@ function setTelemetryEnabled(value) {
   let cfg = {};
   try {
     if (existsSync23(path)) {
-      const parsed = JSON.parse(readFileSync21(path, "utf-8"));
+      const parsed = JSON.parse(readFileSync22(path, "utf-8"));
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
         cfg = parsed;
       }
@@ -50394,7 +51825,7 @@ function showTelemetry(action, json2) {
   try {
     const path = outboxPath();
     if (existsSync23(path)) {
-      pending = readFileSync21(path, "utf8").split(`
+      pending = readFileSync22(path, "utf8").split(`
 `).filter(Boolean).length;
     }
   } catch {}
@@ -50467,6 +51898,12 @@ function describeSourceSync(p, config3) {
     return "oauth";
   if (p.catalogName === "antigravity" && hasSharedAntigravityToken())
     return "oauth";
+  if (p.catalogName === "devin") {
+    if (realValue(process.env.WINDSURF_API_KEY))
+      return "env";
+    if (hasDevinCredentials())
+      return "oauth";
+  }
   const hasCfg = !!p.apiKeyEnvVar && !!realValue(config3.apiKeys?.[p.apiKeyEnvVar]);
   const hasEnv = !!p.apiKeyEnvVar && !!realValue(process.env[p.apiKeyEnvVar]);
   if (hasEnv && hasCfg)
@@ -50487,6 +51924,7 @@ async function describeSource(p, config3) {
 }
 var init_source = __esm(() => {
   init_profile_config();
+  init_devin_credentials();
   init_antigravity_token();
   init_oauth_registry();
   init_api_key_credential();
@@ -50534,8 +51972,8 @@ function providerIsReadyForDisplay(p, config3, localLiveness) {
 function providerAuthCapabilities(p, config3) {
   const apiKeySupported = !!p.apiKeyEnvVar;
   const apiKeySet = apiKeySupported && (!!process.env[p.apiKeyEnvVar] || !!config3.apiKeys?.[p.apiKeyEnvVar]);
-  const oauthSupported = !!p.oauthSlug;
-  const oauthSet = oauthSupported && (hasOAuthCredentials(p.catalogName) || p.catalogName === "antigravity" && hasSharedAntigravityToken());
+  const oauthSupported = !!p.oauthSlug || p.catalogName === "devin";
+  const oauthSet = oauthSupported && (hasOAuthCredentials(p.catalogName) || p.catalogName === "antigravity" && hasSharedAntigravityToken() || p.catalogName === "devin" && hasDevinCredentials());
   return {
     apiKey: { supported: apiKeySupported, set: apiKeySet },
     oauth: { supported: oauthSupported, set: oauthSet }
@@ -50553,6 +51991,7 @@ var init_providers = __esm(() => {
   init_antigravity_token();
   init_source();
   init_oauth_registry();
+  init_devin_credentials();
   init_provider_definitions();
   SKIP = new Set(["qwen", "native-anthropic"]);
   PROVIDERS = getAllProviders().filter((d) => !SKIP.has(d.name)).map(toProviderDef);
@@ -59801,18 +61240,18 @@ var require_dbcs_codec = __commonJS((exports) => {
   DBCSCodec.prototype.encoder = DBCSEncoder;
   DBCSCodec.prototype.decoder = DBCSDecoder;
   DBCSCodec.prototype._getDecodeTrieNode = function(addr) {
-    var bytes = [];
+    var bytes2 = [];
     for (;addr > 0; addr >>>= 8) {
-      bytes.push(addr & 255);
+      bytes2.push(addr & 255);
     }
-    if (bytes.length == 0) {
-      bytes.push(0);
+    if (bytes2.length == 0) {
+      bytes2.push(0);
     }
     var node = this.decodeTables[0];
-    for (var i2 = bytes.length - 1;i2 > 0; i2--) {
-      var val = node[bytes[i2]];
+    for (var i2 = bytes2.length - 1;i2 > 0; i2--) {
+      var val = node[bytes2[i2]];
       if (val == UNASSIGNED) {
-        node[bytes[i2]] = NODE_START - this.decodeTables.length;
+        node[bytes2[i2]] = NODE_START - this.decodeTables.length;
         this.decodeTables.push(node = UNASSIGNED_NODE.slice(0));
       } else if (val <= NODE_START) {
         node = this.decodeTables[NODE_START - val];
@@ -61863,10 +63302,10 @@ var init_RemoveFileError = __esm(() => {
 
 // ../../node_modules/.bun/@inquirer+external-editor@2.0.1+04f2146be16c61ef/node_modules/@inquirer/external-editor/dist/index.js
 import { spawn as spawn3, spawnSync as spawnSync2 } from "child_process";
-import { readFileSync as readFileSync22, unlinkSync as unlinkSync6, writeFileSync as writeFileSync15 } from "fs";
+import { readFileSync as readFileSync23, unlinkSync as unlinkSync6, writeFileSync as writeFileSync15 } from "fs";
 import path from "path";
 import os from "os";
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 function editAsync(text = "", callback, fileOptions) {
   const editor = new ExternalEditor(text, fileOptions);
   editor.runAsync((err, result) => {
@@ -61958,7 +63397,7 @@ class ExternalEditor {
   createTemporaryFile() {
     try {
       const baseDir = this.fileOptions.dir ?? os.tmpdir();
-      const id = randomUUID6();
+      const id = randomUUID7();
       const prefix = sanitizeAffix(this.fileOptions.prefix);
       const postfix = sanitizeAffix(this.fileOptions.postfix);
       const filename = `${prefix}${id}${postfix}`;
@@ -61979,7 +63418,7 @@ class ExternalEditor {
   }
   readTemporaryFile() {
     try {
-      const tempFileBuffer = readFileSync22(this.tempFile);
+      const tempFileBuffer = readFileSync23(this.tempFile);
       if (tempFileBuffer.length === 0) {
         this.text = "";
       } else {
@@ -62961,8 +64400,8 @@ var init_dist16 = __esm(() => {
 // src/auth/antigravity-oauth.ts
 import { spawnSync as spawnSync3 } from "child_process";
 import { existsSync as existsSync24, unlinkSync as unlinkSync7 } from "fs";
-import { homedir as homedir28 } from "os";
-import { join as join30 } from "path";
+import { homedir as homedir29 } from "os";
+import { join as join31 } from "path";
 async function defaultSuggestModel() {
   try {
     const tok = readSharedAntigravityToken();
@@ -63083,7 +64522,7 @@ No session detected yet. Starting the Antigravity CLI interactively \u2014
   async logout(deps) {
     deleteSharedAntigravityToken(deps);
     try {
-      const tokenFile = join30(homedir28(), ".gemini", "antigravity-cli", "antigravity-oauth-token");
+      const tokenFile = join31(homedir29(), ".gemini", "antigravity-cli", "antigravity-oauth-token");
       if (existsSync24(tokenFile))
         unlinkSync7(tokenFile);
     } catch {}
@@ -64535,11 +65974,11 @@ async function probeLink(proxyUrl, link, timeoutMs) {
   } catch (e) {
     const latencyMs = Date.now() - startedAt;
     const name = e?.name || "";
-    const msg = String(e?.message || e);
-    if (name === "TimeoutError" || name === "AbortError" || /timeout/i.test(msg)) {
-      return { state: "timeout", latencyMs, errorMessage: msg };
+    const msg2 = String(e?.message || e);
+    if (name === "TimeoutError" || name === "AbortError" || /timeout/i.test(msg2)) {
+      return { state: "timeout", latencyMs, errorMessage: msg2 };
     }
-    return { state: "network-error", latencyMs, errorMessage: msg };
+    return { state: "network-error", latencyMs, errorMessage: msg2 };
   }
   const ttfbMs = Date.now() - startedAt;
   if (!response.ok) {
@@ -64568,7 +66007,7 @@ function annotateOAuthHint(result, provider, isOAuth) {
     return result;
   if (result.state === "live")
     return result;
-  const loginCommand2 = provider === "gemini-codeassist" ? "claudish login gemini" : provider === "antigravity" ? "claudish login antigravity" : provider === "vertex" ? "gcloud auth application-default login" : undefined;
+  const loginCommand2 = provider === "gemini-codeassist" ? "claudish login gemini" : provider === "antigravity" ? "claudish login antigravity" : provider === "vertex" ? "gcloud auth application-default login" : provider === "devin" ? "devin login" : undefined;
   if (!loginCommand2)
     return result;
   if (result.httpStatus === 403)
@@ -64676,9 +66115,9 @@ function extractErrorMessage(body) {
     return;
   try {
     const parsed = JSON.parse(body);
-    const msg = parsed?.error?.message || parsed?.error?.error?.message || parsed?.message || parsed?.detail;
-    if (typeof msg === "string" && msg.length > 0) {
-      return msg.length > 160 ? `${msg.slice(0, 157)}...` : msg;
+    const msg2 = parsed?.error?.message || parsed?.error?.error?.message || parsed?.message || parsed?.detail;
+    if (typeof msg2 === "string" && msg2.length > 0) {
+      return msg2.length > 160 ? `${msg2.slice(0, 157)}...` : msg2;
     }
   } catch {}
   const trimmed2 = body.trim();
@@ -64894,7 +66333,7 @@ function isFailureState(state) {
 }
 var STREAM_MS_FLOOR = 50, OAUTH_PROVIDERS2, PROBE_PROMPT = "Count from one to twenty in words, one per line.", PROBE_MAX_TOKENS = 512;
 var init_probe_live = __esm(() => {
-  OAUTH_PROVIDERS2 = new Set(["vertex", "gemini-codeassist"]);
+  OAUTH_PROVIDERS2 = new Set(["vertex", "gemini-codeassist", "devin"]);
 });
 
 // src/tui/theme.ts
@@ -67172,19 +68611,19 @@ import {
   copyFileSync as copyFileSync2,
   existsSync as existsSync25,
   mkdirSync as mkdirSync14,
-  readFileSync as readFileSync23,
+  readFileSync as readFileSync24,
   readdirSync as readdirSync5,
   unlinkSync as unlinkSync8,
   writeFileSync as writeFileSync16
 } from "fs";
-import { homedir as homedir29 } from "os";
-import { dirname as dirname10, join as join31 } from "path";
+import { homedir as homedir30 } from "os";
+import { dirname as dirname10, join as join32 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function getVersion3() {
   return VERSION;
 }
 function clearAllModelCaches() {
-  const cacheDir = join31(homedir29(), ".claudish");
+  const cacheDir = join32(homedir30(), ".claudish");
   if (!existsSync25(cacheDir))
     return;
   const cachePatterns = ["pricing-cache.json", "recommended-models-cache.json"];
@@ -67193,7 +68632,7 @@ function clearAllModelCaches() {
     const files = readdirSync5(cacheDir);
     for (const file2 of files) {
       if (cachePatterns.includes(file2)) {
-        unlinkSync8(join31(cacheDir, file2));
+        unlinkSync8(join32(cacheDir, file2));
         cleared++;
       }
     }
@@ -67603,7 +69042,7 @@ Usage:  claudish --models --provider <slug>`);
     });
     config3.resolvedDefaultProvider = resolved;
     if (resolved.legacyAutoPromoted && !config3.quiet) {
-      const markerFile = join31(homedir29(), ".claudish", ".legacy-litellm-hint-shown");
+      const markerFile = join32(homedir30(), ".claudish", ".legacy-litellm-hint-shown");
       if (!existsSync25(markerFile)) {
         const hint = buildLegacyHint(resolved);
         if (hint) {
@@ -68074,6 +69513,9 @@ async function probeModelRouting(models, jsonOutput, options = { live: true, tim
     } else if (providerName === "litellm") {
       formatAdapterName = "LiteLLMAPIFormat";
       declaredStreamFormat = "openai-sse";
+    } else if (providerName === "devin") {
+      formatAdapterName = "DevinAPIFormat";
+      declaredStreamFormat = "connect-proto";
     } else {
       formatAdapterName = "OpenAIAPIFormat";
       declaredStreamFormat = "openai-sse";
@@ -68112,8 +69554,8 @@ async function probeModelRouting(models, jsonOutput, options = { live: true, tim
         console.error(`${DIM}Probing providers via live requests (may incur small cost, use --no-probe to skip)...${RESET}`);
         liveProxy2 = await createProxyServer2(probePort, process.env.OPENROUTER_API_KEY, undefined, false, process.env.ANTHROPIC_API_KEY, undefined, { quiet: true });
       } catch (e) {
-        const msg = e instanceof Error ? e.message : String(e);
-        console.error(`${YELLOW}Failed to start probe proxy (${msg}). Falling back to static probe.${RESET}`);
+        const msg2 = e instanceof Error ? e.message : String(e);
+        console.error(`${YELLOW}Failed to start probe proxy (${msg2}). Falling back to static probe.${RESET}`);
         liveProxy2 = null;
       }
     }
@@ -68678,8 +70120,8 @@ ${h("MORE INFO")}
 }
 function printAIAgentGuide() {
   try {
-    const guidePath = join31(__dirname3, "../AI_AGENT_GUIDE.md");
-    const guideContent = readFileSync23(guidePath, "utf-8");
+    const guidePath = join32(__dirname3, "../AI_AGENT_GUIDE.md");
+    const guideContent = readFileSync24(guidePath, "utf-8");
     console.log(guideContent);
   } catch (error46) {
     console.error("Error reading AI Agent Guide:");
@@ -68695,10 +70137,10 @@ async function initializeClaudishSkill() {
   console.log(`\uD83D\uDD27 Initializing Claudish skill in current project...
 `);
   const cwd = process.cwd();
-  const claudeDir = join31(cwd, ".claude");
-  const skillsDir = join31(claudeDir, "skills");
-  const claudishSkillDir = join31(skillsDir, "claudish-usage");
-  const skillFile = join31(claudishSkillDir, "SKILL.md");
+  const claudeDir = join32(cwd, ".claude");
+  const skillsDir = join32(claudeDir, "skills");
+  const claudishSkillDir = join32(skillsDir, "claudish-usage");
+  const skillFile = join32(claudishSkillDir, "SKILL.md");
   if (existsSync25(skillFile)) {
     console.log("\u2705 Claudish skill already installed at:");
     console.log(`   ${skillFile}
@@ -68706,7 +70148,7 @@ async function initializeClaudishSkill() {
     console.log("\uD83D\uDCA1 To reinstall, delete the file and run 'claudish --init' again.");
     return;
   }
-  const sourceSkillPath = join31(__dirname3, "../skills/claudish-usage/SKILL.md");
+  const sourceSkillPath = join32(__dirname3, "../skills/claudish-usage/SKILL.md");
   if (!existsSync25(sourceSkillPath)) {
     console.error("\u274C Error: Claudish skill file not found in installation.");
     console.error(`   Expected at: ${sourceSkillPath}`);
@@ -68809,24 +70251,24 @@ __export(exports_update_checker, {
   clearCache: () => clearCache,
   checkForUpdates: () => checkForUpdates
 });
-import { existsSync as existsSync26, mkdirSync as mkdirSync15, readFileSync as readFileSync24, unlinkSync as unlinkSync9, writeFileSync as writeFileSync17 } from "fs";
-import { homedir as homedir30, platform as platform2, tmpdir } from "os";
-import { join as join32 } from "path";
+import { existsSync as existsSync26, mkdirSync as mkdirSync15, readFileSync as readFileSync25, unlinkSync as unlinkSync9, writeFileSync as writeFileSync17 } from "fs";
+import { homedir as homedir31, platform as platform2, tmpdir } from "os";
+import { join as join33 } from "path";
 function getCacheFilePath() {
   let cacheDir;
   if (isWindows) {
-    const localAppData = process.env.LOCALAPPDATA || join32(homedir30(), "AppData", "Local");
-    cacheDir = join32(localAppData, "claudish");
+    const localAppData = process.env.LOCALAPPDATA || join33(homedir31(), "AppData", "Local");
+    cacheDir = join33(localAppData, "claudish");
   } else {
-    cacheDir = join32(homedir30(), ".cache", "claudish");
+    cacheDir = join33(homedir31(), ".cache", "claudish");
   }
   try {
     if (!existsSync26(cacheDir)) {
       mkdirSync15(cacheDir, { recursive: true });
     }
-    return join32(cacheDir, "update-check.json");
+    return join33(cacheDir, "update-check.json");
   } catch {
-    return join32(tmpdir(), "claudish-update-check.json");
+    return join33(tmpdir(), "claudish-update-check.json");
   }
 }
 function readCache() {
@@ -68835,7 +70277,7 @@ function readCache() {
     if (!existsSync26(cachePath)) {
       return null;
     }
-    const data = JSON.parse(readFileSync24(cachePath, "utf-8"));
+    const data = JSON.parse(readFileSync25(cachePath, "utf-8"));
     return data;
   } catch {
     return null;
@@ -69743,15 +71185,15 @@ var init_local_liveness = __esm(() => {
 });
 
 // src/providers/probe-catalog.ts
-import { existsSync as existsSync27, mkdirSync as mkdirSync16, readFileSync as readFileSync25, writeFileSync as writeFileSync18 } from "fs";
-import { homedir as homedir31 } from "os";
-import { dirname as dirname11, join as join33 } from "path";
+import { existsSync as existsSync27, mkdirSync as mkdirSync16, readFileSync as readFileSync26, writeFileSync as writeFileSync18 } from "fs";
+import { homedir as homedir32 } from "os";
+import { dirname as dirname11, join as join34 } from "path";
 function readProbeModelsCache(path2 = PROBE_MODELS_CACHE_PATH) {
   if (!existsSync27(path2))
     return null;
   let raw2;
   try {
-    raw2 = JSON.parse(readFileSync25(path2, "utf-8"));
+    raw2 = JSON.parse(readFileSync26(path2, "utf-8"));
   } catch {
     return null;
   }
@@ -69880,7 +71322,7 @@ function isValidResponse(raw2) {
 var PROBE_MODELS_URL = "https://us-central1-claudish-6da10.cloudfunctions.net/probeModels", CACHE_TTL_MS4, FETCH_TIMEOUT_MS3 = 15000, PROBE_MODELS_CACHE_PATH, _inFlight = null;
 var init_probe_catalog = __esm(() => {
   CACHE_TTL_MS4 = 60 * 60 * 1000;
-  PROBE_MODELS_CACHE_PATH = join33(homedir31(), ".claudish", "probe-models.json");
+  PROBE_MODELS_CACHE_PATH = join34(homedir32(), ".claudish", "probe-models.json");
 });
 
 // src/tui/constants.ts
@@ -74327,8 +75769,8 @@ function useRouteProbe(config3) {
         try {
           proxyUrl = await ensureProbeProxy();
         } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          setProbeResults((prev) => prev.map((e) => ({ ...e, status: "failed", error: `probe proxy: ${msg}` })));
+          const msg2 = err instanceof Error ? err.message : String(err);
+          setProbeResults((prev) => prev.map((e) => ({ ...e, status: "failed", error: `probe proxy: ${msg2}` })));
           setProbeMode("done");
           return;
         }
@@ -74682,12 +76124,12 @@ function App({ requestLogin } = {}) {
       }));
       setStatusMsg(`1Password test ok \u2192 ${note}`);
     } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
+      const msg2 = err instanceof Error ? err.message : String(err);
       setOpTestResults((prev) => ({
         ...prev,
-        [key]: { status: "failed", error: msg }
+        [key]: { status: "failed", error: msg2 }
       }));
-      setStatusMsg(msg);
+      setStatusMsg(msg2);
     } finally {
       setOpBusy(false);
     }
@@ -74762,14 +76204,14 @@ function App({ requestLogin } = {}) {
         invalidateProbeProxyHandlers();
         refreshConfig();
       } catch (testErr) {
-        const msg = testErr instanceof Error ? testErr.message : String(testErr);
-        console.error(`[claudish] 1Password add: saved but live resolve failed: ${msg}`);
-        setStatusMsg(`1Password ${kindWord} saved (${scope}) \u2014 live resolve failed: ${msg}`);
+        const msg2 = testErr instanceof Error ? testErr.message : String(testErr);
+        console.error(`[claudish] 1Password add: saved but live resolve failed: ${msg2}`);
+        setStatusMsg(`1Password ${kindWord} saved (${scope}) \u2014 live resolve failed: ${msg2}`);
       }
     } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      console.error(`[claudish] 1Password add failed to persist: ${msg}`);
-      setStatusMsg(`1Password add failed: ${msg}`);
+      const msg2 = err instanceof Error ? err.message : String(err);
+      console.error(`[claudish] 1Password add failed to persist: ${msg2}`);
+      setStatusMsg(`1Password add failed: ${msg2}`);
       setMode("browse");
       resetOpWizard();
     } finally {
@@ -74789,8 +76231,8 @@ function App({ requestLogin } = {}) {
       setOpVaults(vaults);
       setStatusMsg(`1Password: ${vaults.length} vault${vaults.length === 1 ? "" : "s"}.`);
     } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      setStatusMsg(msg);
+      const msg2 = err instanceof Error ? err.message : String(err);
+      setStatusMsg(msg2);
       setMode("browse");
     } finally {
       setOpBusy(false);
@@ -74811,8 +76253,8 @@ function App({ requestLogin } = {}) {
       setOpItems(items);
       setStatusMsg(`1Password: ${items.length} item${items.length === 1 ? "" : "s"}.`);
     } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      setStatusMsg(msg);
+      const msg2 = err instanceof Error ? err.message : String(err);
+      setStatusMsg(msg2);
       setMode("browse");
     } finally {
       setOpBusy(false);
@@ -74840,8 +76282,8 @@ function App({ requestLogin } = {}) {
       setOpFields(fields);
       setStatusMsg(`1Password: ${fields.length} field${fields.length === 1 ? "" : "s"}.`);
     } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      setStatusMsg(msg);
+      const msg2 = err instanceof Error ? err.message : String(err);
+      setStatusMsg(msg2);
       setMode("browse");
     } finally {
       setOpBusy(false);
@@ -74857,9 +76299,9 @@ function App({ requestLogin } = {}) {
       setOpEnvPreview(names);
       setStatusMsg(`1Password environment \u2192 ${names.length} var${names.length === 1 ? "" : "s"}. Enter to save.`);
     } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
+      const msg2 = err instanceof Error ? err.message : String(err);
       setOpEnvPreview(null);
-      setStatusMsg(msg);
+      setStatusMsg(msg2);
     } finally {
       setOpBusy(false);
     }
@@ -74967,10 +76409,10 @@ function App({ requestLogin } = {}) {
       }
     } catch (err) {
       const ms = Date.now() - startMs;
-      const msg = err instanceof Error ? err.message : String(err);
+      const msg2 = err instanceof Error ? err.message : String(err);
       setTestResults((prev) => ({
         ...prev,
-        [provName]: { status: "failed", error: `proxy: ${msg}`, ms }
+        [provName]: { status: "failed", error: `proxy: ${msg2}`, ms }
       }));
     }
   }, []);
@@ -76237,14 +77679,14 @@ import {
   existsSync as existsSync28,
   mkdirSync as mkdirSync17,
   openSync as openSync5,
-  readFileSync as readFileSync26,
+  readFileSync as readFileSync27,
   readdirSync as readdirSync6,
   statSync as statSync5,
   unlinkSync as unlinkSync10,
   writeFileSync as writeFileSync19
 } from "fs";
-import { homedir as homedir32, tmpdir as tmpdir2 } from "os";
-import { dirname as dirname12, join as join34 } from "path";
+import { homedir as homedir33, tmpdir as tmpdir2 } from "os";
+import { dirname as dirname12, join as join35 } from "path";
 import { isatty } from "tty";
 function releaseTerminalIsolation() {
   if (!restoreTerminal)
@@ -76279,14 +77721,14 @@ function isProxyAuthMode(config3) {
 }
 function managedSettingsPath() {
   if (isWindows2()) {
-    return join34(process.env.PROGRAMDATA || "C:\\ProgramData", "ClaudeCode", "managed-settings.json");
+    return join35(process.env.PROGRAMDATA || "C:\\ProgramData", "ClaudeCode", "managed-settings.json");
   }
   if (process.platform === "darwin") {
     return "/Library/Application Support/ClaudeCode/managed-settings.json";
   }
   return "/etc/claude-code/managed-settings.json";
 }
-function managedSettingsForcesClaudeAi(readFile3 = readFileSync26) {
+function managedSettingsForcesClaudeAi(readFile3 = readFileSync27) {
   try {
     const raw2 = readFile3(managedSettingsPath(), "utf-8");
     const parsed = JSON.parse(raw2);
@@ -76300,9 +77742,9 @@ function isWindows2() {
 }
 function createStatusLineScript(tokenFilePath) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join34(homeDir, ".claudish");
+  const claudishDir = join35(homeDir, ".claudish");
   const timestamp = Date.now();
-  const scriptPath = join34(claudishDir, `status-${timestamp}.js`);
+  const scriptPath = join35(claudishDir, `status-${timestamp}.js`);
   const escapedTokenPath = tokenFilePath.replace(/\\/g, "\\\\");
   const script = `
 const fs = require('fs');
@@ -76466,7 +77908,7 @@ function cleanupStaleTokenFiles(dir, now = Date.now(), maxAgeMs = STALE_TOKEN_FI
     if (!name.startsWith("tokens-") || !name.endsWith(".json"))
       continue;
     scanned++;
-    const full = join34(dir, name);
+    const full = join35(dir, name);
     try {
       if (statSync5(full).mtimeMs >= cutoff)
         continue;
@@ -76483,7 +77925,7 @@ function parseSettingsArg(value) {
   if (value.trimStart().startsWith("{")) {
     return JSON.parse(value);
   }
-  return JSON.parse(readFileSync26(value, "utf-8"));
+  return JSON.parse(readFileSync27(value, "utf-8"));
 }
 function parseSettingsArgSafe(value) {
   try {
@@ -76495,9 +77937,9 @@ function parseSettingsArgSafe(value) {
 }
 function userSettingsFileCandidates(cwd) {
   return [
-    join34(homedir32(), ".claude", "settings.json"),
-    join34(cwd, ".claude", "settings.json"),
-    join34(cwd, ".claude", "settings.local.json")
+    join35(homedir33(), ".claude", "settings.json"),
+    join35(cwd, ".claude", "settings.json"),
+    join35(cwd, ".claude", "settings.local.json")
   ];
 }
 function discoverUserStatusLineCommand(claudeArgs = [], cwd = process.cwd()) {
@@ -76538,13 +77980,13 @@ function buildChainedStatusCommand(userCommand, claudishBody, claudishSegment) {
 }
 function createTempSettingsFile(_modelDisplay, port, proxyAuthMode, userStatusLineCommand) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join34(homeDir, ".claudish");
+  const claudishDir = join35(homeDir, ".claudish");
   try {
     mkdirSync17(claudishDir, { recursive: true });
   } catch {}
   const timestamp = Date.now();
-  const tempPath = join34(claudishDir, `settings-${timestamp}.json`);
-  const tokenFilePath = join34(claudishDir, `tokens-${port}.json`);
+  const tempPath = join35(claudishDir, `settings-${timestamp}.json`);
+  const tokenFilePath = join35(claudishDir, `tokens-${port}.json`);
   cleanupStaleTokenFiles(claudishDir);
   initializeTokenFile(tokenFilePath);
   let statusCommand;
@@ -76817,8 +78259,8 @@ async function runClaudeWithProxy(config3, proxyUrl, onCleanup) {
     console.error("Install it from: https://claude.com/claude-code");
     console.error(`
 Or set CLAUDE_PATH to your custom installation:`);
-    const home = homedir32();
-    const localPath = isWindows2() ? join34(home, ".claude", "local", "claude.exe") : join34(home, ".claude", "local", "claude");
+    const home = homedir33();
+    const localPath = isWindows2() ? join35(home, ".claude", "local", "claude.exe") : join35(home, ".claude", "local", "claude");
     console.error(`  export CLAUDE_PATH=${localPath}`);
     process.exit(1);
   }
@@ -76902,16 +78344,16 @@ async function findClaudeBinary() {
       return process.env.CLAUDE_PATH;
     }
   }
-  const home = homedir32();
-  const localPath = isWindows3 ? join34(home, ".claude", "local", "claude.exe") : join34(home, ".claude", "local", "claude");
+  const home = homedir33();
+  const localPath = isWindows3 ? join35(home, ".claude", "local", "claude.exe") : join35(home, ".claude", "local", "claude");
   if (existsSync28(localPath)) {
     return localPath;
   }
   if (isWindows3) {
     const windowsPaths = [
-      join34(home, "AppData", "Roaming", "npm", "claude.cmd"),
-      join34(home, ".npm-global", "claude.cmd"),
-      join34(home, "node_modules", ".bin", "claude.cmd")
+      join35(home, "AppData", "Roaming", "npm", "claude.cmd"),
+      join35(home, ".npm-global", "claude.cmd"),
+      join35(home, "node_modules", ".bin", "claude.cmd")
     ];
     for (const path2 of windowsPaths) {
       if (existsSync28(path2)) {
@@ -76922,11 +78364,11 @@ async function findClaudeBinary() {
     const commonPaths = [
       "/usr/local/bin/claude",
       "/opt/homebrew/bin/claude",
-      join34(home, ".npm-global/bin/claude"),
-      join34(home, ".local/bin/claude"),
-      join34(home, "node_modules/.bin/claude"),
+      join35(home, ".npm-global/bin/claude"),
+      join35(home, ".local/bin/claude"),
+      join35(home, "node_modules/.bin/claude"),
       "/data/data/com.termux/files/usr/bin/claude",
-      join34(home, "../usr/bin/claude")
+      join35(home, "../usr/bin/claude")
     ];
     for (const path2 of commonPaths) {
       if (existsSync28(path2)) {
@@ -76990,17 +78432,17 @@ __export(exports_diag_output, {
   LogFileDiagOutput: () => LogFileDiagOutput
 });
 import { createWriteStream as createWriteStream3, mkdirSync as mkdirSync18, unlinkSync as unlinkSync11, writeFileSync as writeFileSync20 } from "fs";
-import { homedir as homedir33 } from "os";
-import { join as join35 } from "path";
+import { homedir as homedir34 } from "os";
+import { join as join36 } from "path";
 function getClaudishDir() {
-  const dir = join35(homedir33(), ".claudish");
+  const dir = join36(homedir34(), ".claudish");
   try {
     mkdirSync18(dir, { recursive: true });
   } catch {}
   return dir;
 }
 function getDiagLogPath() {
-  return join35(getClaudishDir(), `diag-${process.pid}.log`);
+  return join36(getClaudishDir(), `diag-${process.pid}.log`);
 }
 
 class LogFileDiagOutput {
@@ -77015,9 +78457,9 @@ class LogFileDiagOutput {
     this.stream = createWriteStream3(this.logPath, { flags: "a" });
     this.stream.on("error", () => {});
   }
-  write(msg) {
+  write(msg2) {
     const timestamp = new Date().toISOString();
-    const line = `[${timestamp}] ${msg}
+    const line = `[${timestamp}] ${msg2}
 `;
     try {
       this.stream.write(line);
@@ -77211,9 +78653,9 @@ __export(exports_team_grid, {
 });
 import { spawn as spawn5 } from "child_process";
 import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync29, readFileSync as readFileSync27, writeFileSync as writeFileSync21 } from "fs";
+import { existsSync as existsSync29, readFileSync as readFileSync28, writeFileSync as writeFileSync21 } from "fs";
 import { connect as netConnect } from "net";
-import { dirname as dirname13, join as join36 } from "path";
+import { dirname as dirname13, join as join37 } from "path";
 import { setTimeout as wait } from "timers/promises";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function resolveRouteInfo(modelId) {
@@ -77307,17 +78749,17 @@ function buildPaneHeader(model, prompt, bg) {
 function findMagmuxBinary() {
   const thisFile = fileURLToPath3(import.meta.url);
   const thisDir = dirname13(thisFile);
-  const pkgRoot = join36(thisDir, "..");
+  const pkgRoot = join37(thisDir, "..");
   const platform3 = process.platform;
   const arch = process.arch;
-  const bundledMagmux = join36(pkgRoot, "native", `magmux-${platform3}-${arch}`);
+  const bundledMagmux = join37(pkgRoot, "native", `magmux-${platform3}-${arch}`);
   if (existsSync29(bundledMagmux))
     return bundledMagmux;
   try {
     const pkgName = `@claudish/magmux-${platform3}-${arch}`;
     let searchDir = pkgRoot;
     for (let i = 0;i < 5; i++) {
-      const candidate = join36(searchDir, "node_modules", pkgName, "bin", "magmux");
+      const candidate = join37(searchDir, "node_modules", pkgName, "bin", "magmux");
       if (existsSync29(candidate))
         return candidate;
       const parent = dirname13(searchDir);
@@ -77424,9 +78866,9 @@ async function runWithGrid(sessionPath, models, input, opts) {
   const keep = opts?.keep ?? false;
   const manifest = setupSession(sessionPath, models, input);
   const startedAt = new Date().toISOString();
-  const gridfilePath = join36(sessionPath, "gridfile.txt");
-  const prompt = readFileSync27(join36(sessionPath, "input.md"), "utf-8").replace(/'/g, "'\\''").replace(/\n/g, " ");
-  const rawPrompt = readFileSync27(join36(sessionPath, "input.md"), "utf-8");
+  const gridfilePath = join37(sessionPath, "gridfile.txt");
+  const prompt = readFileSync28(join37(sessionPath, "input.md"), "utf-8").replace(/'/g, "'\\''").replace(/\n/g, " ");
+  const rawPrompt = readFileSync28(join37(sessionPath, "input.md"), "utf-8");
   const usedBannerColors = new Set;
   const gridLines = Object.entries(manifest.models).map(([anonId]) => {
     const model = manifest.models[anonId].model;
@@ -77457,7 +78899,7 @@ async function runWithGrid(sessionPath, models, input, opts) {
   });
   const [{ results: results2 }] = await Promise.all([subscription, procExit]);
   const status = buildTeamStatus(manifest, startedAt, results2?.panes ?? null);
-  const statusPath = join36(sessionPath, "status.json");
+  const statusPath = join37(sessionPath, "status.json");
   writeFileSync21(statusPath, JSON.stringify(status, null, 2), "utf-8");
   return status;
 }
@@ -77481,8 +78923,8 @@ var init_team_grid = __esm(() => {
 init_op_source();
 init_startup_trace();
 var import_dotenv3 = __toESM(require_main(), 1);
-import { existsSync as existsSync30, readFileSync as readFileSync28 } from "fs";
-import { join as join37, resolve as resolve5 } from "path";
+import { existsSync as existsSync30, readFileSync as readFileSync29 } from "fs";
+import { join as join38, resolve as resolve5 } from "path";
 import_dotenv3.config({ quiet: true });
 function classifyStartupKind() {
   const argv = process.argv.slice(2);
@@ -77729,14 +79171,14 @@ async function runCli() {
     if (cliConfig.team && cliConfig.team.length > 0) {
       let prompt = cliConfig.claudeArgs.join(" ");
       if (cliConfig.inputFile) {
-        prompt = readFileSync28(cliConfig.inputFile, "utf-8");
+        prompt = readFileSync29(cliConfig.inputFile, "utf-8");
       }
       if (!prompt.trim()) {
         console.error("Error: --team requires a prompt (positional args or -f <file>)");
         process.exit(1);
       }
       const mode = cliConfig.teamMode ?? "default";
-      const sessionPath = join37(process.cwd(), `.claudish-team-${Date.now()}`);
+      const sessionPath = join38(process.cwd(), `.claudish-team-${Date.now()}`);
       if (mode === "json") {
         const { setupSession: setupSession2, runModels: runModels2 } = await Promise.resolve().then(() => (init_team_orchestrator(), exports_team_orchestrator));
         setupSession2(sessionPath, cliConfig.team, prompt);
@@ -77746,9 +79188,9 @@ async function runCli() {
         });
         const result = { ...status2, responses: {} };
         for (const anonId of Object.keys(status2.models)) {
-          const responsePath = join37(sessionPath, `response-${anonId}.md`);
+          const responsePath = join38(sessionPath, `response-${anonId}.md`);
           try {
-            const raw2 = readFileSync28(responsePath, "utf-8").trim();
+            const raw2 = readFileSync29(responsePath, "utf-8").trim();
             try {
               result.responses[anonId] = JSON.parse(raw2);
             } catch {