@namzu/cli 36.1.2 → 36.2.0

package/dist/chunks/{chunk-TJJUB7VQ.js → chunk-H7VJHF5S.js}

@@ -2,24 +2,24 @@ import { createRequire as __namzuCreateRequire } from 'node:module';
 const require = __namzuCreateRequire(import.meta.url);
 import {
   openManagedWorktrees
-} from "./chunk-GMCOZ3CU.js";
+} from "./chunk-PT7TZNBV.js";
 import {
   createBrowserControl
 } from "./chunk-WHODOMXA.js";
 import {
   connectMcpServers
-} from "./chunk-FXS3AG6B.js";
+} from "./chunk-HIZ7F6BT.js";
 import {
   createSessionSkillCatalog
-} from "./chunk-LQMHASKR.js";
+} from "./chunk-YTJO7G24.js";
 import {
   SAVE_SKILL_TOOL_NAME,
   readStoredTurnGuards,
   resolveTurnGuards
-} from "./chunk-PYG7DZ2D.js";
+} from "./chunk-L6FMG3R6.js";
 import {
   openInBrowser
-} from "./chunk-3P5PF6XE.js";
+} from "./chunk-XAKL7C7B.js";
 import {
   CredentialRefreshRejectedError,
   CredentialWithdrawnError,
@@ -27,7 +27,7 @@ import {
   ensureFreshStoredCodexCredential,
   readSubscriptionCredential,
   sameOAuthCredential
-} from "./chunk-4BZMQ2VD.js";
+} from "./chunk-HJ42RG5U.js";
 import {
   debugRequested
 } from "./chunk-GNBMKISG.js";
@@ -35,7 +35,7 @@ import {
   configuredPassthroughTools,
   resolveToolResultScreens,
   unmatchedPassthroughTools
-} from "./chunk-K76WV7TN.js";
+} from "./chunk-U5AWHJ7O.js";
 import {
   formatSize,
   homePath,
@@ -63,7 +63,7 @@ import {
   requiresCredentialForModel,
   resolveChainCapabilities,
   unresolvedMembers
-} from "./chunk-YXLD46UI.js";
+} from "./chunk-CFN7CUD3.js";
 import {
   PROVIDER_REGISTRY,
   missingCredentialMessage,
@@ -71,11 +71,11 @@ import {
 } from "./chunk-6LLJQ3KY.js";
 import {
   cliLogger
-} from "./chunk-HBBB2CAC.js";
+} from "./chunk-2VXA7GZU.js";
 import {
   isPermissionMode,
   permissionModeLabel
-} from "./chunk-5GRV6P5C.js";
+} from "./chunk-AGHVC2IJ.js";
 import {
   probeCapabilities
 } from "./chunk-OH6TB27S.js";
@@ -86,7 +86,7 @@ import {
 import {
   conversationLogPath,
   ensureSessionStarted
-} from "./chunk-TIGWWAJI.js";
+} from "./chunk-ABD2DOO2.js";
 import {
   INSTRUCTIONS_FILENAME,
   MAX_CHARS_PER_FILE,
@@ -96,13 +96,13 @@ import {
 } from "./chunk-H6B6AROX.js";
 import {
   ensurePrivateStateDirectory
-} from "./chunk-A5UXODFL.js";
+} from "./chunk-WW4VKEBD.js";
 import {
   restrictToOwner
-} from "./chunk-Q24K7536.js";
+} from "./chunk-QQLB573I.js";
 import {
   namzuHomePath
-} from "./chunk-NQY5P2EB.js";
+} from "./chunk-3OZ2OBGU.js";
 import {
   AgentManager,
   AgentRegistry,
@@ -111,6 +111,7 @@ import {
   CODING_AGENT_DELEGATION_DOCTRINE,
   CODING_AGENT_HYPERMODE_DOCTRINE,
   CODING_AGENT_WORKING_DOCTRINE,
+  COMPUTER_USE_TOOL_NAME,
   CompletionInbox,
   DefaultCapacityValidator,
   DiskMemoryStore,
@@ -190,6 +191,7 @@ import {
   discoverAgentDefinitions,
   discoverAllPluginDirs,
   ensureProject,
+  external_exports,
   filtered,
   generateSessionId,
   generateSummaryId,
@@ -230,7 +232,7 @@ import {
   webGuidanceContribution,
   withProviderFallback,
   wrapUntrusted
-} from "./chunk-EWKJGHRO.js";
+} from "./chunk-ZKTLXAQK.js";
 import {
   __name
 } from "./chunk-76FLAFCG.js";
@@ -2626,6 +2628,499 @@ function composeTurnSnapshot(snapshot) {
 }
 __name(composeTurnSnapshot, "composeTurnSnapshot");
 
+// ../decision/dist/contract.js
+var DecisionError = class extends Error {
+  static {
+    __name(this, "DecisionError");
+  }
+  status;
+  code;
+  constructor(message2, status, code) {
+    super(message2);
+    this.status = status;
+    this.code = code;
+    this.name = "DecisionError";
+  }
+};
+
+// ../decision/dist/drivers/wire.js
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+__name(isRecord, "isRecord");
+function numberRecord(v) {
+  const out = {};
+  if (isRecord(v)) {
+    for (const [k, val] of Object.entries(v))
+      if (typeof val === "number")
+        out[k] = val;
+  }
+  return out;
+}
+__name(numberRecord, "numberRecord");
+async function postDecision(post) {
+  const res = await post.fetch(post.url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...post.headers },
+    body: JSON.stringify(post.body),
+    signal: post.signal
+  });
+  let json;
+  try {
+    json = await res.json();
+  } catch {
+    json = void 0;
+  }
+  if (!res.ok) {
+    const err = isRecord(json) && isRecord(json.error) ? json.error : {};
+    throw new DecisionError(typeof err.message === "string" ? err.message : `Decision request failed (${res.status})`, res.status, typeof err.code === "string" ? err.code : void 0);
+  }
+  const answers = isRecord(json) ? json.answers : void 0;
+  return isRecord(answers) ? answers.q : void 0;
+}
+__name(postDecision, "postDecision");
+function yesnoQuestion(instructions) {
+  return { type: "noul", instructions };
+}
+__name(yesnoQuestion, "yesnoQuestion");
+function choiceQuestion(instructions, options) {
+  return { type: "choice", instructions, options: [...options] };
+}
+__name(choiceQuestion, "choiceQuestion");
+function scoreQuestion(instructions, levels2) {
+  return { type: "score", instructions, levels: [...levels2] };
+}
+__name(scoreQuestion, "scoreQuestion");
+function parseYesNo(answer) {
+  const noul = isRecord(answer) ? answer.noul : void 0;
+  if (typeof noul !== "number") {
+    throw new DecisionError('Decision response carried no "noul" probability');
+  }
+  return { p: noul };
+}
+__name(parseYesNo, "parseYesNo");
+function parseChoice(answer) {
+  const body = isRecord(answer) && isRecord(answer.choice) ? answer.choice : answer;
+  const probabilities = numberRecord(isRecord(body) ? body.probabilities : void 0);
+  let option = isRecord(body) ? body.option : void 0;
+  if (typeof option !== "string") {
+    option = Object.entries(probabilities).sort((a, b) => b[1] - a[1])[0]?.[0];
+  }
+  if (typeof option !== "string") {
+    throw new DecisionError('Decision response carried no "choice" answer');
+  }
+  return { option, probabilities };
+}
+__name(parseChoice, "parseChoice");
+function parseScore(answer) {
+  const body = isRecord(answer) && isRecord(answer.score) ? answer.score : answer;
+  const raw = isRecord(body) ? body : {};
+  const probabilities = Array.isArray(raw.probabilities) ? raw.probabilities.filter((x) => typeof x === "number") : [];
+  let level = raw.level;
+  if (typeof level !== "number") {
+    let best = -1;
+    probabilities.forEach((p, i) => {
+      if (best < 0 || p > (probabilities[best] ?? 0))
+        best = i;
+    });
+    level = best >= 0 ? best : void 0;
+  }
+  if (typeof level !== "number") {
+    throw new DecisionError('Decision response carried no "score" answer');
+  }
+  return { level, probabilities };
+}
+__name(parseScore, "parseScore");
+
+// ../decision/dist/drivers/azure-foundry.js
+var AzureFoundryDecisionModel = class {
+  static {
+    __name(this, "AzureFoundryDecisionModel");
+  }
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async yesno(state, instructions, opts) {
+    return parseYesNo(await this.ask(state, yesnoQuestion(instructions), opts));
+  }
+  async choice(state, instructions, options, opts) {
+    return parseChoice(await this.ask(state, choiceQuestion(instructions, options), opts));
+  }
+  async score(state, instructions, levels2, opts) {
+    return parseScore(await this.ask(state, scoreQuestion(instructions, levels2), opts));
+  }
+  async ask(state, question, opts) {
+    const token = await this.config.getToken();
+    return postDecision({
+      url: `${this.config.endpoint.replace(/\/$/, "")}/providers/microsoft/v1/systemone`,
+      headers: { Authorization: `Bearer ${token}` },
+      body: { model: this.config.deployment, state, questions: { q: question } },
+      fetch: this.config.fetch ?? globalThis.fetch,
+      ...opts?.signal ? { signal: opts.signal } : {}
+    });
+  }
+};
+
+// ../decision/dist/drivers/http.js
+var HttpDecisionModel = class {
+  static {
+    __name(this, "HttpDecisionModel");
+  }
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async yesno(state, instructions, opts) {
+    return parseYesNo(await this.ask(state, yesnoQuestion(instructions), opts));
+  }
+  async choice(state, instructions, options, opts) {
+    return parseChoice(await this.ask(state, choiceQuestion(instructions, options), opts));
+  }
+  async score(state, instructions, levels2, opts) {
+    return parseScore(await this.ask(state, scoreQuestion(instructions, levels2), opts));
+  }
+  async ask(state, question, opts) {
+    return postDecision({
+      url: this.config.url,
+      headers: {
+        ...this.config.apiKey ? { Authorization: `Bearer ${this.config.apiKey}` } : {},
+        ...this.config.headers
+      },
+      body: {
+        ...this.config.model ? { model: this.config.model } : {},
+        state,
+        questions: { q: question }
+      },
+      fetch: this.config.fetch ?? globalThis.fetch,
+      ...opts?.signal ? { signal: opts.signal } : {}
+    });
+  }
+};
+
+// ../decision/dist/create.js
+function createDecisionModel(config) {
+  switch (config.provider) {
+    case "azure":
+      return new AzureFoundryDecisionModel({
+        endpoint: config.endpoint,
+        deployment: config.deployment,
+        getToken: config.getToken,
+        ...config.fetch ? { fetch: config.fetch } : {}
+      });
+    case "http":
+      return new HttpDecisionModel({
+        url: config.url,
+        ...config.model ? { model: config.model } : {},
+        ...config.apiKey ? { apiKey: config.apiKey } : {},
+        ...config.headers ? { headers: config.headers } : {},
+        ...config.fetch ? { fetch: config.fetch } : {}
+      });
+    default: {
+      const unknown = config;
+      throw new Error(`Unknown decision provider: ${JSON.stringify(unknown.provider)}`);
+    }
+  }
+}
+__name(createDecisionModel, "createDecisionModel");
+
+// ../decision/dist/tool.js
+var DECIDE_TOOL_NAME = "decide";
+var inputSchema3 = external_exports.object({
+  kind: external_exports.enum(["yesno", "choice", "score"]).describe("yesno = probability a statement is true; choice = pick one of `options`; score = pick one of ordered `levels`."),
+  context: external_exports.string().describe("The situation to judge: the state, the evidence, whatever the decision turns on."),
+  question: external_exports.string().describe("What to decide, phrased for the chosen kind (a yes/no claim, a pick instruction, a scoring rubric)."),
+  options: external_exports.array(external_exports.string()).optional().describe('kind="choice" only: the options to pick exactly one of (2 or more).'),
+  levels: external_exports.array(external_exports.string()).optional().describe('kind="score" only: the ordered levels, lowest first (2 or more).')
+});
+function round(n) {
+  return n.toFixed(4);
+}
+__name(round, "round");
+function distribution(probabilities) {
+  return Object.entries(probabilities).sort((a, b) => b[1] - a[1]).map(([k, v]) => `${k}=${round(v)}`).join(", ");
+}
+__name(distribution, "distribution");
+var ADVISORY = "This is a fast, advisory System-1 judgment \u2014 you remain responsible for hard constraints; weigh low-confidence results with your own reasoning.";
+function createDecisionTool(model, options = {}) {
+  return defineTool({
+    name: options.name ?? DECIDE_TOOL_NAME,
+    description: "Ask a fast System-1 decision model for a typed judgment: a yes/no probability, a choice among options, or a score across ordered levels. Optional and advisory \u2014 reach for it when a quick, well-scoped classification, routing, safety pre-screen, element pick or ranking would help, then act on your own reasoning. If the model is unavailable the tool says so and you simply proceed.",
+    inputSchema: inputSchema3,
+    category: "analysis",
+    permissions: [],
+    readOnly: true,
+    destructive: false,
+    concurrencySafe: true,
+    async execute(input, context) {
+      const opts = context.abortSignal ? { signal: context.abortSignal } : void 0;
+      try {
+        if (input.kind === "yesno") {
+          const { p } = await model.yesno(input.context, input.question, opts);
+          return {
+            success: true,
+            output: `P(true) = ${round(p)}. ${ADVISORY}`,
+            data: { kind: "yesno", p }
+          };
+        }
+        if (input.kind === "choice") {
+          const choices = input.options ?? [];
+          if (choices.length < 2) {
+            return {
+              success: true,
+              output: "decide(choice) needs 2 or more `options`. None judged \u2014 decide with your own reasoning."
+            };
+          }
+          const { option, probabilities: probabilities2 } = await model.choice(input.context, input.question, choices, opts);
+          return {
+            success: true,
+            output: `Pick: ${option}  (${distribution(probabilities2)}). ${ADVISORY}`,
+            data: { kind: "choice", option, probabilities: probabilities2 }
+          };
+        }
+        const levels2 = input.levels ?? [];
+        if (levels2.length < 2) {
+          return {
+            success: true,
+            output: "decide(score) needs 2 or more `levels`. None judged \u2014 decide with your own reasoning."
+          };
+        }
+        const { level, probabilities } = await model.score(input.context, input.question, levels2, opts);
+        const name = levels2[level] ?? `level ${level}`;
+        return {
+          success: true,
+          output: `Score: ${name} (index ${level})  [${probabilities.map(round).join(", ")}]. ${ADVISORY}`,
+          data: { kind: "score", level, name, probabilities }
+        };
+      } catch (error) {
+        const why = error instanceof DecisionError ? error.message : String(error);
+        return {
+          success: true,
+          output: `The decision model is unavailable (${why}). Decide using your own reasoning; this tool is advisory only.`,
+          data: { kind: "unavailable", reason: why }
+        };
+      }
+    }
+  });
+}
+__name(createDecisionTool, "createDecisionTool");
+
+// src/integrations/decision/model.ts
+function buildDecisionProviderConfig(cfg, env) {
+  if (cfg.provider === "azure") {
+    return {
+      provider: "azure",
+      endpoint: cfg.endpoint,
+      deployment: cfg.deployment,
+      getToken: /* @__PURE__ */ __name(async () => env[cfg.tokenEnv ?? "AZURE_FOUNDRY_TOKEN"] ?? "", "getToken")
+    };
+  }
+  return {
+    provider: "http",
+    url: cfg.url,
+    ...cfg.model !== void 0 ? { model: cfg.model } : {},
+    ...cfg.apiKeyEnv ? { apiKey: env[cfg.apiKeyEnv] } : {}
+  };
+}
+__name(buildDecisionProviderConfig, "buildDecisionProviderConfig");
+function maybeCreateDecisionTool(cfg, env) {
+  if (!cfg) return void 0;
+  return createDecisionTool(createDecisionModel(buildDecisionProviderConfig(cfg, env)));
+}
+__name(maybeCreateDecisionTool, "maybeCreateDecisionTool");
+function maybeCreateDecisionModel(cfg, env) {
+  if (!cfg) return void 0;
+  return createDecisionModel(buildDecisionProviderConfig(cfg, env));
+}
+__name(maybeCreateDecisionModel, "maybeCreateDecisionModel");
+
+// src/integrations/decision/routing.ts
+var DEFAULT_ROUTING_TIMEOUT_MS = 1500;
+var DEFAULT_ROUTING_THRESHOLD = 0.7;
+var ROUTING_TASK_CHARS = 1500;
+var FAST_MAX_CONVERSATION = 40;
+var ROUTING_FAST_QUESTION = "Is this task simple enough for a small, fast model to complete correctly? Answer yes only for short chat, a lookup, or a single small step.";
+var ROUTING_BIG_QUESTION = "Does this task need deep multi-step reasoning or large-scale code changes across many files?";
+var ROUTING_SCORE_LEVELS = [
+  "trivial: chat, lookup, or one step",
+  "small: a single-file or single-tool task",
+  "medium: multi-step work across several files",
+  "large: open-ended, architectural, or long-horizon work"
+];
+function truncate(task) {
+  return task.length > ROUTING_TASK_CHARS ? task.slice(0, ROUTING_TASK_CHARS) : task;
+}
+__name(truncate, "truncate");
+function describeState(task, features) {
+  const facts = [];
+  if (features?.attachmentCount) facts.push(`attachments: ${features.attachmentCount}`);
+  if (features?.usesComputerUse) facts.push("drives the desktop");
+  if (features?.usesPal) facts.push("runs in a Pal");
+  if (features?.conversationLength) facts.push(`messages so far: ${features.conversationLength}`);
+  if (features?.voice) facts.push("spoken");
+  return facts.length > 0 ? `${truncate(task)}
+
+[${facts.join("; ")}]` : truncate(task);
+}
+__name(describeState, "describeState");
+function probability(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) {
+    throw new RangeError("malformed probability");
+  }
+  return value;
+}
+__name(probability, "probability");
+function massAtOrBelow(probabilities, last) {
+  const total = probabilities.reduce((sum, p) => sum + p, 0);
+  if (!(total > 0)) throw new RangeError("malformed probabilities");
+  return probabilities.slice(0, last + 1).reduce((sum, p) => sum + p, 0) / total;
+}
+__name(massAtOrBelow, "massAtOrBelow");
+var RouteInterrupted = class extends Error {
+  constructor(reason) {
+    super(reason);
+    this.reason = reason;
+  }
+  reason;
+  static {
+    __name(this, "RouteInterrupted");
+  }
+};
+async function withinBudget(run2, timeoutMs, outer) {
+  const controller = new AbortController();
+  let timer;
+  let onOuterAbort;
+  const interrupted = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      controller.abort();
+      reject(new RouteInterrupted("timeout"));
+    }, timeoutMs);
+    onOuterAbort = /* @__PURE__ */ __name(() => {
+      controller.abort();
+      reject(new RouteInterrupted("aborted"));
+    }, "onOuterAbort");
+    if (outer?.aborted) onOuterAbort();
+    else outer?.addEventListener("abort", onOuterAbort, { once: true });
+  });
+  try {
+    return await Promise.race([run2(controller.signal), interrupted]);
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+    if (onOuterAbort) outer?.removeEventListener("abort", onOuterAbort);
+  }
+}
+__name(withinBudget, "withinBudget");
+async function askOnce(call, signal) {
+  try {
+    return await call(signal);
+  } catch (err) {
+    if (signal.aborted) throw err;
+    return await call(signal);
+  }
+}
+__name(askOnce, "askOnce");
+async function routeModel(input, deps = {}) {
+  const now = deps.now ?? Date.now;
+  const started = now();
+  const { config } = input;
+  const result = /* @__PURE__ */ __name((tier, target, confidence, reason, error) => {
+    const routed = {
+      tier,
+      provider: target.provider,
+      model: target.model,
+      confidence,
+      reason
+    };
+    try {
+      deps.logger?.debug("auto model routed", {
+        "namzu.routing.tier": tier,
+        "namzu.routing.reason": reason,
+        "namzu.routing.confidence": confidence,
+        "namzu.routing.duration_ms": Math.max(0, now() - started),
+        "gen_ai.request.model": target.model,
+        "namzu.provider.id": target.provider,
+        // The class of what made it fall back, never its message: that can carry an endpoint.
+        ...error instanceof Error ? { "error.type": error.name } : {}
+      });
+    } catch {
+    }
+    return routed;
+  }, "result");
+  const fallback = /* @__PURE__ */ __name((reason, error) => result("default", config.default, 0, reason, error), "fallback");
+  try {
+    if (input.pin) return result("default", input.pin, 1, "pinned");
+    const usable = /* @__PURE__ */ __name((target) => target && (deps.isAvailable?.(target) ?? true) ? target : void 0, "usable");
+    const features = input.features;
+    const failedOn = features?.previousTurnFailedOnTier;
+    const big = usable(config.tiers?.big);
+    const fastBarred = features?.usesComputerUse === true || features?.usesPal === true || (features?.attachmentCount ?? 0) > 0 || (features?.conversationLength ?? 0) > FAST_MAX_CONVERSATION || failedOn === "fast" || failedOn === "default";
+    const fast = fastBarred ? void 0 : usable(config.tiers?.fast);
+    if (failedOn === "fast") return result("default", config.default, 1, "escalated-after-failure");
+    if (failedOn === "default") {
+      return big ? result("big", big, 1, "escalated-after-failure") : fallback("failed-no-bigger-tier");
+    }
+    if (!fast && !big) return fallback(fastBarred ? "fast-tier-barred" : "no-tier-available");
+    if (!deps.model) return fallback("no-decision-model");
+    const model = deps.model;
+    const timeoutMs = config.timeoutMs ?? DEFAULT_ROUTING_TIMEOUT_MS;
+    const fastThreshold = config.thresholds?.fast ?? DEFAULT_ROUTING_THRESHOLD;
+    const bigThreshold = config.thresholds?.big ?? DEFAULT_ROUTING_THRESHOLD;
+    const state = describeState(input.task, features);
+    let pFast;
+    let pBig;
+    if (config.strategy === "score") {
+      const decision = await withinBudget(
+        (signal) => askOnce(
+          (inner) => model.score(state, "", ROUTING_SCORE_LEVELS, { signal: inner }),
+          signal
+        ),
+        timeoutMs,
+        input.signal
+      );
+      const { probabilities } = decision;
+      if (!Array.isArray(probabilities) || probabilities.length !== ROUTING_SCORE_LEVELS.length) {
+        throw new RangeError("malformed probabilities");
+      }
+      for (const p of probabilities) probability(p);
+      if (fast) pFast = massAtOrBelow(probabilities, 1);
+      if (big) pBig = 1 - massAtOrBelow(probabilities, 2);
+    } else {
+      const [fastDecision, bigDecision] = await withinBudget(
+        (signal) => Promise.all([
+          fast ? askOnce(
+            (inner) => model.yesno(state, ROUTING_FAST_QUESTION, { signal: inner }),
+            signal
+          ) : Promise.resolve(void 0),
+          big ? askOnce(
+            (inner) => model.yesno(state, ROUTING_BIG_QUESTION, { signal: inner }),
+            signal
+          ) : Promise.resolve(void 0)
+        ]),
+        timeoutMs,
+        input.signal
+      );
+      if (fastDecision) pFast = probability(fastDecision.p);
+      if (bigDecision) pBig = probability(bigDecision.p);
+    }
+    const wantsFast = fast !== void 0 && pFast !== void 0 && pFast >= fastThreshold;
+    const wantsBig = big !== void 0 && pBig !== void 0 && pBig >= bigThreshold;
+    if (wantsFast && wantsBig) return fallback("contradictory-decision");
+    if (wantsFast && fast) return result("fast", fast, pFast ?? 0, "simple-task");
+    if (wantsBig && big) return result("big", big, pBig ?? 0, "demanding-task");
+    const leaning = Math.max(pFast ?? 0, pBig ?? 0);
+    return result("default", config.default, Math.max(0, 1 - leaning), "ordinary-task");
+  } catch (err) {
+    if (err instanceof RouteInterrupted) return fallback(err.reason);
+    if (err instanceof RangeError) return fallback("malformed-decision", err);
+    return fallback("decision-unavailable", err);
+  }
+}
+__name(routeModel, "routeModel");
+function resolveAutoDefault(config, isAvailable) {
+  return isAvailable(config.default) ? config.default : void 0;
+}
+__name(resolveAutoDefault, "resolveAutoDefault");
+
 // src/integrations/plugins/settings.ts
 import { createHash as createHash3, randomUUID as randomUUID3 } from "node:crypto";
 import {
@@ -7865,10 +8360,10 @@ function clipRequestContext(prompt, limit, kind) {
 __name(clipRequestContext, "clipRequestContext");
 async function createAgentSession(prefs, detected, options = {}) {
   if (options.palEnvironment) {
-    const { createPalAgentSession } = await import("./agent-session-UNUZAMRW.js");
+    const { createPalAgentSession } = await import("./agent-session-C2HDOXK4.js");
     return createPalAgentSession(prefs, detected, options);
   }
-  const { palAtWorkspace } = await import("./store-GDP2EW27.js");
+  const { palAtWorkspace } = await import("./store-2PDDGKYZ.js");
   if (palAtWorkspace(options.cwd ?? process.cwd()))
     throw new Error("This Pal requires its owned virtual computer. Open it with namzu pal chat.");
   const fileObservations = /* @__PURE__ */ new Map();
@@ -8167,6 +8662,8 @@ async function createAgentSession(prefs, detected, options = {}) {
     }
     return readCurrentAuxiliaryCredential(found, signal);
   }, "currentCredentialFor");
+  let turnRouteTarget;
+  let lastAutoRoute;
   const providerForSession = /* @__PURE__ */ __name((sessionId) => primary.id === "zen" || primary.id === "zen-go" ? constructProvider(primary.id, det, model, { sessionId }) : provider, "providerForSession");
   const projectInstructions = new ProjectInstructionTracker(cwd);
   let sandbox;
@@ -8393,9 +8890,10 @@ async function createAgentSession(prefs, detected, options = {}) {
   const nativeSearchAvailable = provider.capabilities?.supportsHostedWebSearch === true && !options.structuredOutput && (provider.supportsHostedWebSearchFor?.(
     model,
     options.web?.search === "cached" ? "cached" : "live"
-  ) ?? true) && prefs.providers.length === 1;
+  ) ?? true) && prefs.providers.length === 1 && !options.routing;
   const webSearch = resolveWebSearch(options.web, nativeSearchAvailable);
   const nativeWebSearch = webSearch.mode !== "off" && webSearch.backend === "native" ? { mode: webSearch.mode } : void 0;
+  const routedWebSearch = /* @__PURE__ */ __name((routed) => nativeWebSearch && routed.provider.capabilities?.supportsHostedWebSearch === true && (routed.provider.supportsHostedWebSearchFor?.(routed.model, nativeWebSearch.mode) ?? true) ? nativeWebSearch : void 0, "routedWebSearch");
   let webSearchTool;
   if (webSearch.mode !== "off" && webSearch.backend === "exa") {
     webSearchTool = createWebSearchTool();
@@ -8607,8 +9105,8 @@ async function createAgentSession(prefs, detected, options = {}) {
         });
       }, "listModels"),
       buildProvider: /* @__PURE__ */ __name(async (invokingSessionId, selection) => {
-        const providerId = selection ? selection.provider : primary.id;
-        const selectedModel = selection?.model ?? model;
+        const providerId = selection ? selection.provider : turnRouteTarget?.provider ?? primary.id;
+        const selectedModel = selection?.model ?? turnRouteTarget?.model ?? model;
         if (!invokingSessionId && (providerId === "zen" || providerId === "zen-go"))
           throw new Error("A delegated provider requires its invoking conversation.");
         await ensureRegistered(providerId);
@@ -8723,7 +9221,9 @@ async function createAgentSession(prefs, detected, options = {}) {
     toolsets.push(toolset("extra", options.extraTools));
   }
   if (options.openUrl) toolsets.push(toolset("open-url", [createOpenUrlTool()]));
-  const operatorPals = await import("./operator-tools-LTPV3CH5.js");
+  const decisionTool = maybeCreateDecisionTool(options.decision, process.env);
+  if (decisionTool) toolsets.push(toolset("decide", [decisionTool]));
+  const operatorPals = await import("./operator-tools-GI63VOXH.js");
   toolsets.push(
     readyWhen(
       toolset(
@@ -8914,6 +9414,58 @@ async function createAgentSession(prefs, detected, options = {}) {
       ...effort ? { effort } : {}
     };
   }, "pinnedResumeRoute");
+  const routingDecisionModel = options.routing ? maybeCreateDecisionModel(options.decision, process.env) : void 0;
+  const autoRouteFor = /* @__PURE__ */ __name(async (messages, sessionId, signal) => {
+    const routing = options.routing;
+    if (!routing) return void 0;
+    try {
+      const routed = await routeModel(
+        {
+          task: lastUserText(messages),
+          config: routing,
+          features: {
+            conversationLength: messages.length,
+            // Mounted is not used: the tool is on in every interactive session,
+            // so only a conversation that has driven the desktop keeps the small
+            // tier out.
+            usesComputerUse: options.enableComputerUse === true && conversationDrovePc(messages),
+            usesPal: false
+          },
+          signal
+        },
+        {
+          ...routingDecisionModel ? { model: routingDecisionModel } : {},
+          isAvailable: /* @__PURE__ */ __name((target) => {
+            const found = findDetected(detected, target.provider);
+            if (!found) return false;
+            return found.entry.constructible && canSelectModel(found.entry, found.apiKey, target.model);
+          }, "isAvailable"),
+          logger: cliLogger()
+        }
+      );
+      lastAutoRoute = { tier: routed.tier, model: routed.model };
+      if (routed.provider === primary.id && routed.model === model) {
+        turnRouteTarget = void 0;
+        return void 0;
+      }
+      const route = await pinnedResumeRoute(
+        { provider: routed.provider, model: routed.model },
+        sessionId,
+        signal
+      );
+      turnRouteTarget = route ? { provider: routed.provider, model: route.model } : void 0;
+      return route;
+    } catch (err) {
+      signal.throwIfAborted();
+      turnRouteTarget = void 0;
+      lastAutoRoute = void 0;
+      cliLogger().warn(
+        "auto model routing failed, using the session model",
+        exceptionAttributes(err)
+      );
+      return void 0;
+    }
+  }, "autoRouteFor");
   const kernelResume = /* @__PURE__ */ __name(({
     entry: entry2,
     sessionLog,
@@ -8935,6 +9487,7 @@ async function createAgentSession(prefs, detected, options = {}) {
     const resumedLimits = await readStoredTurnGuards(sessionLog, entry2.turnId) ?? resolveTurnGuards(options.limits);
     await prepareProviderCredential(ownedSignal);
     const route = await pinnedResumeRoute(pinned, entry2.sessionId, ownedSignal);
+    const resumeWebSearch = route ? routedWebSearch(route) : nativeWebSearch;
     const turnSkills = await turnSkillsFor(route?.model ?? model);
     const curatedMemory = readMemory(void 0, cwd);
     for (const notice of formatMemoryDiagnostics(curatedMemory)) cliLogger().warn(notice);
@@ -9054,7 +9607,7 @@ async function createAgentSession(prefs, detected, options = {}) {
         turnConfig: {
           model: route?.model ?? model,
           ...route?.effort ? { effort: route.effort } : {},
-          ...nativeWebSearch ? { webSearch: nativeWebSearch } : {},
+          ...resumeWebSearch ? { webSearch: resumeWebSearch } : {},
           ...sandbox.provider ? { sandbox: { workspace: sandboxWorkspace } } : {},
           ...resumedLimits,
           maxResponseTokens: 8192,
@@ -9201,6 +9754,9 @@ async function createAgentSession(prefs, detected, options = {}) {
     },
     providerSummary: entry.label,
     modelSummary: model,
+    get autoRoute() {
+      return lastAutoRoute;
+    },
     get imageAttachmentsSupported() {
       return providerForSession(scope.sessionId).capabilities?.supportsVision;
     },
@@ -9537,7 +10093,9 @@ async function createAgentSession(prefs, detected, options = {}) {
         }, "claimTurn");
         try {
           await prepareProviderCredential(signal);
-          const turnSkills = await turnSkillsFor(model);
+          const autoRoute = await autoRouteFor(messages, turnScope.sessionId, signal);
+          const turnWebSearch = autoRoute ? routedWebSearch(autoRoute) : nativeWebSearch;
+          const turnSkills = await turnSkillsFor(autoRoute?.model ?? model);
           const curatedMemory = readMemory(void 0, cwd);
           for (const notice of formatMemoryDiagnostics(curatedMemory)) {
             yield { kind: "context", text: notice, shed: false };
@@ -9700,7 +10258,7 @@ async function createAgentSession(prefs, detected, options = {}) {
           }
           try {
             for await (const event of runTurn({
-              provider: providerForSession(turnScope.sessionId),
+              provider: autoRoute?.provider ?? providerForSession(turnScope.sessionId),
               fileReadTracker: await observationsFor(turnScope.sessionId, messages),
               compactionConfig: compactionConfigFor(options.compaction),
               retainedToolPreviewChars: options.conversationSessions ? options.compaction?.retainedToolPreviewChars ?? 4e3 : void 0,
@@ -9716,8 +10274,9 @@ async function createAgentSession(prefs, detected, options = {}) {
               // that expired hours ago — and a chain whose own members are stale
               // is a fallback that fails for the reason the fallback exists to
               // survive. Building a driver is a client object, not a request.
-              fallbackProviders: fallbackPlan.build(currentToken, turnScope.sessionId),
-              model,
+              // A routed turn has no fallback chain, like a pinned resume.
+              fallbackProviders: autoRoute ? [] : fallbackPlan.build(currentToken, turnScope.sessionId),
+              model: autoRoute?.model ?? model,
               toolsets: runToolsets,
               ...screensConfig !== void 0 ? { toolResultGuardrails: screensConfig } : {},
               pluginManager: pluginRuntime?.manager,
@@ -9769,7 +10328,7 @@ async function createAgentSession(prefs, detected, options = {}) {
               completionInbox: await subagentRuntime?.completionInboxForTurn(turnId),
               promptContributions,
               ...webCapability ? { web: webCapability } : {},
-              ...nativeWebSearch ? { webSearch: nativeWebSearch } : {},
+              ...turnWebSearch ? { webSearch: turnWebSearch } : {},
               // Tasks join this turn's registry inside query, after the fork.
               // Keep the existing eager path unless deferral was requested.
               runtimeToolOverrides: {
@@ -10153,6 +10712,16 @@ async function listProviderModels(id, det) {
   return listing.kind === "ok" ? [...listing.models] : [];
 }
 __name(listProviderModels, "listProviderModels");
+var DESKTOP_USE_LOOKBACK = 20;
+function conversationDrovePc(messages) {
+  for (let i = messages.length - 1; i >= 0 && i >= messages.length - DESKTOP_USE_LOOKBACK; i--) {
+    const m = messages[i];
+    if (m?.role === "assistant" && m.toolCalls?.some((call) => call.function.name === COMPUTER_USE_TOOL_NAME))
+      return true;
+  }
+  return false;
+}
+__name(conversationDrovePc, "conversationDrovePc");
 function lastUserText(messages) {
   for (let i = messages.length - 1; i >= 0; i--) {
     const m = messages[i];
@@ -10844,29 +11413,29 @@ __name(takeCallDiff, "takeCallDiff");
 function viewToSummary(view) {
   switch (view.kind) {
     case "generic":
-      return truncate(view.label, 120);
+      return truncate2(view.label, 120);
     case "diff":
-      return truncate(view.label ?? view.path ?? view.after.split("\n")[0] ?? "", 120);
+      return truncate2(view.label ?? view.path ?? view.after.split("\n")[0] ?? "", 120);
     case "terminal":
-      return truncate(view.command ?? view.output.split("\n")[0] ?? "", 120);
+      return truncate2(view.command ?? view.output.split("\n")[0] ?? "", 120);
   }
 }
 __name(viewToSummary, "viewToSummary");
 var RESULT_SUMMARY_WHOLE_MAX = 300;
 function resultSummaryLine(line) {
   const flat = line.replace(/\s+/g, " ");
-  return flat.length <= RESULT_SUMMARY_WHOLE_MAX ? flat : truncate(line, 120);
+  return flat.length <= RESULT_SUMMARY_WHOLE_MAX ? flat : truncate2(line, 120);
 }
 __name(resultSummaryLine, "resultSummaryLine");
 function summarySaysAll(line, summary) {
   return line === summary || line.replace(/\s+/g, " ") === summary;
 }
 __name(summarySaysAll, "summarySaysAll");
-function truncate(value, max) {
+function truncate2(value, max) {
   const oneLine3 = value.replace(/\s+/g, " ");
   return oneLine3.length > max ? `${oneLine3.slice(0, max - 1)}\u2026` : oneLine3;
 }
-__name(truncate, "truncate");
+__name(truncate2, "truncate");
 function diffContentLines(value) {
   if (value === "") return [];
   const lines = value.split("\n");
@@ -10913,16 +11482,16 @@ __name(resultToLines, "resultToLines");
 function firstLine3(result) {
   const payload = payloadString(result);
   if (payload !== null) {
-    return truncate(payload.split("\n").find((l) => l.trim().length > 0) ?? "", 120);
+    return truncate2(payload.split("\n").find((l) => l.trim().length > 0) ?? "", 120);
   }
   const obj = parseJsonObject(result);
   if (obj) {
-    if (obj.success === false && typeof obj.error === "string") return truncate(obj.error, 120);
+    if (obj.success === false && typeof obj.error === "string") return truncate2(obj.error, 120);
     const keys = Object.keys(obj);
     return keys.length > 0 ? `{ ${keys.slice(0, 6).join(", ")}${keys.length > 6 ? ", \u2026" : ""} }` : "{}";
   }
   const cleaned = cleanToolText(result.trim());
-  return truncate(cleaned.split("\n").find((l) => l.trim().length > 0) ?? "", 120);
+  return truncate2(cleaned.split("\n").find((l) => l.trim().length > 0) ?? "", 120);
 }
 __name(firstLine3, "firstLine");
 function exceptionAttributes(err) {
@@ -11053,6 +11622,8 @@ export {
   renderRestoreNote,
   PluginSettingsStore,
   validateComposerSendSettings,
+  maybeCreateDecisionTool,
+  resolveAutoDefault,
   createCurrentCredentialReader,
   createTaskContextStep,
   createLiveModeControl,
@@ -11094,6 +11665,7 @@ export {
   computerUseHasControl,
   isCredentialRejection,
   listProviderModels,
+  conversationDrovePc,
   makeResumeHandler,
   makeHoldingResumeHandler,
   isPromptExempt,
@@ -11108,4 +11680,4 @@ export {
   RESULT_SUMMARY_WHOLE_MAX,
   resultSummaryLine
 };
-//# sourceMappingURL=chunk-TJJUB7VQ.js.map
+//# sourceMappingURL=chunk-H7VJHF5S.js.map