@ycodium-ai/agent-claude 0.2.2678 → 0.2.2694

package/dist/index.js

@@ -217,7 +217,7 @@ var CLAUDE_CARD = {
 
 // src/claudeInstance.ts
 import * as NodeOS8 from "node:os";
-import * as NodePath8 from "node:path";
+import * as NodePath13 from "node:path";
 
 // ../../node_modules/.pnpm/@anthropic-ai+claude-agent-sdk@0.3.170_@anthropic-ai+sdk@0.93.0_zod@4.6.5__@modelcontex_64204813d4dba2ebc464c3aa751485a4/node_modules/@anthropic-ai/claude-agent-sdk/sdk.mjs
 import { createRequire as xz } from "node:module";
@@ -19650,10 +19650,12 @@ function HU(e, t) {
 }
 
 // src/claudeInstance.ts
+import { mergeLaunchEnv as mergeLaunchEnv3 } from "@ycodium-ai/plugin-api/executor";
+
+// src/claudeProbe.ts
 import {
   describeExecutorSpawnFailure,
-  ExecutorSpawnRefusedError,
-  mergeLaunchEnv as mergeLaunchEnv2
+  ExecutorSpawnRefusedError
 } from "@ycodium-ai/plugin-api/executor";
 
 // src/claudeAccount.ts
@@ -19743,78 +19745,73 @@ function readClaudeAccount(credentialsDirPath) {
   };
 }
 
-// src/claudeExecutable.ts
-import * as NodeFS2 from "node:fs";
-import * as NodeOS2 from "node:os";
-import * as NodePath2 from "node:path";
-var WINDOWS_SHIM_EXTENSIONS = /* @__PURE__ */ new Set([".cmd", ".bat", ".ps1"]);
-var NPM_PACKAGE_ENTRY_CANDIDATES = [
-  ["node_modules", "@anthropic-ai", "claude-code", "bin", "claude.exe"],
-  ["node_modules", "@anthropic-ai", "claude-code", "cli.js"]
-];
-function isExistingFile(filePath) {
-  try {
-    return NodeFS2.statSync(filePath).isFile();
-  } catch {
-    return false;
-  }
-}
-function resolveClaudeSdkExecutablePath(binaryPath, environment = process.env, isFile = isExistingFile, isWindows = NodeOS2.type() === "Windows_NT") {
-  if (!isWindows) {
-    return binaryPath;
-  }
-  const resolved = resolveWindowsExecutable(binaryPath, environment) ?? binaryPath;
-  const extension = NodePath2.win32.extname(resolved).toLowerCase();
-  if (!WINDOWS_SHIM_EXTENSIONS.has(extension)) {
-    return resolved;
-  }
-  const shimDirectory = NodePath2.win32.dirname(resolved);
-  for (const entrySegments of NPM_PACKAGE_ENTRY_CANDIDATES) {
-    const candidate = NodePath2.win32.join(shimDirectory, ...entrySegments);
-    if (isFile(candidate)) {
-      return candidate;
-    }
-  }
-  return binaryPath;
-}
-function resolveWindowsExecutable(binaryPath, environment) {
-  const trimmed = binaryPath.trim();
-  if (trimmed.length === 0) return void 0;
-  if (NodePath2.win32.isAbsolute(trimmed) && isExistingFile(trimmed)) return trimmed;
-  const pathValue = environment.PATH ?? environment.Path ?? "";
-  const pathext = environment.PATHEXT ?? ".EXE;.CMD;.BAT;.COM";
-  const extensions = pathext.split(";").filter((ext) => ext.length > 0);
-  const hasExt = NodePath2.win32.extname(trimmed).length > 0;
-  for (const dir of pathValue.split(";")) {
-    if (dir.trim().length === 0) continue;
-    const candidates = hasExt ? [NodePath2.win32.join(dir, trimmed)] : extensions.map((ext) => NodePath2.win32.join(dir, `${trimmed}${ext}`));
-    for (const candidate of candidates) {
-      if (isExistingFile(candidate)) return candidate;
-    }
-  }
-  return void 0;
-}
-
 // src/claudeHome.ts
-import * as NodeOS4 from "node:os";
-import * as NodePath4 from "node:path";
-
-// src/pathExpansion.ts
 import * as NodeOS3 from "node:os";
 import * as NodePath3 from "node:path";
+
+// src/pathExpansion.ts
+import * as NodeOS2 from "node:os";
+import * as NodePath2 from "node:path";
 function expandHomePath(value) {
-  if (value === "~") return NodeOS3.homedir();
+  if (value === "~") return NodeOS2.homedir();
   if (value.startsWith("~/") || value.startsWith("~\\")) {
-    return NodePath3.join(NodeOS3.homedir(), value.slice(2));
+    return NodePath2.join(NodeOS2.homedir(), value.slice(2));
   }
   return value;
 }
 
+// src/usageLimit.ts
+var WINDOW_NAMES = {
+  five_hour: "5-hour",
+  seven_day: "7-day",
+  seven_day_opus: "7-day Opus",
+  seven_day_sonnet: "7-day Sonnet",
+  overage: "overage"
+};
+var MAX_CREDIBLE_WAIT_MS = 30 * 24 * 60 * 60 * 1e3;
+var isBlockingRateLimit = (info) => info.status === "rejected" && info.overageStatus !== "allowed" && info.overageStatus !== "allowed_warning" && info.isUsingOverage !== true && info.overageInUse !== true;
+var isClearingRateLimit = (info) => info.status === "allowed" || info.status === "allowed_warning" || info.overageStatus === "allowed" || info.overageStatus === "allowed_warning" || info.isUsingOverage === true || info.overageInUse === true;
+var rateLimitKey = (info) => `${info.rateLimitType ?? "unknown"}:${String(info.resetsAt ?? "unknown")}`;
+var formatLimitWait = (waitMs) => {
+  const totalMinutes = Math.max(1, Math.ceil(waitMs / 6e4));
+  const days = Math.floor(totalMinutes / (24 * 60));
+  const hours = Math.floor(totalMinutes % (24 * 60) / 60);
+  const minutes = totalMinutes % 60;
+  if (days > 0) return hours === 0 ? `${String(days)}d` : `${String(days)}d ${String(hours)}h`;
+  if (hours === 0) return `${String(totalMinutes)}m`;
+  return minutes === 0 ? `${String(hours)}h` : `${String(hours)}h ${String(minutes)}m`;
+};
+var waitUntil = (resetsAtSeconds, nowMs) => {
+  if (resetsAtSeconds === void 0 || !Number.isFinite(nowMs)) return void 0;
+  const waitMs = resetsAtSeconds * 1e3 - nowMs;
+  return waitMs > 0 && waitMs <= MAX_CREDIBLE_WAIT_MS ? formatLimitWait(waitMs) : void 0;
+};
+var describeUsageLimitPause = (info, nowMs) => {
+  const name = info.rateLimitType === void 0 ? void 0 : WINDOW_NAMES[info.rateLimitType];
+  const wait = waitUntil(info.resetsAt, nowMs);
+  return `Claude usage limit reached. This turn is paused until the ${name === void 0 ? "" : `${name} `}limit resets${wait === void 0 ? "" : ` in ${wait}`}.`;
+};
+var describeUsageLimitFailure = (rejected, nowMs) => {
+  let name;
+  let wait;
+  let latestResetSeconds = Number.NEGATIVE_INFINITY;
+  for (const [type4, resetsAt] of rejected) {
+    const label = WINDOW_NAMES[type4];
+    const reachable = waitUntil(resetsAt, nowMs);
+    if (label === void 0 || reachable === void 0 || resetsAt === void 0) continue;
+    if (resetsAt <= latestResetSeconds) continue;
+    latestResetSeconds = resetsAt;
+    name = label;
+    wait = reachable;
+  }
+  return name === void 0 ? "Claude usage limit reached. Send the message again once the limit resets." : `Claude usage limit reached. The ${name} limit resets in ${wait}. Send the message again once it resets.`;
+};
+
 // src/claudeHome.ts
 var CLAUDE_CREDENTIALS_DIR_ENVIRONMENT_VARIABLE = "CLAUDE_SECURESTORAGE_CONFIG_DIR";
 function resolveClaudeHomePath(homePath) {
   const trimmed = homePath.trim();
-  return NodePath4.resolve(trimmed.length > 0 ? expandHomePath(trimmed) : NodeOS4.homedir());
+  return NodePath3.resolve(trimmed.length > 0 ? expandHomePath(trimmed) : NodeOS3.homedir());
 }
 function claudeContinuationKey(homePath) {
   return `claude:home:${resolveClaudeHomePath(homePath)}`;
@@ -19822,18 +19819,18 @@ function claudeContinuationKey(homePath) {
 function resolveClaudeConfigDirPath(homePath, environment, cwd) {
   const trimmed = homePath.trim();
   if (trimmed.length > 0) {
-    return NodePath4.resolve(expandHomePath(trimmed));
+    return NodePath3.resolve(expandHomePath(trimmed));
   }
   const environmentConfigDir = environment.CLAUDE_CONFIG_DIR?.trim() ?? "";
   if (environmentConfigDir.length > 0) {
-    return cwd ? NodePath4.resolve(cwd, environmentConfigDir) : NodePath4.resolve(environmentConfigDir);
+    return cwd ? NodePath3.resolve(cwd, environmentConfigDir) : NodePath3.resolve(environmentConfigDir);
   }
-  return NodePath4.join(NodeOS4.homedir(), ".claude");
+  return NodePath3.join(NodeOS3.homedir(), ".claude");
 }
 function resolveClaudeCredentialsDirPath(credentialsPath) {
   const trimmed = credentialsPath.trim();
   if (trimmed.length === 0) return null;
-  return NodePath4.resolve(expandHomePath(trimmed));
+  return NodePath3.resolve(expandHomePath(trimmed));
 }
 function resolveClaudeHomeLayout(input) {
   return {
@@ -19864,13 +19861,13 @@ function claudeSignedOutMessage(input) {
   const configDir = input.configDir?.trim() ?? "";
   if (configDir.length > 0) {
     variables.push(
-      `CLAUDE_CONFIG_DIR set to ${quoteLiteral(NodePath4.resolve(input.cwd, configDir))}`
+      `CLAUDE_CONFIG_DIR set to ${quoteLiteral(NodePath3.resolve(input.cwd, configDir))}`
     );
   }
   const credentialsDir = input.credentialsDir?.trim() ?? "";
   if (credentialsDir.length > 0) {
     variables.push(
-      `${CLAUDE_CREDENTIALS_DIR_ENVIRONMENT_VARIABLE} set to ${quoteLiteral(NodePath4.resolve(input.cwd, credentialsDir))}`
+      `${CLAUDE_CREDENTIALS_DIR_ENVIRONMENT_VARIABLE} set to ${quoteLiteral(NodePath3.resolve(input.cwd, credentialsDir))}`
     );
   }
   const withVariables = variables.length > 0 ? `, with ${variables.join(" and ")}` : "";
@@ -19884,34 +19881,37 @@ function claudeFailureHint(input) {
       cwd: input.cwd
     });
   }
+  const limit = input.usageLimit;
+  if (limit !== void 0 && (limit.rejected.size > 0 || limit.latestAssistantRateLimited)) {
+    return describeUsageLimitFailure(limit.rejected, limit.nowMs);
+  }
   return void 0;
 }
 
-// src/claudeSignIn.ts
-var POSIX_BARE_VALUE = /^[A-Za-z0-9_@%+=:,./-]+$/;
-function quotePosixShellValue(value) {
-  if (POSIX_BARE_VALUE.test(value)) return value;
-  return `'${value.replaceAll("'", `'\\''`)}'`;
-}
-function quotePowerShellValue(value) {
-  return `'${value.replaceAll("'", "''")}'`;
-}
-function withClaudeCredentialsDir(input) {
-  const variable = CLAUDE_CREDENTIALS_DIR_ENVIRONMENT_VARIABLE;
-  return input.platform === "win32" ? `$env:${variable}=${quotePowerShellValue(input.credentialsDirPath)}; ${input.command}` : `${variable}=${quotePosixShellValue(input.credentialsDirPath)} ${input.command}`;
-}
-function claudeSignInCommand(credentialsPath, platform) {
-  const command = "claude auth login";
-  const credentialsDirPath = resolveClaudeCredentialsDirPath(credentialsPath);
-  if (credentialsDirPath === null) return command;
-  return withClaudeCredentialsDir({ command, credentialsDirPath, platform });
-}
-
 // src/claudeSkills.ts
 import * as NodeFSP from "node:fs/promises";
-import * as NodePath5 from "node:path";
-var FRONT_MATTER_KEY = /^(name|description):[ \t]*(.*)$/;
+import * as NodePath4 from "node:path";
+import * as NodeProcess from "node:process";
+var FRONT_MATTER_KEY = /^(description|disable-model-invocation|user-invocable|argument-hint):[ \t]*(.*)$/;
 var BLOCK_SCALAR = /^[|>][+-]?$/;
+function parseFrontMatterBoolean(value) {
+  switch (value?.trim().toLowerCase()) {
+    case "true":
+    case "yes":
+    case "on":
+    case "y":
+    case "1":
+      return true;
+    case "false":
+    case "no":
+    case "off":
+    case "n":
+    case "0":
+      return false;
+    default:
+      return void 0;
+  }
+}
 function parseSkillFrontMatter(contents) {
   const lines = contents.split(/\r?\n/);
   if (lines[0]?.trim() !== "---") return {};
@@ -19933,149 +19933,852 @@ function parseSkillFrontMatter(contents) {
       }
       value = block.join(value.startsWith("|") ? "\n" : " ");
     } else {
+      if (key !== "description" && key !== "argument-hint") value = value.replace(/\s+#.*$/, "");
       value = value.replace(/^(["'])(.*)\1$/, "$2").trim();
     }
     if (value.length > 0 && values[key] === void 0) values[key] = value;
   }
-  return values;
+  const description = values["description"];
+  const argumentHint = values["argument-hint"];
+  return {
+    ...description === void 0 ? {} : { description },
+    ...argumentHint === void 0 ? {} : { argumentHint },
+    ...parseFrontMatterBoolean(values["disable-model-invocation"]) === true ? { userInvocationOnly: true } : {},
+    ...parseFrontMatterBoolean(values["user-invocable"]) === false ? { userInvocable: false } : {}
+  };
 }
-async function discoverClaudeSkills(configDirPath) {
-  const root = NodePath5.join(configDirPath, "skills");
-  const entries = await NodeFSP.readdir(root).catch(() => []);
-  const skills = /* @__PURE__ */ new Map();
-  for (const entry of entries.toSorted()) {
-    const skillPath = NodePath5.join(root, entry, "SKILL.md");
-    const contents = await NodeFSP.readFile(skillPath, "utf8").catch(() => void 0);
-    if (contents === void 0) continue;
-    const frontMatter = parseSkillFrontMatter(contents);
-    const name = frontMatter.name ?? entry.trim();
-    if (name.length === 0) continue;
-    skills.set(name, {
-      name,
-      path: skillPath,
-      enabled: true,
-      scope: "user",
-      ...frontMatter.description === void 0 ? {} : { description: frontMatter.description }
-    });
+function claudeManagedSettingsPath(platform2, environment) {
+  if (platform2 === "darwin") {
+    return "/Library/Application Support/ClaudeCode/managed-settings.json";
   }
-  return [...skills.values()].toSorted((left, right) => left.name.localeCompare(right.name));
+  if (platform2 === "win32") {
+    const programData = environment["PROGRAMDATA"]?.trim();
+    return programData ? NodePath4.join(programData, "ClaudeCode", "managed-settings.json") : void 0;
+  }
+  return "/etc/claude-code/managed-settings.json";
 }
-
-// src/config.ts
-var CLAUDE_AUTO_COMPACT_WINDOW_PATTERN = /^(?:|[1-9]\d{5}|1000000)$/;
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function skillOverrideSettingsPaths(configDirPath, cwd, platform2, environment, repositoryRoot) {
+  const managedPath = claudeManagedSettingsPath(platform2, environment);
+  const root = repositoryRoot !== void 0 && repositoryRoot !== cwd ? repositoryRoot : void 0;
+  return [
+    NodePath4.join(configDirPath, "settings.json"),
+    ...cwd ? [
+      NodePath4.join(cwd, ".claude", "settings.json"),
+      NodePath4.join(cwd, ".claude", "settings.local.json")
+    ] : [],
+    ...root ? [NodePath4.join(root, ".claude", "settings.local.json")] : [],
+    ...managedPath ? [managedPath] : []
+  ];
 }
-function readString(value) {
-  return typeof value === "string" ? value : "";
+async function findRepositoryRoot(cwd) {
+  let current = NodePath4.resolve(cwd);
+  for (; ; ) {
+    const found = await NodeFSP.stat(NodePath4.join(current, ".git")).then(
+      () => true,
+      () => false
+    );
+    if (found) return current;
+    const parent = NodePath4.dirname(current);
+    if (parent === current) return void 0;
+    current = parent;
+  }
+}
+function parseLenientJson(text) {
+  let output = "";
+  let index = 0;
+  while (index < text.length) {
+    const char = text[index];
+    const next = text[index + 1];
+    if (char === '"') {
+      let end = index + 1;
+      while (end < text.length && text[end] !== '"') end += text[end] === "\\" ? 2 : 1;
+      output += text.slice(index, end + 1);
+      index = end + 1;
+    } else if (char === "/" && next === "/") {
+      while (index < text.length && text[index] !== "\n") index += 1;
+    } else if (char === "/" && next === "*") {
+      const end = text.indexOf("*/", index + 2);
+      index = end === -1 ? text.length : end + 2;
+    } else {
+      output += char;
+      index += 1;
+    }
+  }
+  return JSON.parse(output.replace(/,(\s*[}\]])/g, "$1"));
 }
-function readTrimmed(value) {
-  return readString(value).trim();
+var SKILL_OVERRIDE_BY_VALUE = {
+  off: { enabled: false, userInvocationOnly: false },
+  // 与 `disable-model-invocation` 一样对 agent 隐藏，所以与普通开关分开记。
+  "user-invocable-only": { enabled: true, userInvocationOnly: true },
+  on: { enabled: true, userInvocationOnly: false },
+  "name-only": { enabled: true, userInvocationOnly: false }
+};
+function readOverridesFromSettings(text) {
+  let parsed;
+  try {
+    parsed = parseLenientJson(text);
+  } catch {
+    return void 0;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
+  const overrides = parsed["skillOverrides"];
+  if (typeof overrides !== "object" || overrides === null || Array.isArray(overrides)) {
+    return void 0;
+  }
+  const result = /* @__PURE__ */ new Map();
+  for (const [name, value] of Object.entries(overrides)) {
+    const override = typeof value === "string" ? SKILL_OVERRIDE_BY_VALUE[value] : void 0;
+    if (override === void 0) return void 0;
+    result.set(name, override);
+  }
+  return result;
 }
-function readEnvironment(value) {
-  if (!Array.isArray(value)) return {};
-  const env = {};
-  for (const entry of value) {
-    if (!isRecord2(entry)) continue;
-    const name = readTrimmed(entry["name"]);
-    if (name.length === 0) continue;
-    env[name] = readString(entry["value"]);
+async function readSkillOverrides(configDirPath, cwd, platform2, environment) {
+  const repositoryRoot = cwd === void 0 ? void 0 : await findRepositoryRoot(cwd);
+  const merged = /* @__PURE__ */ new Map();
+  for (const settingsPath of skillOverrideSettingsPaths(
+    configDirPath,
+    cwd,
+    platform2,
+    environment,
+    repositoryRoot
+  )) {
+    const contents = await NodeFSP.readFile(settingsPath, "utf8").catch(() => void 0);
+    if (contents === void 0) continue;
+    for (const [name, override] of readOverridesFromSettings(contents) ?? []) {
+      merged.set(name, override);
+    }
   }
-  return env;
+  return merged;
 }
-function readCustomModels(value) {
-  if (!Array.isArray(value)) return [];
-  const models = [];
-  for (const entry of value) {
-    if (typeof entry === "string") {
-      const slug2 = entry.trim();
-      if (slug2.length > 0) models.push({ slug: slug2 });
-      continue;
+async function discoverClaudeSkills(configDirPath, options = {}) {
+  const { cwd } = options;
+  const overrides = await readSkillOverrides(
+    configDirPath,
+    cwd,
+    options.platform ?? NodeProcess.platform,
+    options.environment ?? NodeProcess.env
+  );
+  const roots = [
+    { directory: NodePath4.join(configDirPath, "skills"), scope: "user" },
+    ...cwd ? [{ directory: NodePath4.join(cwd, ".claude", "skills"), scope: "project" }] : []
+  ];
+  const skills = /* @__PURE__ */ new Map();
+  for (const root of roots) {
+    const entries = await NodeFSP.readdir(root.directory).catch(() => []);
+    for (const entry of entries.toSorted()) {
+      const name = entry.trim();
+      if (name.length === 0 || skills.has(name)) continue;
+      const skillPath = NodePath4.join(root.directory, entry, "SKILL.md");
+      const contents = await NodeFSP.readFile(skillPath, "utf8").catch(() => void 0);
+      if (contents === void 0) continue;
+      const frontMatter = parseSkillFrontMatter(contents);
+      const override = overrides.get(name);
+      const userInvocationOnly = frontMatter.userInvocationOnly === true || override?.userInvocationOnly === true;
+      skills.set(name, {
+        name,
+        path: skillPath,
+        enabled: override?.enabled ?? true,
+        scope: root.scope,
+        ...frontMatter.description === void 0 ? {} : { description: frontMatter.description },
+        ...userInvocationOnly ? { userInvocationOnly: true } : {},
+        ...frontMatter.userInvocable === false ? { userInvocable: false } : {}
+      });
     }
-    if (!isRecord2(entry)) continue;
-    const slug = readTrimmed(entry["slug"]);
-    if (slug.length === 0) continue;
-    const thinkingRaw = entry["thinkingOptions"];
-    const thinkingOptions = Array.isArray(thinkingRaw) ? thinkingRaw.flatMap((option) => {
-      if (!isRecord2(option)) return [];
-      const id2 = readTrimmed(option["id"]) || readTrimmed(option["value"]);
-      const label = readTrimmed(option["label"]) || id2;
-      if (id2.length === 0) return [];
-      return [
-        {
-          id: id2,
-          label,
-          ...typeof option["description"] === "string" ? { description: option["description"] } : {},
-          ...option["isDefault"] === true ? { isDefault: true } : {}
-        }
-      ];
-    }) : void 0;
-    const aliasesRaw = entry["aliases"];
-    const aliases = Array.isArray(aliasesRaw) ? aliasesRaw.filter(
-      (alias) => typeof alias === "string" && alias.trim().length > 0
-    ) : void 0;
-    const contextWindow = typeof entry["contextWindow"] === "number" && Number.isFinite(entry["contextWindow"]) && entry["contextWindow"] > 0 ? Math.round(entry["contextWindow"]) : void 0;
-    models.push({
-      slug,
-      ...readTrimmed(entry["label"]) ? { label: readTrimmed(entry["label"]) } : {},
-      ...thinkingOptions && thinkingOptions.length > 0 ? { thinkingOptions } : {},
-      ...contextWindow !== void 0 ? { contextWindow } : {},
-      ...aliases && aliases.length > 0 ? { aliases } : {}
-    });
   }
-  return models;
+  return [...skills.values()].toSorted((left, right) => left.name.localeCompare(right.name));
 }
-function readAutoCompactWindow(value) {
-  const trimmed = readTrimmed(value);
-  return CLAUDE_AUTO_COMPACT_WINDOW_PATTERN.test(trimmed) ? trimmed : "";
+
+// src/model.ts
+import { matchCatalogModel } from "@ycodium-ai/plugin-api/executor";
+var DEFAULT_CLAUDE_MODEL_CAPABILITIES = {
+  optionDescriptors: []
+};
+var CLAUDE_CUSTOM_MODEL_THINKING_SELECT = {
+  id: "effort",
+  label: "Reasoning"
+};
+function parseGenericCliVersion(output) {
+  const match = output.match(/\bv?(\d+\.\d+\.\d+)\b/);
+  return match?.[1] ?? null;
 }
-function parseClaudeInstanceConfig(config) {
-  if (!isRecord2(config)) {
+function normalizeCustomModelSlug(slug) {
+  return slug.trim();
+}
+function knownClaudeModelCapabilities(model, catalog, customModels) {
+  const slug = model?.trim();
+  const fromCatalog = catalog.find((candidate) => candidate.slug === slug)?.capabilities;
+  if (fromCatalog) return fromCatalog;
+  const custom = customModels?.find(
+    (candidate) => normalizeCustomModelSlug(candidate.slug) === slug
+  );
+  if (custom?.thinkingOptions !== void 0 && custom.thinkingOptions.length > 0) {
+    const currentValue = custom.thinkingOptions.find((option) => option.isDefault)?.id;
     return {
-      binaryPath: "",
-      homePath: "",
-      credentialsPath: "",
-      launchArgs: "",
-      autoCompactWindow: "",
-      customModels: [],
-      enabled: true,
-      environment: {},
-      envelopeDriver: void 0
+      optionDescriptors: [
+        {
+          type: "select",
+          id: CLAUDE_CUSTOM_MODEL_THINKING_SELECT.id,
+          label: CLAUDE_CUSTOM_MODEL_THINKING_SELECT.label,
+          options: custom.thinkingOptions,
+          ...currentValue !== void 0 ? {} : {}
+        }
+      ]
     };
   }
-  const nested = isRecord2(config["config"]) ? config["config"] : void 0;
-  const settings = nested ?? config;
-  return {
-    binaryPath: readTrimmed(settings["binaryPath"]),
-    homePath: readTrimmed(settings["homePath"]) || readTrimmed(config["homePath"]),
-    credentialsPath: readTrimmed(settings["credentialsPath"]) || readTrimmed(config["credentialsPath"]),
-    launchArgs: readString(settings["launchArgs"]),
-    autoCompactWindow: readAutoCompactWindow(settings["autoCompactWindow"]),
-    customModels: readCustomModels(settings["customModels"]),
-    enabled: settings["enabled"] !== false,
-    environment: readEnvironment(config["environment"]),
-    envelopeDriver: readTrimmed(config["driver"]) || void 0
-  };
+  return void 0;
 }
-function tokenizeLaunchArgs(value) {
-  const input = value.trim();
-  if (!input) return [];
-  const tokens = [];
-  let current = "";
-  let quote;
-  let quoted = false;
-  for (let index = 0; index < input.length; index++) {
-    const char = input[index];
-    if (char === void 0) continue;
-    if (quote) {
-      if (char === quote) {
-        quote = void 0;
-        quoted = true;
-      } else if (char === "\\" && quote === '"') {
-        const next = input[index + 1];
-        if (next !== void 0 && ['"', "\\", "$", "`"].includes(next)) {
-          current += next;
-          index++;
+function claudeModelCapabilities(model, catalog, customModels) {
+  return knownClaudeModelCapabilities(model, catalog, customModels) ?? DEFAULT_CLAUDE_MODEL_CAPABILITIES;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getModelSelectionStringOptionValue(modelSelection, optionId) {
+  if (!isRecord2(modelSelection)) return void 0;
+  const options = modelSelection["options"];
+  if (!Array.isArray(options)) return void 0;
+  for (const entry of options) {
+    if (!isRecord2(entry)) continue;
+    if (entry["id"] === optionId && typeof entry["value"] === "string") {
+      const trimmed = entry["value"].trim();
+      if (trimmed.length > 0) return trimmed;
+    }
+  }
+  return void 0;
+}
+function getModelSelectionBooleanOptionValue(modelSelection, optionId) {
+  if (!isRecord2(modelSelection)) return void 0;
+  const options = modelSelection["options"];
+  if (!Array.isArray(options)) return void 0;
+  for (const entry of options) {
+    if (!isRecord2(entry)) continue;
+    if (entry["id"] === optionId && typeof entry["value"] === "boolean") {
+      return entry["value"];
+    }
+  }
+  return void 0;
+}
+function modelIdFromSelection(selection) {
+  if (!isRecord2(selection)) return void 0;
+  const model = selection["model"];
+  return typeof model === "string" ? model.trim() || void 0 : void 0;
+}
+function currentSelectValue(descriptor, raw) {
+  if (raw && descriptor.options.some((option) => option.id === raw)) return raw;
+  return descriptor.options.find((option) => option.isDefault)?.id;
+}
+function resolveClaudeEffort(caps, raw) {
+  const descriptor = caps.optionDescriptors.find((entry) => entry.id === "effort");
+  if (!descriptor || descriptor.type !== "select") return void 0;
+  return currentSelectValue(descriptor, raw);
+}
+function normalizeClaudeCliEffort(effort) {
+  if (!effort || effort === "ultrathink") {
+    return void 0;
+  }
+  if (effort === "ultracode") {
+    return "xhigh";
+  }
+  return effort;
+}
+function isClaudeUltracodeEffort(effort) {
+  return effort === "ultracode";
+}
+function claudeCliModelId(input) {
+  const requested = input.requestedModelId.trim();
+  if (requested.length > 0 && (input.catalog ?? []).length === 0) return requested;
+  const known = [
+    ...(input.catalog ?? []).map((model) => model.slug),
+    ...input.declared ?? [],
+    ...(input.customModels ?? []).map((model) => normalizeCustomModelSlug(model.slug))
+  ];
+  return matchCatalogModel(input.requestedModelId, known) ?? input.placeholder;
+}
+function resolvePromptInjectedEffort(caps, rawEffort) {
+  const trimmed = rawEffort?.trim();
+  if (!trimmed) return void 0;
+  const descriptor = caps.optionDescriptors.find((entry) => entry.id === "effort");
+  if (!descriptor || descriptor.type !== "select") return void 0;
+  if (!descriptor.promptInjectedValues?.includes(trimmed)) return void 0;
+  return trimmed;
+}
+function applyClaudePromptEffortPrefix(text, effort) {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return trimmed;
+  }
+  if (effort !== "ultrathink" || /^\/[^\s/]+(?:\s|$)/u.test(trimmed)) {
+    return trimmed;
+  }
+  if (trimmed.startsWith("Ultrathink:")) {
+    return trimmed;
+  }
+  return `Ultrathink:
+${trimmed}`;
+}
+function getEffectiveClaudeAgentEffort(effort) {
+  const normalized = normalizeClaudeCliEffort(effort);
+  return normalized ? normalized : null;
+}
+
+// src/probeModels.ts
+var toProbeCapabilities = (caps) => ({
+  optionDescriptors: caps.optionDescriptors.map(
+    (descriptor) => descriptor.type === "select" ? {
+      id: descriptor.id,
+      label: descriptor.label,
+      type: "select",
+      options: descriptor.options.map((option) => ({
+        id: option.id,
+        label: option.label,
+        ...option.description === void 0 ? {} : { description: option.description },
+        ...option.isDefault === void 0 ? {} : { isDefault: option.isDefault }
+      }))
+    } : {
+      id: descriptor.id,
+      label: descriptor.label,
+      type: "boolean"
+    }
+  )
+});
+var claudeProbeModels = (input) => {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const model of input.catalog) {
+    if (seen.has(model.slug)) continue;
+    seen.add(model.slug);
+    const userLabel = input.customModels.find((entry) => entry.slug === model.slug)?.label;
+    out.push({
+      slug: model.slug,
+      name: userLabel?.trim() || model.name,
+      capabilities: toProbeCapabilities(model.capabilities)
+    });
+  }
+  for (const model of input.customModels) {
+    if (model.slug.trim().length === 0 || seen.has(model.slug)) continue;
+    seen.add(model.slug);
+    out.push({ slug: model.slug, name: model.label?.trim() || model.slug });
+  }
+  return out;
+};
+
+// src/sessionSettings.ts
+function toSessionPermissionUpdates(toolName, suggestions) {
+  const sessionScoped = (suggestions ?? []).map(
+    (suggestion) => ({ ...suggestion, destination: "session" })
+  );
+  if (sessionScoped.length > 0) {
+    return sessionScoped;
+  }
+  return [
+    {
+      type: "addRules",
+      rules: [{ toolName }],
+      behavior: "allow",
+      destination: "session"
+    }
+  ];
+}
+var CLAUDE_SESSION_SETTING_KEYS = [
+  "alwaysThinkingEnabled",
+  "fastMode",
+  "ultracode",
+  "autoCompactWindow"
+];
+function buildClaudeSessionSettings(input) {
+  return {
+    ...typeof input.thinking === "boolean" ? { alwaysThinkingEnabled: input.thinking } : {},
+    ...input.fastMode ? { fastMode: true } : {},
+    ...input.ultracode ? { ultracode: true } : {},
+    ...input.autoCompactWindow ? { autoCompactWindow: Number(input.autoCompactWindow) } : {}
+  };
+}
+function diffClaudeSessionSettings(previous, next) {
+  const patch = {};
+  let changed = false;
+  const track = (key) => {
+    if (previous[key] === next[key]) {
+      return;
+    }
+    changed = true;
+    patch[key] = next[key] ?? null;
+  };
+  for (const key of CLAUDE_SESSION_SETTING_KEYS) {
+    track(key);
+  }
+  return changed ? patch : void 0;
+}
+var CLAUDE_NATIVE_MODES = [
+  { id: "default", name: "Manual", description: "Always ask before making changes" },
+  { id: "acceptEdits", name: "Accept edits", description: "Automatically accept all file edits" },
+  { id: "plan", name: "Plan", description: "Create a plan before making changes" },
+  { id: "auto", name: "Auto", description: "Claude handles permission decisions" },
+  {
+    id: "bypassPermissions",
+    name: "Bypass permissions",
+    description: "Accepts all permissions"
+  }
+];
+var CLAUDE_DEFAULT_NATIVE_MODE_ID = "default";
+var CLAUDE_NATIVE_MODE_BY_RUNTIME_MODE = {
+  "approval-required": "default",
+  "auto-accept-edits": "acceptEdits",
+  auto: "auto",
+  "full-access": "bypassPermissions"
+};
+var CLAUDE_NATIVE_MODE_REPORT = {
+  nativeModes: CLAUDE_NATIVE_MODES.map((mode) => ({
+    id: mode.id,
+    name: mode.name,
+    description: mode.description
+  })),
+  currentNativeModeId: CLAUDE_DEFAULT_NATIVE_MODE_ID,
+  nativeModeByRuntimeMode: CLAUDE_NATIVE_MODE_BY_RUNTIME_MODE
+};
+function isClaudeNativeModeId(value) {
+  return CLAUDE_NATIVE_MODES.some((mode) => mode.id === value);
+}
+function claudePermissionModeFor(runtimeMode, nativeModeId) {
+  if (nativeModeId !== void 0 && isClaudeNativeModeId(nativeModeId)) return nativeModeId;
+  return CLAUDE_NATIVE_MODE_BY_RUNTIME_MODE[runtimeMode];
+}
+var CLAUDE_SETTING_SOURCES = [
+  "user",
+  "project",
+  "local"
+];
+
+// src/claudeProbe.ts
+var CLAUDE_PROGRAM_NOT_CONFIGURED = "Claude program path is not configured";
+function createClaudeProbe(input) {
+  const { recipe, host, modelCatalog } = input;
+  const collectProcessText = async (stream) => {
+    const chunks = [];
+    for await (const chunk of stream) {
+      chunks.push(Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString("utf8");
+  };
+  const probeAuth = () => {
+    const hasEnvToken = (recipe.environment.ANTHROPIC_AUTH_TOKEN ?? "").trim().length > 0;
+    const hasEnvApiKey = (recipe.environment.ANTHROPIC_API_KEY ?? "").trim().length > 0;
+    if (hasEnvToken || hasEnvApiKey) {
+      return {
+        status: "authenticated",
+        type: hasEnvToken ? "env-token" : "api-key",
+        label: hasEnvToken ? "ANTHROPIC_AUTH_TOKEN" : "ANTHROPIC_API_KEY"
+      };
+    }
+    const account = readClaudeAccount(resolveClaudeCredentialsDirPath(recipe.credentialsPath));
+    switch (account.state) {
+      case "signed-in":
+      case "expired":
+        return { status: "authenticated" };
+      case "signed-out":
+        return { status: "unauthenticated" };
+      case "unreadable":
+        return { status: "unknown" };
+    }
+  };
+  let lastProbedVersion;
+  const probe = async (signal) => {
+    if (recipe.binaryPath.length === 0) {
+      return {
+        installed: false,
+        version: null,
+        readiness: "not-installed",
+        auth: { status: "unknown" },
+        detail: CLAUDE_PROGRAM_NOT_CONFIGURED
+      };
+    }
+    if (signal?.aborted) {
+      throw new Error("aborted");
+    }
+    let handle;
+    try {
+      handle = await host.process.spawn({
+        program: recipe.binaryPath,
+        args: ["--version"],
+        owner: { bindingId: host.bindingId }
+      });
+    } catch (error) {
+      if (error instanceof ExecutorSpawnRefusedError) throw error;
+      const failure = describeExecutorSpawnFailure(error);
+      return {
+        installed: false,
+        version: null,
+        readiness: failure.readiness,
+        auth: { status: "unknown" },
+        detail: failure.detail
+      };
+    }
+    const [stdout, stderr, exitCode] = await Promise.all([
+      collectProcessText(handle.stdout),
+      collectProcessText(handle.stderr),
+      handle.exited
+    ]);
+    const version = parseGenericCliVersion(`${stdout}
+${stderr}`);
+    if (version !== null || exitCode === 0) {
+      await modelCatalog.refresh({ signal, force: version !== lastProbedVersion });
+      lastProbedVersion = version;
+    }
+    const models = claudeProbeModels({
+      catalog: modelCatalog.current(),
+      customModels: recipe.customModels
+    });
+    const auth = probeAuth();
+    const skills = await discoverClaudeSkills(
+      resolveClaudeConfigDirPath(recipe.homePath, { ...process.env, ...recipe.environment })
+    );
+    if (exitCode !== 0 && version === null) {
+      const detail = (stderr || stdout || "claude --version failed").trim();
+      return {
+        installed: false,
+        version: null,
+        readiness: "error",
+        auth,
+        ...detail.length > 0 ? { detail } : {}
+      };
+    }
+    if (auth.status === "unauthenticated") {
+      return {
+        installed: true,
+        version,
+        readiness: "error",
+        auth,
+        models,
+        skills,
+        detail: "Claude is signed out",
+        // 退出登录了档位照样是那五档。不报就退回宿主四档，而那份映射少了 `plan`。
+        ...CLAUDE_NATIVE_MODE_REPORT
+      };
+    }
+    return {
+      installed: true,
+      version,
+      readiness: "ready",
+      auth,
+      models,
+      skills,
+      ...CLAUDE_NATIVE_MODE_REPORT
+    };
+  };
+  return probe;
+}
+
+// src/claudeExecutable.ts
+import * as NodeFS2 from "node:fs";
+import * as NodeOS4 from "node:os";
+import * as NodePath5 from "node:path";
+var WINDOWS_SHIM_EXTENSIONS = /* @__PURE__ */ new Set([".cmd", ".bat", ".ps1"]);
+var NPM_PACKAGE_ENTRY_CANDIDATES = [
+  ["node_modules", "@anthropic-ai", "claude-code", "bin", "claude.exe"],
+  ["node_modules", "@anthropic-ai", "claude-code", "cli.js"]
+];
+function isExistingFile(filePath) {
+  try {
+    return NodeFS2.statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+function resolveClaudeSdkExecutablePath(binaryPath, environment = process.env, isFile = isExistingFile, isWindows = NodeOS4.type() === "Windows_NT") {
+  if (!isWindows) {
+    return binaryPath;
+  }
+  const resolved = resolveWindowsExecutable(binaryPath, environment) ?? binaryPath;
+  const extension = NodePath5.win32.extname(resolved).toLowerCase();
+  if (!WINDOWS_SHIM_EXTENSIONS.has(extension)) {
+    return resolved;
+  }
+  const shimDirectory = NodePath5.win32.dirname(resolved);
+  for (const entrySegments of NPM_PACKAGE_ENTRY_CANDIDATES) {
+    const candidate = NodePath5.win32.join(shimDirectory, ...entrySegments);
+    if (isFile(candidate)) {
+      return candidate;
+    }
+  }
+  return binaryPath;
+}
+function resolveWindowsExecutable(binaryPath, environment) {
+  const trimmed = binaryPath.trim();
+  if (trimmed.length === 0) return void 0;
+  if (NodePath5.win32.isAbsolute(trimmed) && isExistingFile(trimmed)) return trimmed;
+  const pathValue = environment.PATH ?? environment.Path ?? "";
+  const pathext = environment.PATHEXT ?? ".EXE;.CMD;.BAT;.COM";
+  const extensions = pathext.split(";").filter((ext) => ext.length > 0);
+  const hasExt = NodePath5.win32.extname(trimmed).length > 0;
+  for (const dir of pathValue.split(";")) {
+    if (dir.trim().length === 0) continue;
+    const candidates = hasExt ? [NodePath5.win32.join(dir, trimmed)] : extensions.map((ext) => NodePath5.win32.join(dir, `${trimmed}${ext}`));
+    for (const candidate of candidates) {
+      if (isExistingFile(candidate)) return candidate;
+    }
+  }
+  return void 0;
+}
+
+// src/claudeSignIn.ts
+var POSIX_BARE_VALUE = /^[A-Za-z0-9_@%+=:,./-]+$/;
+function quotePosixShellValue(value) {
+  if (POSIX_BARE_VALUE.test(value)) return value;
+  return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+function quotePowerShellValue(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
+function withClaudeCredentialsDir(input) {
+  const variable = CLAUDE_CREDENTIALS_DIR_ENVIRONMENT_VARIABLE;
+  return input.platform === "win32" ? `$env:${variable}=${quotePowerShellValue(input.credentialsDirPath)}; ${input.command}` : `${variable}=${quotePosixShellValue(input.credentialsDirPath)} ${input.command}`;
+}
+function claudeSignInCommand(credentialsPath, platform2) {
+  const command = "claude auth login";
+  const credentialsDirPath = resolveClaudeCredentialsDirPath(credentialsPath);
+  if (credentialsDirPath === null) return command;
+  return withClaudeCredentialsDir({ command, credentialsDirPath, platform: platform2 });
+}
+
+// src/claudeWorkspaceInventory.ts
+import * as NodeFSP2 from "node:fs/promises";
+import * as NodePath6 from "node:path";
+var MAX_COMMAND_DEPTH = 5;
+var MAX_COMMAND_FILES = 500;
+var MAX_DESCRIPTION_LENGTH = 200;
+var firstBodyLine = (contents) => {
+  const lines = contents.split(/\r?\n/);
+  let index = 0;
+  if (lines[0]?.trim() === "---") {
+    const close = lines.findIndex((line, position) => position > 0 && line.trim() === "---");
+    index = close === -1 ? lines.length : close + 1;
+  }
+  for (; index < lines.length; index += 1) {
+    const line = (lines[index] ?? "").trim().replace(/^#+\s*/, "");
+    if (line.length > 0) return line.slice(0, MAX_DESCRIPTION_LENGTH);
+  }
+  return void 0;
+};
+var scanCommands = async (claudeDir) => {
+  const root = NodePath6.join(claudeDir, "commands");
+  const commands = /* @__PURE__ */ new Map();
+  const watched = [root];
+  let level = [root];
+  let files = 0;
+  for (let depth = 0; depth < MAX_COMMAND_DEPTH && level.length > 0; depth += 1) {
+    const next = [];
+    for (const directory of level) {
+      const entries = await NodeFSP2.readdir(directory, { withFileTypes: true }).catch(() => []);
+      for (const entry of entries.toSorted((left, right) => left.name.localeCompare(right.name))) {
+        const entryPath = NodePath6.join(directory, entry.name);
+        if (entry.isDirectory()) {
+          next.push(entryPath);
+          watched.push(entryPath);
+          continue;
+        }
+        if (!entry.isFile() || !entry.name.toLowerCase().endsWith(".md")) continue;
+        watched.push(entryPath);
+        if (files >= MAX_COMMAND_FILES) continue;
+        files += 1;
+        const name = entry.name.slice(0, -".md".length).trim();
+        if (name.length === 0 || commands.has(name)) continue;
+        const contents = await NodeFSP2.readFile(entryPath, "utf8").catch(() => void 0);
+        if (contents === void 0) continue;
+        const frontMatter = parseSkillFrontMatter(contents);
+        const description = frontMatter.description ?? firstBodyLine(contents);
+        commands.set(name, {
+          name,
+          ...description === void 0 ? {} : { description },
+          ...frontMatter.argumentHint === void 0 ? {} : { input: { hint: frontMatter.argumentHint } }
+        });
+      }
+    }
+    level = next;
+  }
+  return { commands: [...commands.values()], watched };
+};
+var watchSkillsRoot = async (claudeDir) => {
+  const root = NodePath6.join(claudeDir, "skills");
+  const entries = await NodeFSP2.readdir(root).catch(() => []);
+  return [
+    root,
+    ...entries.flatMap((entry) => [
+      NodePath6.join(root, entry),
+      NodePath6.join(root, entry, "SKILL.md")
+    ])
+  ];
+};
+var mergeByName = (base, preferred) => {
+  const merged = /* @__PURE__ */ new Map();
+  for (const entry of base) merged.set(entry.name, entry);
+  for (const entry of preferred) merged.set(entry.name, entry);
+  return [...merged.values()].toSorted((left, right) => left.name.localeCompare(right.name));
+};
+var discoverClaudeWorkspaceInventory = async (input) => {
+  const projectClaudeDir = NodePath6.join(input.cwd, ".claude");
+  const [userCommands, projectCommands, skills, userSkillWatch, projectSkillWatch] = await Promise.all([
+    scanCommands(input.configDirPath),
+    scanCommands(projectClaudeDir),
+    discoverClaudeSkills(input.configDirPath, {
+      cwd: input.cwd,
+      ...input.environment === void 0 ? {} : { environment: input.environment }
+    }),
+    watchSkillsRoot(input.configDirPath),
+    watchSkillsRoot(projectClaudeDir)
+  ]);
+  return {
+    slashCommands: mergeByName(userCommands.commands, projectCommands.commands),
+    skills,
+    // 项目目录本身也看：`.claude` 整个是后来才建的，它出现就该重查。
+    watchPaths: [
+      projectClaudeDir,
+      ...userCommands.watched,
+      ...projectCommands.watched,
+      ...userSkillWatch,
+      ...projectSkillWatch,
+      // `skillOverrides` 在这几个设置文件里：开关一个技能也要重查。
+      NodePath6.join(input.configDirPath, "settings.json"),
+      NodePath6.join(projectClaudeDir, "settings.json"),
+      NodePath6.join(projectClaudeDir, "settings.local.json")
+    ]
+  };
+};
+var asRecord = (value) => typeof value === "object" && value !== null ? value : void 0;
+var nonEmptyString = (value) => typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+var claudeSlashCommandsFromNames = (names) => Array.isArray(names) ? names.flatMap((entry) => {
+  const name = nonEmptyString(entry);
+  return name === void 0 ? [] : [{ name }];
+}) : [];
+var claudeSlashCommandsFromSdk = (commands) => Array.isArray(commands) ? commands.flatMap((entry) => {
+  const record = asRecord(entry);
+  const name = nonEmptyString(record?.["name"]);
+  if (name === void 0) return [];
+  const description = nonEmptyString(record?.["description"]);
+  const hint = nonEmptyString(record?.["argumentHint"]);
+  return [
+    {
+      name,
+      ...description === void 0 ? {} : { description },
+      ...hint === void 0 ? {} : { input: { hint } }
+    }
+  ];
+}) : [];
+
+// src/config.ts
+var CLAUDE_AUTO_COMPACT_WINDOW_PATTERN = /^(?:|[1-9]\d{5}|1000000)$/;
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString(value) {
+  return typeof value === "string" ? value : "";
+}
+function readTrimmed(value) {
+  return readString(value).trim();
+}
+function readEnvironment(value) {
+  if (!Array.isArray(value)) return {};
+  const env2 = {};
+  for (const entry of value) {
+    if (!isRecord3(entry)) continue;
+    const name = readTrimmed(entry["name"]);
+    if (name.length === 0) continue;
+    env2[name] = readString(entry["value"]);
+  }
+  return env2;
+}
+function readCustomModels(value) {
+  if (!Array.isArray(value)) return [];
+  const models = [];
+  for (const entry of value) {
+    if (typeof entry === "string") {
+      const slug2 = entry.trim();
+      if (slug2.length > 0) models.push({ slug: slug2 });
+      continue;
+    }
+    if (!isRecord3(entry)) continue;
+    const slug = readTrimmed(entry["slug"]);
+    if (slug.length === 0) continue;
+    const thinkingRaw = entry["thinkingOptions"];
+    const thinkingOptions = Array.isArray(thinkingRaw) ? thinkingRaw.flatMap((option) => {
+      if (!isRecord3(option)) return [];
+      const id2 = readTrimmed(option["id"]) || readTrimmed(option["value"]);
+      const label = readTrimmed(option["label"]) || id2;
+      if (id2.length === 0) return [];
+      return [
+        {
+          id: id2,
+          label,
+          ...typeof option["description"] === "string" ? { description: option["description"] } : {},
+          ...option["isDefault"] === true ? { isDefault: true } : {}
+        }
+      ];
+    }) : void 0;
+    const aliasesRaw = entry["aliases"];
+    const aliases = Array.isArray(aliasesRaw) ? aliasesRaw.filter(
+      (alias) => typeof alias === "string" && alias.trim().length > 0
+    ) : void 0;
+    const contextWindow = typeof entry["contextWindow"] === "number" && Number.isFinite(entry["contextWindow"]) && entry["contextWindow"] > 0 ? Math.round(entry["contextWindow"]) : void 0;
+    models.push({
+      slug,
+      ...readTrimmed(entry["label"]) ? { label: readTrimmed(entry["label"]) } : {},
+      ...thinkingOptions && thinkingOptions.length > 0 ? { thinkingOptions } : {},
+      ...contextWindow !== void 0 ? { contextWindow } : {},
+      ...aliases && aliases.length > 0 ? { aliases } : {}
+    });
+  }
+  return models;
+}
+function readAutoCompactWindow(value) {
+  const trimmed = readTrimmed(value);
+  return CLAUDE_AUTO_COMPACT_WINDOW_PATTERN.test(trimmed) ? trimmed : "";
+}
+function parseClaudeInstanceConfig(config) {
+  if (!isRecord3(config)) {
+    return {
+      binaryPath: "",
+      homePath: "",
+      credentialsPath: "",
+      launchArgs: "",
+      autoCompactWindow: "",
+      customModels: [],
+      enabled: true,
+      environment: {},
+      envelopeDriver: void 0
+    };
+  }
+  const nested = isRecord3(config["config"]) ? config["config"] : void 0;
+  const settings = nested ?? config;
+  return {
+    binaryPath: readTrimmed(settings["binaryPath"]),
+    homePath: readTrimmed(settings["homePath"]) || readTrimmed(config["homePath"]),
+    credentialsPath: readTrimmed(settings["credentialsPath"]) || readTrimmed(config["credentialsPath"]),
+    launchArgs: readString(settings["launchArgs"]),
+    autoCompactWindow: readAutoCompactWindow(settings["autoCompactWindow"]),
+    customModels: readCustomModels(settings["customModels"]),
+    enabled: settings["enabled"] !== false,
+    environment: readEnvironment(config["environment"]),
+    envelopeDriver: readTrimmed(config["driver"]) || void 0
+  };
+}
+function tokenizeLaunchArgs(value) {
+  const input = value.trim();
+  if (!input) return [];
+  const tokens = [];
+  let current = "";
+  let quote;
+  let quoted = false;
+  for (let index = 0; index < input.length; index++) {
+    const char = input[index];
+    if (char === void 0) continue;
+    if (quote) {
+      if (char === quote) {
+        quote = void 0;
+        quoted = true;
+      } else if (char === "\\" && quote === '"') {
+        const next = input[index + 1];
+        if (next !== void 0 && ['"', "\\", "$", "`"].includes(next)) {
+          current += next;
+          index++;
         } else {
           current += char;
         }
@@ -20124,189 +20827,56 @@ function parseCliArgs(args, options) {
         continue;
       }
       if (booleanSet?.has(rest)) {
-        flags[rest] = null;
-        continue;
-      }
-      const next = tokens[i + 1];
-      if (next !== void 0 && !next.startsWith("--")) {
-        flags[rest] = next;
-        i++;
-      } else {
-        flags[rest] = null;
-      }
-    } else {
-      positionals.push(token);
-    }
-  }
-  return { flags, positionals };
-}
-
-// src/events.ts
-var EventBus = class {
-  #queued = [];
-  #waiters = [];
-  #closed = false;
-  push(event) {
-    const waiter = this.#waiters.shift();
-    if (waiter) {
-      waiter({ done: false, value: event });
-      return;
-    }
-    this.#queued.push(event);
-  }
-  close() {
-    if (this.#closed) return;
-    this.#closed = true;
-    while (this.#waiters.length > 0) {
-      this.#waiters.shift()?.({ done: true, value: void 0 });
-    }
-  }
-  [Symbol.asyncIterator]() {
-    return {
-      next: () => {
-        const queued = this.#queued.shift();
-        if (queued !== void 0) return Promise.resolve({ done: false, value: queued });
-        if (this.#closed) return Promise.resolve({ done: true, value: void 0 });
-        return new Promise((resolve3) => {
-          this.#waiters.push(resolve3);
-        });
-      }
-    };
-  }
-};
-
-// src/model.ts
-import { matchCatalogModel } from "@ycodium-ai/plugin-api/executor";
-var DEFAULT_CLAUDE_MODEL_CAPABILITIES = {
-  optionDescriptors: []
-};
-var CLAUDE_CUSTOM_MODEL_THINKING_SELECT = {
-  id: "effort",
-  label: "Reasoning"
-};
-function parseGenericCliVersion(output) {
-  const match = output.match(/\bv?(\d+\.\d+\.\d+)\b/);
-  return match?.[1] ?? null;
-}
-function normalizeCustomModelSlug(slug) {
-  return slug.trim();
-}
-function knownClaudeModelCapabilities(model, catalog, customModels) {
-  const slug = model?.trim();
-  const fromCatalog = catalog.find((candidate) => candidate.slug === slug)?.capabilities;
-  if (fromCatalog) return fromCatalog;
-  const custom = customModels?.find(
-    (candidate) => normalizeCustomModelSlug(candidate.slug) === slug
-  );
-  if (custom?.thinkingOptions !== void 0 && custom.thinkingOptions.length > 0) {
-    const currentValue = custom.thinkingOptions.find((option) => option.isDefault)?.id;
-    return {
-      optionDescriptors: [
-        {
-          type: "select",
-          id: CLAUDE_CUSTOM_MODEL_THINKING_SELECT.id,
-          label: CLAUDE_CUSTOM_MODEL_THINKING_SELECT.label,
-          options: custom.thinkingOptions,
-          ...currentValue !== void 0 ? {} : {}
-        }
-      ]
-    };
-  }
-  return void 0;
-}
-function claudeModelCapabilities(model, catalog, customModels) {
-  return knownClaudeModelCapabilities(model, catalog, customModels) ?? DEFAULT_CLAUDE_MODEL_CAPABILITIES;
-}
-function isRecord3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function getModelSelectionStringOptionValue(modelSelection, optionId) {
-  if (!isRecord3(modelSelection)) return void 0;
-  const options = modelSelection["options"];
-  if (!Array.isArray(options)) return void 0;
-  for (const entry of options) {
-    if (!isRecord3(entry)) continue;
-    if (entry["id"] === optionId && typeof entry["value"] === "string") {
-      const trimmed = entry["value"].trim();
-      if (trimmed.length > 0) return trimmed;
+        flags[rest] = null;
+        continue;
+      }
+      const next = tokens[i + 1];
+      if (next !== void 0 && !next.startsWith("--")) {
+        flags[rest] = next;
+        i++;
+      } else {
+        flags[rest] = null;
+      }
+    } else {
+      positionals.push(token);
     }
   }
-  return void 0;
+  return { flags, positionals };
 }
-function getModelSelectionBooleanOptionValue(modelSelection, optionId) {
-  if (!isRecord3(modelSelection)) return void 0;
-  const options = modelSelection["options"];
-  if (!Array.isArray(options)) return void 0;
-  for (const entry of options) {
-    if (!isRecord3(entry)) continue;
-    if (entry["id"] === optionId && typeof entry["value"] === "boolean") {
-      return entry["value"];
+
+// src/events.ts
+var EventBus = class {
+  #queued = [];
+  #waiters = [];
+  #closed = false;
+  push(event) {
+    const waiter = this.#waiters.shift();
+    if (waiter) {
+      waiter({ done: false, value: event });
+      return;
     }
+    this.#queued.push(event);
   }
-  return void 0;
-}
-function modelIdFromSelection(selection) {
-  if (!isRecord3(selection)) return void 0;
-  const model = selection["model"];
-  return typeof model === "string" ? model.trim() || void 0 : void 0;
-}
-function currentSelectValue(descriptor, raw) {
-  if (raw && descriptor.options.some((option) => option.id === raw)) return raw;
-  return descriptor.options.find((option) => option.isDefault)?.id;
-}
-function resolveClaudeEffort(caps, raw) {
-  const descriptor = caps.optionDescriptors.find((entry) => entry.id === "effort");
-  if (!descriptor || descriptor.type !== "select") return void 0;
-  return currentSelectValue(descriptor, raw);
-}
-function normalizeClaudeCliEffort(effort) {
-  if (!effort || effort === "ultrathink") {
-    return void 0;
-  }
-  if (effort === "ultracode") {
-    return "xhigh";
-  }
-  return effort;
-}
-function isClaudeUltracodeEffort(effort) {
-  return effort === "ultracode";
-}
-function claudeCliModelId(input) {
-  const requested = input.requestedModelId.trim();
-  if (requested.length > 0 && (input.catalog ?? []).length === 0) return requested;
-  const known = [
-    ...(input.catalog ?? []).map((model) => model.slug),
-    ...input.declared ?? [],
-    ...(input.customModels ?? []).map((model) => normalizeCustomModelSlug(model.slug))
-  ];
-  return matchCatalogModel(input.requestedModelId, known) ?? input.placeholder;
-}
-function resolvePromptInjectedEffort(caps, rawEffort) {
-  const trimmed = rawEffort?.trim();
-  if (!trimmed) return void 0;
-  const descriptor = caps.optionDescriptors.find((entry) => entry.id === "effort");
-  if (!descriptor || descriptor.type !== "select") return void 0;
-  if (!descriptor.promptInjectedValues?.includes(trimmed)) return void 0;
-  return trimmed;
-}
-function applyClaudePromptEffortPrefix(text, effort) {
-  const trimmed = text.trim();
-  if (!trimmed) {
-    return trimmed;
-  }
-  if (effort !== "ultrathink" || /^\/[^\s/]+(?:\s|$)/u.test(trimmed)) {
-    return trimmed;
+  close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    while (this.#waiters.length > 0) {
+      this.#waiters.shift()?.({ done: true, value: void 0 });
+    }
   }
-  if (trimmed.startsWith("Ultrathink:")) {
-    return trimmed;
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => {
+        const queued = this.#queued.shift();
+        if (queued !== void 0) return Promise.resolve({ done: false, value: queued });
+        if (this.#closed) return Promise.resolve({ done: true, value: void 0 });
+        return new Promise((resolve4) => {
+          this.#waiters.push(resolve4);
+        });
+      }
+    };
   }
-  return `Ultrathink:
-${trimmed}`;
-}
-function getEffectiveClaudeAgentEffort(effort) {
-  const normalized = normalizeClaudeCliEffort(effort);
-  return normalized ? normalized : null;
-}
+};
 
 // src/sdkModels.ts
 import * as NodeOS5 from "node:os";
@@ -20355,9 +20925,9 @@ var claudeCatalogFromSdk = (models) => {
 };
 var silentPrompt = (signal) => ({
   [Symbol.asyncIterator]: () => ({
-    next: () => new Promise((resolve3) => {
-      if (signal.aborted) resolve3({ done: true, value: void 0 });
-      signal.addEventListener("abort", () => resolve3({ done: true, value: void 0 }), {
+    next: () => new Promise((resolve4) => {
+      if (signal.aborted) resolve4({ done: true, value: void 0 });
+      signal.addEventListener("abort", () => resolve4({ done: true, value: void 0 }), {
         once: true
       });
     }),
@@ -20587,10 +21157,10 @@ function inputDiffStat(input) {
   let deletions = 0;
   for (const edit of input.edits) {
     if (edit === null || typeof edit !== "object" || Array.isArray(edit)) return void 0;
-    const stat = replacementDiffStat(edit, budget);
-    if (!stat) return void 0;
-    additions += stat.additions;
-    deletions += stat.deletions;
+    const stat2 = replacementDiffStat(edit, budget);
+    if (!stat2) return void 0;
+    additions += stat2.additions;
+    deletions += stat2.deletions;
   }
   return { additions, deletions };
 }
@@ -20976,7 +21546,7 @@ function terminalResultError(reason, failureHint) {
     case "turn_setup_failed":
       return "Claude could not start the turn.";
     case "blocking_limit":
-      return "Claude stopped: a usage limit blocked the request.";
+      return failureHint ?? "Claude stopped: a usage limit blocked the request.";
     case "rapid_refill_breaker":
       return "Claude stopped: the context refilled too quickly after compaction.";
     case "prompt_too_long":
@@ -21011,10 +21581,8 @@ function resultOutcome(result, failureHint) {
     return { status: "completed", errorMessage };
   }
   if (isInterruptedResult(result)) return { status: "interrupted", errorMessage };
-  return {
-    status: resultErrorsText(result).includes("cancel") ? "cancelled" : "failed",
-    errorMessage
-  };
+  const cancelled = resultErrorsText(result).includes("cancel");
+  return cancelled ? { status: "cancelled", errorMessage } : { status: "failed", errorMessage: errorMessage ?? failureHint };
 }
 function streamKindFromDeltaType(deltaType) {
   return deltaType.includes("thinking") ? "reasoning_text" : "assistant_text";
@@ -21111,92 +21679,6 @@ function describeUnknownSdkMessage(kind, message) {
   return preview ? `${kind} \u2014 ${preview}` : `${kind} (no displayable text content)`;
 }
 
-// src/sessionSettings.ts
-function toSessionPermissionUpdates(toolName, suggestions) {
-  const sessionScoped = (suggestions ?? []).map(
-    (suggestion) => ({ ...suggestion, destination: "session" })
-  );
-  if (sessionScoped.length > 0) {
-    return sessionScoped;
-  }
-  return [
-    {
-      type: "addRules",
-      rules: [{ toolName }],
-      behavior: "allow",
-      destination: "session"
-    }
-  ];
-}
-var CLAUDE_SESSION_SETTING_KEYS = [
-  "alwaysThinkingEnabled",
-  "fastMode",
-  "ultracode",
-  "autoCompactWindow"
-];
-function buildClaudeSessionSettings(input) {
-  return {
-    ...typeof input.thinking === "boolean" ? { alwaysThinkingEnabled: input.thinking } : {},
-    ...input.fastMode ? { fastMode: true } : {},
-    ...input.ultracode ? { ultracode: true } : {},
-    ...input.autoCompactWindow ? { autoCompactWindow: Number(input.autoCompactWindow) } : {}
-  };
-}
-function diffClaudeSessionSettings(previous, next) {
-  const patch = {};
-  let changed = false;
-  const track = (key) => {
-    if (previous[key] === next[key]) {
-      return;
-    }
-    changed = true;
-    patch[key] = next[key] ?? null;
-  };
-  for (const key of CLAUDE_SESSION_SETTING_KEYS) {
-    track(key);
-  }
-  return changed ? patch : void 0;
-}
-var CLAUDE_NATIVE_MODES = [
-  { id: "default", name: "Manual", description: "Always ask before making changes" },
-  { id: "acceptEdits", name: "Accept edits", description: "Automatically accept all file edits" },
-  { id: "plan", name: "Plan", description: "Create a plan before making changes" },
-  { id: "auto", name: "Auto", description: "Claude handles permission decisions" },
-  {
-    id: "bypassPermissions",
-    name: "Bypass permissions",
-    description: "Accepts all permissions"
-  }
-];
-var CLAUDE_DEFAULT_NATIVE_MODE_ID = "default";
-var CLAUDE_NATIVE_MODE_BY_RUNTIME_MODE = {
-  "approval-required": "default",
-  "auto-accept-edits": "acceptEdits",
-  auto: "auto",
-  "full-access": "bypassPermissions"
-};
-var CLAUDE_NATIVE_MODE_REPORT = {
-  nativeModes: CLAUDE_NATIVE_MODES.map((mode) => ({
-    id: mode.id,
-    name: mode.name,
-    description: mode.description
-  })),
-  currentNativeModeId: CLAUDE_DEFAULT_NATIVE_MODE_ID,
-  nativeModeByRuntimeMode: CLAUDE_NATIVE_MODE_BY_RUNTIME_MODE
-};
-function isClaudeNativeModeId(value) {
-  return CLAUDE_NATIVE_MODES.some((mode) => mode.id === value);
-}
-function claudePermissionModeFor(runtimeMode, nativeModeId) {
-  if (nativeModeId !== void 0 && isClaudeNativeModeId(nativeModeId)) return nativeModeId;
-  return CLAUDE_NATIVE_MODE_BY_RUNTIME_MODE[runtimeMode];
-}
-var CLAUDE_SETTING_SOURCES = [
-  "user",
-  "project",
-  "local"
-];
-
 // src/readOnlyDirectories.ts
 var GLOB_METACHARACTERS = /[*?[\]{}]/;
 function toClaudeAbsolutePath(directory) {
@@ -21222,8 +21704,8 @@ function claudeReadAllowRules(directories) {
 // src/sessions.ts
 import * as NodeFS3 from "node:fs";
 import * as NodeOS6 from "node:os";
-import * as NodePath6 from "node:path";
-import * as NodeProcess from "node:process";
+import * as NodePath7 from "node:path";
+import * as NodeProcess2 from "node:process";
 
 // ../../packages/ycodium-jsonl-stream/src/jsonlStream.ts
 var DEFAULT_MAX_RETAINED_CHARS = 8e6;
@@ -21851,7 +22333,7 @@ function listTranscriptFiles(transcriptDir, directory) {
   const scanned = matched.length > 0 ? matched : dirs;
   const found = [];
   for (const dir of scanned) {
-    const projectDir = NodePath6.join(transcriptDir, dir);
+    const projectDir = NodePath7.join(transcriptDir, dir);
     let names;
     try {
       names = NodeFS3.readdirSync(projectDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(TRANSCRIPT_SUFFIX)).map((entry) => entry.name);
@@ -21859,17 +22341,17 @@ function listTranscriptFiles(transcriptDir, directory) {
       continue;
     }
     for (const name of names) {
-      let stat;
+      let stat2;
       try {
-        stat = NodeFS3.statSync(NodePath6.join(projectDir, name));
+        stat2 = NodeFS3.statSync(NodePath7.join(projectDir, name));
       } catch {
         continue;
       }
       found.push({
-        path: NodePath6.join(projectDir, name),
+        path: NodePath7.join(projectDir, name),
         sessionId: name.slice(0, -TRANSCRIPT_SUFFIX.length),
-        size: stat.size,
-        mtimeMs: Number.isFinite(stat.mtimeMs) ? stat.mtimeMs : 0
+        size: stat2.size,
+        mtimeMs: Number.isFinite(stat2.mtimeMs) ? stat2.mtimeMs : 0
       });
     }
   }
@@ -21877,7 +22359,7 @@ function listTranscriptFiles(transcriptDir, directory) {
 }
 function readClaudeLiveSessionIds(configDir) {
   const live = /* @__PURE__ */ new Set();
-  const markerDir = NodePath6.join(configDir, "sessions");
+  const markerDir = NodePath7.join(configDir, "sessions");
   let entries;
   try {
     entries = NodeFS3.readdirSync(markerDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name);
@@ -21887,7 +22369,7 @@ function readClaudeLiveSessionIds(configDir) {
   for (const entry of entries) {
     let marker;
     try {
-      marker = JSON.parse(NodeFS3.readFileSync(NodePath6.join(markerDir, entry), "utf8"));
+      marker = JSON.parse(NodeFS3.readFileSync(NodePath7.join(markerDir, entry), "utf8"));
     } catch {
       continue;
     }
@@ -21895,7 +22377,7 @@ function readClaudeLiveSessionIds(configDir) {
     const typed = marker;
     if (typeof typed.pid !== "number" || typeof typed.sessionId !== "string") continue;
     try {
-      NodeProcess.kill(typed.pid, 0);
+      NodeProcess2.kill(typed.pid, 0);
     } catch {
       continue;
     }
@@ -21941,7 +22423,7 @@ async function scanClaudeSessions(input) {
 function resolveTranscriptPath(input) {
   const fileName = `${input.sessionId}${TRANSCRIPT_SUFFIX}`;
   if (input.cwd !== void 0 && input.cwd.length > 0) {
-    const direct = NodePath6.join(
+    const direct = NodePath7.join(
       input.transcriptDir,
       encodeClaudeProjectDirName(input.cwd),
       fileName
@@ -21958,7 +22440,7 @@ function resolveTranscriptPath(input) {
     return null;
   }
   for (const dir of dirs) {
-    const candidate = NodePath6.join(input.transcriptDir, dir, fileName);
+    const candidate = NodePath7.join(input.transcriptDir, dir, fileName);
     try {
       if (NodeFS3.statSync(candidate).isFile()) return candidate;
     } catch {
@@ -22417,69 +22899,28 @@ function normalizeClaudeTaskProgressTokenUsage(value, memory) {
   const usage = value;
   const snapshot = makeClaudeTokenUsageSnapshot({
     activeTokens,
-    ...memory.lastKnownContextWindow !== void 0 ? { contextWindow: memory.lastKnownContextWindow } : {},
-    totalProcessedTokens: Math.max(
-      totalTokens,
-      memory.lastKnownTotalProcessedTokens ?? totalTokens
-    )
-  });
-  if (!snapshot) {
-    return void 0;
-  }
-  const toolUses = finiteNonNegativeInteger(usage.tool_uses);
-  const durationMs = finiteNonNegativeInteger(usage.duration_ms);
-  return {
-    ...snapshot,
-    ...toolUses !== void 0 ? { toolUses } : {},
-    ...durationMs !== void 0 ? { durationMs } : {}
-  };
-}
-
-// src/probeModels.ts
-var toProbeCapabilities = (caps) => ({
-  optionDescriptors: caps.optionDescriptors.map(
-    (descriptor) => descriptor.type === "select" ? {
-      id: descriptor.id,
-      label: descriptor.label,
-      type: "select",
-      options: descriptor.options.map((option) => ({
-        id: option.id,
-        label: option.label,
-        ...option.description === void 0 ? {} : { description: option.description },
-        ...option.isDefault === void 0 ? {} : { isDefault: option.isDefault }
-      }))
-    } : {
-      id: descriptor.id,
-      label: descriptor.label,
-      type: "boolean"
-    }
-  )
-});
-var claudeProbeModels = (input) => {
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  for (const model of input.catalog) {
-    if (seen.has(model.slug)) continue;
-    seen.add(model.slug);
-    const userLabel = input.customModels.find((entry) => entry.slug === model.slug)?.label;
-    out.push({
-      slug: model.slug,
-      name: userLabel?.trim() || model.name,
-      capabilities: toProbeCapabilities(model.capabilities)
-    });
-  }
-  for (const model of input.customModels) {
-    if (model.slug.trim().length === 0 || seen.has(model.slug)) continue;
-    seen.add(model.slug);
-    out.push({ slug: model.slug, name: model.label?.trim() || model.slug });
+    ...memory.lastKnownContextWindow !== void 0 ? { contextWindow: memory.lastKnownContextWindow } : {},
+    totalProcessedTokens: Math.max(
+      totalTokens,
+      memory.lastKnownTotalProcessedTokens ?? totalTokens
+    )
+  });
+  if (!snapshot) {
+    return void 0;
   }
-  return out;
-};
+  const toolUses = finiteNonNegativeInteger(usage.tool_uses);
+  const durationMs = finiteNonNegativeInteger(usage.duration_ms);
+  return {
+    ...snapshot,
+    ...toolUses !== void 0 ? { toolUses } : {},
+    ...durationMs !== void 0 ? { durationMs } : {}
+  };
+}
 
 // src/textGeneration.ts
-import * as NodeFSP2 from "node:fs/promises";
+import * as NodeFSP3 from "node:fs/promises";
 import * as NodeOS7 from "node:os";
-import * as NodePath7 from "node:path";
+import * as NodePath8 from "node:path";
 import { mergeLaunchEnv } from "@ycodium-ai/plugin-api/executor";
 
 // src/textGenerationUtils.ts
@@ -22948,16 +23389,16 @@ function createClaudeTextGeneration(recipe, host, modelCatalog) {
       return decodeStructuredOutput(stdout, input.operation);
     };
     if (input.operation !== "generateThreadTitle") return runIn(input.cwd);
-    const scratchDirectory = await NodeFSP2.mkdtemp(
-      NodePath7.join(NodeOS7.tmpdir(), "ycodium-claude-title-")
+    const scratchDirectory = await NodeFSP3.mkdtemp(
+      NodePath8.join(NodeOS7.tmpdir(), "ycodium-claude-title-")
     );
     try {
       return await runIn(scratchDirectory);
     } finally {
-      await NodeFSP2.rm(scratchDirectory, { recursive: true, force: true }).catch(() => void 0);
+      await NodeFSP3.rm(scratchDirectory, { recursive: true, force: true }).catch(() => void 0);
     }
   };
-  const asRecord = (value, operation) => {
+  const asRecord2 = (value, operation) => {
     if (!isRecord5(value))
       throw new Error(`${operation}: Claude returned invalid structured output.`);
     return value;
@@ -22965,7 +23406,7 @@ function createClaudeTextGeneration(recipe, host, modelCatalog) {
   return {
     generateCommitMessage: async (raw, signal) => {
       try {
-        const input = asRecord(raw, "generateCommitMessage");
+        const input = asRecord2(raw, "generateCommitMessage");
         const includeBranch = input["includeBranch"] === true;
         const { prompt, outputSchema } = buildCommitMessagePrompt({
           branch: typeof input["branch"] === "string" ? input["branch"] : null,
@@ -22974,7 +23415,7 @@ function createClaudeTextGeneration(recipe, host, modelCatalog) {
           includeBranch,
           ...isRecord5(input["policy"]) ? { policy: input["policy"] } : {}
         });
-        const generated = asRecord(
+        const generated = asRecord2(
           await runClaudeJson({
             operation: "generateCommitMessage",
             cwd: readString3(input["cwd"]) || ".",
@@ -22993,114 +23434,799 @@ function createClaudeTextGeneration(recipe, host, modelCatalog) {
       } catch (error) {
         throw normalizeCliError("claude", error, "Failed to generate commit message");
       }
-    },
-    generatePrContent: async (raw, signal) => {
-      try {
-        const input = asRecord(raw, "generatePrContent");
-        const { prompt, outputSchema } = buildPrContentPrompt({
-          baseBranch: readString3(input["baseBranch"]),
-          headBranch: readString3(input["headBranch"]),
-          commitSummary: readString3(input["commitSummary"]),
-          diffSummary: readString3(input["diffSummary"]),
-          diffPatch: readString3(input["diffPatch"]),
-          ...typeof input["changeRequestTemplate"] === "string" ? { changeRequestTemplate: input["changeRequestTemplate"] } : {},
-          ...isRecord5(input["policy"]) ? { policy: input["policy"] } : {}
-        });
-        const generated = asRecord(
-          await runClaudeJson({
-            operation: "generatePrContent",
-            cwd: readString3(input["cwd"]) || ".",
-            prompt,
-            outputSchema,
-            modelSelection: input["modelSelection"],
-            ...signal === void 0 ? {} : { signal }
-          }),
-          "generatePrContent"
-        );
-        return {
-          title: sanitizePrTitle(readString3(generated["title"])),
-          body: readString3(generated["body"]).trim()
-        };
-      } catch (error) {
-        throw normalizeCliError("claude", error, "Failed to generate change request content");
+    },
+    generatePrContent: async (raw, signal) => {
+      try {
+        const input = asRecord2(raw, "generatePrContent");
+        const { prompt, outputSchema } = buildPrContentPrompt({
+          baseBranch: readString3(input["baseBranch"]),
+          headBranch: readString3(input["headBranch"]),
+          commitSummary: readString3(input["commitSummary"]),
+          diffSummary: readString3(input["diffSummary"]),
+          diffPatch: readString3(input["diffPatch"]),
+          ...typeof input["changeRequestTemplate"] === "string" ? { changeRequestTemplate: input["changeRequestTemplate"] } : {},
+          ...isRecord5(input["policy"]) ? { policy: input["policy"] } : {}
+        });
+        const generated = asRecord2(
+          await runClaudeJson({
+            operation: "generatePrContent",
+            cwd: readString3(input["cwd"]) || ".",
+            prompt,
+            outputSchema,
+            modelSelection: input["modelSelection"],
+            ...signal === void 0 ? {} : { signal }
+          }),
+          "generatePrContent"
+        );
+        return {
+          title: sanitizePrTitle(readString3(generated["title"])),
+          body: readString3(generated["body"]).trim()
+        };
+      } catch (error) {
+        throw normalizeCliError("claude", error, "Failed to generate change request content");
+      }
+    },
+    generateBranchName: async (raw, signal) => {
+      try {
+        const input = asRecord2(raw, "generateBranchName");
+        const { prompt, outputSchema } = buildBranchNamePrompt({
+          message: readString3(input["message"]),
+          ...Array.isArray(input["attachments"]) ? { attachments: input["attachments"] } : {},
+          ...isRecord5(input["policy"]) ? { policy: input["policy"] } : {}
+        });
+        const generated = asRecord2(
+          await runClaudeJson({
+            operation: "generateBranchName",
+            cwd: readString3(input["cwd"]) || ".",
+            prompt,
+            outputSchema,
+            modelSelection: input["modelSelection"],
+            ...signal === void 0 ? {} : { signal }
+          }),
+          "generateBranchName"
+        );
+        return { branch: sanitizeBranchFragment(readString3(generated["branch"])) };
+      } catch (error) {
+        throw normalizeCliError("claude", error, "Failed to generate branch name");
+      }
+    },
+    generateThreadTitle: async (raw, signal) => {
+      try {
+        const input = asRecord2(raw, "generateThreadTitle");
+        const { prompt, outputSchema } = buildThreadTitlePrompt({
+          message: readString3(input["message"]),
+          ...typeof input["linkedContext"] === "string" && input["linkedContext"].length > 0 ? { linkedContext: input["linkedContext"] } : {},
+          ...typeof input["previousTitle"] === "string" ? { previousTitle: input["previousTitle"] } : {},
+          ...Array.isArray(input["attachments"]) ? { attachments: input["attachments"] } : {},
+          ...isRecord5(input["policy"]) ? { policy: input["policy"] } : {}
+        });
+        const generated = asRecord2(
+          await runClaudeJson({
+            operation: "generateThreadTitle",
+            cwd: readString3(input["cwd"]) || ".",
+            prompt,
+            outputSchema,
+            modelSelection: input["modelSelection"],
+            ...signal === void 0 ? {} : { signal }
+          }),
+          "generateThreadTitle"
+        );
+        return {
+          title: sanitizeThreadTitle(readString3(generated["title"])),
+          ...generated["needsRefinement"] === true ? { needsRefinement: true } : {}
+        };
+      } catch (error) {
+        throw normalizeCliError("claude", error, "Failed to generate thread title");
+      }
+    },
+    summarizeHandover: async (raw, signal) => {
+      try {
+        const input = asRecord2(raw, "summarizeHandover");
+        const { prompt, outputSchema } = buildHandoverSummaryPrompt({
+          transcript: readString3(input["transcript"])
+        });
+        const generated = asRecord2(
+          await runClaudeJson({
+            operation: "summarizeHandover",
+            cwd: readString3(input["cwd"]) || ".",
+            prompt,
+            outputSchema,
+            modelSelection: input["modelSelection"],
+            ...signal === void 0 ? {} : { signal }
+          }),
+          "summarizeHandover"
+        );
+        return { summary: readString3(generated["summary"]).trim() };
+      } catch (error) {
+        throw normalizeCliError("claude", error, "Failed to summarize handover");
+      }
+    }
+  };
+}
+
+// src/usageRead/index.ts
+import * as NodePath12 from "node:path";
+
+// src/usageRead/quota.ts
+import * as NodeFS4 from "node:fs";
+import * as NodePath9 from "node:path";
+import { mergeLaunchEnv as mergeLaunchEnv2, setsOwnModelConnection } from "@ycodium-ai/plugin-api/executor";
+import {
+  parseRetryAfterMs
+} from "@ycodium-ai/plugin-api/usage";
+var CLAUDE_QUOTA_URL = "https://api.anthropic.com/api/oauth/usage";
+var REQUEST_TIMEOUT_MS = 1e4;
+var HOUR_MS = 60 * 60 * 1e3;
+var WINDOWS = [
+  { field: "five_hour", id: "session", labelKey: "usage.window.session", windowMs: 5 * HOUR_MS },
+  { field: "seven_day", id: "weekly", labelKey: "usage.window.weekly", windowMs: 7 * 24 * HOUR_MS }
+];
+var isRecord6 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var launchEnvironment = (recipe) => mergeLaunchEnv2({
+  inherited: process.env,
+  instanceTable: recipe.environment,
+  handOverrides: claudeHomeVariables(resolveClaudeHomeLayout(recipe))
+});
+var claudeCredentialFileCandidates = (recipe) => {
+  const environment = launchEnvironment(recipe);
+  const credentialsDir = resolveClaudeCredentialsDirPath(
+    environment[CLAUDE_CREDENTIALS_DIR_ENVIRONMENT_VARIABLE] ?? ""
+  );
+  if (credentialsDir !== null) return [NodePath9.join(credentialsDir, ".credentials.json")];
+  const configDir = resolveClaudeConfigDirPath(recipe.homePath, environment);
+  const home = resolveClaudeHomePath(recipe.homePath);
+  return [
+    .../* @__PURE__ */ new Set([
+      NodePath9.join(configDir, ".credentials.json"),
+      NodePath9.join(home, ".claude", ".credentials.json"),
+      NodePath9.join(home, ".credentials.json")
+    ])
+  ];
+};
+var readString4 = (value) => typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+var readLoginCredential = (candidates) => {
+  for (const path of candidates) {
+    let raw;
+    try {
+      raw = NodeFS4.readFileSync(path, "utf8");
+    } catch {
+      continue;
+    }
+    if (raw.trim().length === 0) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    const oauth = isRecord6(parsed) ? parsed["claudeAiOauth"] : void 0;
+    if (!isRecord6(oauth)) continue;
+    const accessToken = readString4(oauth["accessToken"]);
+    if (accessToken === void 0) continue;
+    return {
+      accessToken,
+      subscriptionType: readString4(oauth["subscriptionType"]),
+      rateLimitTier: readString4(oauth["rateLimitTier"]),
+      path
+    };
+  }
+  return null;
+};
+var claudePlanName = (credential) => {
+  const type4 = credential.subscriptionType;
+  if (type4 === void 0) return void 0;
+  const name = `${type4.charAt(0).toUpperCase()}${type4.slice(1)}`;
+  const multiplier = /(?:^|_)(\d+x)$/.exec(credential.rateLimitTier ?? "")?.[1];
+  return multiplier === void 0 ? name : `${name} ${multiplier}`;
+};
+var toIso = (value) => {
+  if (typeof value !== "string") return null;
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? null : new Date(parsed).toISOString();
+};
+var readWindows = (body) => WINDOWS.flatMap((spec) => {
+  const row = body[spec.field];
+  if (!isRecord6(row)) return [];
+  const utilization = row["utilization"];
+  if (typeof utilization !== "number" || !Number.isFinite(utilization)) return [];
+  return [
+    {
+      id: spec.id,
+      label: { key: spec.labelKey },
+      usedPercent: Math.min(100, Math.max(0, utilization)),
+      resetsAt: toIso(row["resets_at"]),
+      windowMs: spec.windowMs
+    }
+  ];
+});
+var readClaudeQuota = async (request) => {
+  const { recipe } = request;
+  const connectivity = CLAUDE_CARD.modelConnectivity;
+  const environmentRows = Object.entries(recipe.environment).map(([name, value]) => ({
+    name,
+    value
+  }));
+  if (connectivity !== void 0 && setsOwnModelConnection(connectivity, environmentRows)) {
+    const changesEndpoint = setsOwnModelConnection(
+      {
+        baseUrlEnvKey: connectivity.baseUrlEnvKey,
+        backendSwitchEnvKeys: connectivity.backendSwitchEnvKeys
+      },
+      environmentRows
+    );
+    return {
+      status: "unavailable",
+      reason: changesEndpoint ? "customEndpoint" : "unsupportedLogin"
+    };
+  }
+  const credential = readLoginCredential(claudeCredentialFileCandidates(recipe));
+  if (credential === null) return { status: "unavailable", reason: "missingCredentials" };
+  const now = request.now ?? Date.now;
+  let response;
+  try {
+    response = await request.fetch(CLAUDE_QUOTA_URL, {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+        "anthropic-beta": "oauth-2025-04-20",
+        Authorization: `Bearer ${credential.accessToken}`
+      },
+      redirect: "error",
+      signal: request.signal === void 0 ? AbortSignal.timeout(REQUEST_TIMEOUT_MS) : AbortSignal.any([request.signal, AbortSignal.timeout(REQUEST_TIMEOUT_MS)])
+    });
+  } catch (cause) {
+    if (request.signal?.aborted === true) throw cause;
+    return { status: "unavailable", reason: "unreachable" };
+  }
+  const release = () => {
+    void response.body?.cancel().catch(() => void 0);
+  };
+  if (response.status === 429) {
+    const retryAfterMs = parseRetryAfterMs(response.headers.get("Retry-After"), now());
+    release();
+    return {
+      status: "unavailable",
+      reason: "rateLimited",
+      ...retryAfterMs === null ? {} : { retryAfterMs }
+    };
+  }
+  if (response.status === 401 || response.status === 403) {
+    release();
+    return { status: "unavailable", reason: "authRejected" };
+  }
+  if (response.status < 200 || response.status >= 300) {
+    release();
+    return { status: "unavailable", reason: "unreachable" };
+  }
+  let body;
+  try {
+    body = JSON.parse(await response.text());
+  } catch {
+    return { status: "unavailable", reason: "unreachable" };
+  }
+  if (!isRecord6(body)) return { status: "unavailable", reason: "unreachable" };
+  const plan = claudePlanName(credential);
+  return {
+    status: "available",
+    ...plan === void 0 ? {} : { plan },
+    windows: readWindows(body),
+    balances: [],
+    accountKey: credential.path
+  };
+};
+
+// src/usageRead/scanCache.ts
+import * as NodePath11 from "node:path";
+
+// src/usageRead/transcriptScan.ts
+import * as NodeFS5 from "node:fs";
+import * as NodePath10 from "node:path";
+
+// src/usageRead/transcriptLine.ts
+var int = (value) => typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.trunc(value) : 0;
+var parseTimestampMs = (value) => {
+  if (typeof value !== "string") return null;
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? null : parsed;
+};
+var mightCarryUsage = (line) => line.includes('"usage"');
+var parseClaudeLine = (line) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null) return null;
+  const record = parsed;
+  if (record["type"] !== "assistant") return null;
+  const message = record["message"];
+  if (typeof message !== "object" || message === null) return null;
+  const messageRecord = message;
+  const usage = messageRecord["usage"];
+  if (typeof usage !== "object" || usage === null) return null;
+  const usageRecord = usage;
+  const timestampMs = parseTimestampMs(record["timestamp"]);
+  if (timestampMs === null) return null;
+  const model = typeof messageRecord["model"] === "string" ? messageRecord["model"] : "";
+  if (model.length === 0) return null;
+  const messageId = typeof messageRecord["id"] === "string" ? messageRecord["id"] : null;
+  const requestId = typeof record["requestId"] === "string" ? record["requestId"] : null;
+  const dedupeKey = messageId === null && requestId === null ? null : `${messageId ?? ""}:${requestId ?? ""}`;
+  const cost = record["costUSD"];
+  return {
+    timestampMs,
+    model,
+    sessionId: typeof record["sessionId"] === "string" ? record["sessionId"] : "",
+    totals: {
+      uncachedInputTokens: int(usageRecord["input_tokens"]),
+      cachedInputTokens: int(usageRecord["cache_read_input_tokens"]),
+      cacheCreationTokens: int(usageRecord["cache_creation_input_tokens"]),
+      outputTokens: int(usageRecord["output_tokens"]),
+      reasoningTokens: 0
+    },
+    reportedCostUsd: typeof cost === "number" && Number.isFinite(cost) ? cost : null,
+    dedupeKey
+  };
+};
+
+// src/usageRead/transcriptScan.ts
+var TRANSCRIPT_SUFFIX2 = ".jsonl";
+async function listTranscriptFiles2(root, sinceMs) {
+  const found = [];
+  const walk = async (dir) => {
+    let entries;
+    try {
+      entries = await NodeFS5.promises.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const child = NodePath10.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(child);
+        continue;
+      }
+      if (!entry.isFile() || !entry.name.endsWith(TRANSCRIPT_SUFFIX2)) continue;
+      let stat2;
+      try {
+        stat2 = await NodeFS5.promises.stat(child);
+      } catch {
+        continue;
+      }
+      if (stat2.mtimeMs < sinceMs) continue;
+      found.push({ path: child, size: stat2.size, mtimeMs: stat2.mtimeMs });
+    }
+  };
+  await walk(root);
+  return found;
+}
+async function statTranscriptRoot(root) {
+  try {
+    const stat2 = await NodeFS5.promises.stat(root);
+    if (!stat2.isDirectory()) return null;
+    return { volumeId: stat2.ino === 0 ? "" : `${String(stat2.dev)}:${String(stat2.ino)}` };
+  } catch {
+    return null;
+  }
+}
+var GUARD_LENGTH = 64;
+var NEWLINE = 10;
+var CARRIAGE_RETURN = 13;
+var fnv1a = (bytes) => {
+  let hash = 2166136261;
+  for (let index = 0; index < bytes.length; index += 1) {
+    hash ^= bytes[index];
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+};
+var asBuffer = (chunk) => typeof chunk === "string" ? Buffer.from(chunk) : Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+async function readMatchingGuard(filePath, position) {
+  const { guardLength, resumeOffset } = position;
+  if (guardLength <= 0 || guardLength > GUARD_LENGTH || guardLength > resumeOffset) return null;
+  try {
+    const chunks = [];
+    for await (const chunk of NodeFS5.createReadStream(filePath, {
+      start: resumeOffset - guardLength,
+      end: resumeOffset - 1
+    })) {
+      chunks.push(asBuffer(chunk));
+    }
+    const window2 = Buffer.concat(chunks);
+    return window2.length === guardLength && fnv1a(window2) === position.guardHash ? window2 : null;
+  } catch {
+    return null;
+  }
+}
+async function readTranscriptRecords(filePath, resumeFrom) {
+  try {
+    let resumed = false;
+    let start = 0;
+    let guardWindow = Buffer.alloc(0);
+    if (resumeFrom !== void 0 && resumeFrom.resumeOffset > 0) {
+      const window2 = await readMatchingGuard(filePath, resumeFrom);
+      if (window2 !== null) {
+        start = resumeFrom.resumeOffset;
+        guardWindow = window2;
+        resumed = true;
+      }
+    }
+    const parseLine = (line, out) => {
+      if (!mightCarryUsage(line)) return;
+      const record = parseClaudeLine(line);
+      if (record !== null) out.push(record);
+    };
+    const toLineString = (lineBuffer) => {
+      const content = lineBuffer.length > 0 && lineBuffer[lineBuffer.length - 1] === CARRIAGE_RETURN ? lineBuffer.subarray(0, -1) : lineBuffer;
+      return content.toString("utf8");
+    };
+    const records = [];
+    let resumeOffset = start;
+    let pendingChunks = [];
+    for await (const raw of NodeFS5.createReadStream(filePath, start > 0 ? { start } : void 0)) {
+      const chunk = asBuffer(raw);
+      if (!chunk.includes(NEWLINE)) {
+        pendingChunks.push(chunk);
+        continue;
+      }
+      const buffer = pendingChunks.length === 0 ? chunk : Buffer.concat([...pendingChunks, chunk]);
+      pendingChunks = [];
+      let lineStart = 0;
+      for (; ; ) {
+        const newlineIndex = buffer.indexOf(NEWLINE, lineStart);
+        if (newlineIndex === -1) break;
+        parseLine(toLineString(buffer.subarray(lineStart, newlineIndex)), records);
+        lineStart = newlineIndex + 1;
+      }
+      resumeOffset += lineStart;
+      const consumed = buffer.subarray(0, lineStart);
+      guardWindow = consumed.length >= GUARD_LENGTH ? Buffer.from(consumed.subarray(-GUARD_LENGTH)) : Buffer.concat([guardWindow, consumed]).subarray(-GUARD_LENGTH);
+      if (lineStart < buffer.length) pendingChunks.push(buffer.subarray(lineStart));
+    }
+    const tailRecords = [];
+    if (pendingChunks.length > 0) {
+      const pending = pendingChunks.length === 1 ? pendingChunks[0] : Buffer.concat(pendingChunks);
+      if (pending.length > 0) parseLine(toLineString(pending), tailRecords);
+    }
+    return {
+      records,
+      tailRecords,
+      position: {
+        resumeOffset,
+        guardLength: guardWindow.length,
+        guardHash: guardWindow.length > 0 ? fnv1a(guardWindow) : 0
+      },
+      resumed
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/usageRead/scanCache.ts
+var USAGE_SCAN_CACHE_VERSION = 1;
+function encodeScanCache(cache) {
+  const models = [];
+  const sessions = [];
+  const modelIndex = /* @__PURE__ */ new Map();
+  const sessionIndex = /* @__PURE__ */ new Map();
+  const intern = (table, index, value) => {
+    const existing = index.get(value);
+    if (existing !== void 0) return existing;
+    const next = table.length;
+    table.push(value);
+    index.set(value, next);
+    return next;
+  };
+  const serializeRecord = (record) => [
+    record.timestampMs,
+    intern(models, modelIndex, record.model),
+    intern(sessions, sessionIndex, record.sessionId),
+    record.totals.uncachedInputTokens,
+    record.totals.cachedInputTokens,
+    record.totals.cacheCreationTokens,
+    record.totals.outputTokens,
+    record.totals.reasoningTokens,
+    record.dedupeKey,
+    record.reportedCostUsd
+  ];
+  const files = {};
+  for (const [path, entry] of cache) {
+    files[path] = {
+      s: entry.size,
+      m: entry.mtimeMs,
+      r: entry.records.map(serializeRecord),
+      t: entry.tailRecords.map(serializeRecord),
+      o: entry.position.resumeOffset,
+      gl: entry.position.guardLength,
+      gh: entry.position.guardHash
+    };
+  }
+  return { version: USAGE_SCAN_CACHE_VERSION, models, sessions, files };
+}
+function decodeScanCache(document) {
+  const cache = /* @__PURE__ */ new Map();
+  if (typeof document !== "object" || document === null) return cache;
+  const root = document;
+  if (root.version !== USAGE_SCAN_CACHE_VERSION) return cache;
+  if (!Array.isArray(root.models) || !Array.isArray(root.sessions)) return cache;
+  if (typeof root.files !== "object" || root.files === null) return cache;
+  if (!root.models.every((value) => typeof value === "string")) return cache;
+  if (!root.sessions.every((value) => typeof value === "string")) return cache;
+  const models = root.models;
+  const sessions = root.sessions;
+  const decodeRecords = (rows) => {
+    const records = [];
+    for (const row of rows) {
+      if (!Array.isArray(row) || row.length < 10) return null;
+      const [
+        timestampMs,
+        modelIndex,
+        sessionIndex,
+        uncached,
+        cached,
+        cacheCreation,
+        output,
+        reasoning,
+        dedupeKey,
+        reportedCostUsd
+      ] = row;
+      const model = typeof modelIndex === "number" ? models[modelIndex] : void 0;
+      if (typeof timestampMs !== "number" || !Number.isFinite(timestampMs) || model === void 0 || !Number.isFinite(uncached) || !Number.isFinite(cached) || !Number.isFinite(cacheCreation) || !Number.isFinite(output) || !Number.isFinite(reasoning)) {
+        return null;
+      }
+      records.push({
+        timestampMs,
+        model,
+        sessionId: (typeof sessionIndex === "number" ? sessions[sessionIndex] : void 0) ?? "",
+        totals: {
+          uncachedInputTokens: uncached,
+          cachedInputTokens: cached,
+          cacheCreationTokens: cacheCreation,
+          outputTokens: output,
+          reasoningTokens: reasoning
+        },
+        reportedCostUsd: typeof reportedCostUsd === "number" ? reportedCostUsd : null,
+        dedupeKey: typeof dedupeKey === "string" ? dedupeKey : null
+      });
+    }
+    return records;
+  };
+  for (const [path, raw] of Object.entries(root.files)) {
+    if (typeof raw !== "object" || raw === null) continue;
+    const entry = raw;
+    if (typeof entry.s !== "number" || typeof entry.m !== "number") continue;
+    if (!Array.isArray(entry.r) || !Array.isArray(entry.t)) continue;
+    if (typeof entry.o !== "number" || !Number.isSafeInteger(entry.o) || entry.o < 0 || typeof entry.gl !== "number" || !Number.isSafeInteger(entry.gl) || entry.gl < 0 || entry.gl > GUARD_LENGTH || entry.gl > entry.o || typeof entry.gh !== "number" || !Number.isFinite(entry.gh)) {
+      continue;
+    }
+    const records = decodeRecords(entry.r);
+    const tailRecords = decodeRecords(entry.t);
+    if (records === null || tailRecords === null) continue;
+    cache.set(path, {
+      size: entry.s,
+      mtimeMs: entry.m,
+      records,
+      tailRecords,
+      position: { resumeOffset: entry.o, guardLength: entry.gl, guardHash: entry.gh }
+    });
+  }
+  return cache;
+}
+function pruneScanCache(cache, options) {
+  let removed = 0;
+  for (const [path, entry] of cache) {
+    const agedOut = entry.mtimeMs < options.retentionCutoffMs;
+    const underWalkedRoot = options.walkedRoots.some((root) => {
+      const relative2 = NodePath11.relative(root, path);
+      return relative2 === "" || relative2 !== ".." && !relative2.startsWith(`..${NodePath11.sep}`) && !NodePath11.isAbsolute(relative2);
+    });
+    const deleted = underWalkedRoot && entry.mtimeMs >= options.windowStartMs && !options.livePaths.has(path);
+    if (agedOut || deleted) {
+      cache.delete(path);
+      removed += 1;
+    }
+  }
+  return removed;
+}
+function dedupeWithinFile(records, seen = /* @__PURE__ */ new Set()) {
+  const kept = [];
+  for (const record of records) {
+    if (record.dedupeKey !== null) {
+      if (seen.has(record.dedupeKey)) continue;
+      seen.add(record.dedupeKey);
+    }
+    kept.push(record);
+  }
+  return kept;
+}
+
+// src/usageRead/tokenUsage.ts
+var MTIME_SLACK_MS = 36 * 60 * 60 * 1e3;
+var CACHE_RETENTION_MS = 90 * 24 * 60 * 60 * 1e3;
+var SCAN_CACHE_KEY_PREFIX = "claude-usage-scan:";
+var runtimes = /* @__PURE__ */ new Map();
+var runtimeFor = (root) => {
+  let runtime = runtimes.get(root);
+  if (runtime === void 0) {
+    runtime = { fileCache: /* @__PURE__ */ new Map(), loaded: void 0, dirty: false, queue: Promise.resolve() };
+    runtimes.set(root, runtime);
+  }
+  return runtime;
+};
+var ensureLoaded = (runtime, root, cache) => {
+  runtime.loaded ??= (async () => {
+    if (cache === void 0) return;
+    const cached = await cache.getJson(`${SCAN_CACHE_KEY_PREFIX}${root}`).catch(() => null);
+    if (cached === null) return;
+    for (const [path, entry] of decodeScanCache(cached.value)) runtime.fileCache.set(path, entry);
+  })();
+  return runtime.loaded;
+};
+var readFileRecords = async (runtime, filePath, size, mtimeMs) => {
+  const cached = runtime.fileCache.get(filePath);
+  if (cached && cached.size === size && cached.mtimeMs === mtimeMs) {
+    return cached.tailRecords.length === 0 ? cached.records : [...cached.records, ...cached.tailRecords];
+  }
+  const resumeFrom = cached !== void 0 && size > cached.size ? cached.position : void 0;
+  const parsed = await readTranscriptRecords(filePath, resumeFrom);
+  if (parsed === null) return null;
+  const base = parsed.resumed && cached !== void 0 ? cached.records : [];
+  const seen = /* @__PURE__ */ new Set();
+  const records = dedupeWithinFile([...base, ...parsed.records], seen);
+  const tailRecords = dedupeWithinFile(parsed.tailRecords, seen);
+  runtime.fileCache.set(filePath, {
+    size,
+    mtimeMs,
+    records,
+    tailRecords,
+    position: parsed.position
+  });
+  runtime.dirty = true;
+  return tailRecords.length === 0 ? records : [...records, ...tailRecords];
+};
+var createClaudeTokenReader = (options) => {
+  const { configDir, transcriptRoot, cache } = options;
+  const scan = async (input) => {
+    const sinceMs = Date.parse(input.since);
+    const untilMs = Date.parse(input.until);
+    if (Number.isNaN(sinceMs) || Number.isNaN(untilMs)) {
+      throw new Error(`readTokenUsage: invalid window '${input.since}'..'${input.until}'`);
+    }
+    const root = await statTranscriptRoot(transcriptRoot);
+    if (root === null) {
+      return {
+        records: [],
+        source: {
+          homePath: configDir,
+          status: "missing",
+          scannedFiles: 0,
+          skippedFiles: 0,
+          message: "No Claude Code session records found on this machine."
+        }
+      };
+    }
+    const runtime = runtimeFor(transcriptRoot);
+    await ensureLoaded(runtime, transcriptRoot, cache);
+    const startedAtMs = Date.now();
+    const windowStartMs = sinceMs - MTIME_SLACK_MS;
+    const files = (await listTranscriptFiles2(transcriptRoot, windowStartMs)).toSorted(
+      (a, b3) => a.path < b3.path ? -1 : a.path > b3.path ? 1 : 0
+    );
+    let scannedFiles = 0;
+    let skippedFiles = 0;
+    let failedFiles = 0;
+    const livePaths = /* @__PURE__ */ new Set();
+    const seen = /* @__PURE__ */ new Set();
+    const records = [];
+    for (const file of files) {
+      input.signal?.throwIfAborted();
+      livePaths.add(file.path);
+      const fileRecords = await readFileRecords(runtime, file.path, file.size, file.mtimeMs);
+      if (fileRecords === null) {
+        failedFiles += 1;
+        continue;
+      }
+      if (fileRecords.length === 0) {
+        skippedFiles += 1;
+        continue;
       }
-    },
-    generateBranchName: async (raw, signal) => {
-      try {
-        const input = asRecord(raw, "generateBranchName");
-        const { prompt, outputSchema } = buildBranchNamePrompt({
-          message: readString3(input["message"]),
-          ...Array.isArray(input["attachments"]) ? { attachments: input["attachments"] } : {},
-          ...isRecord5(input["policy"]) ? { policy: input["policy"] } : {}
+      scannedFiles += 1;
+      for (const record of fileRecords) {
+        if (record.dedupeKey !== null) {
+          if (seen.has(record.dedupeKey)) continue;
+          seen.add(record.dedupeKey);
+        }
+        if (record.timestampMs < sinceMs || record.timestampMs >= untilMs) continue;
+        records.push({
+          at: new Date(record.timestampMs).toISOString(),
+          model: record.model,
+          ...record.sessionId.length > 0 ? { sessionId: record.sessionId } : {},
+          totals: record.totals,
+          ...record.reportedCostUsd === null ? {} : { reportedCostUsd: record.reportedCostUsd }
         });
-        const generated = asRecord(
-          await runClaudeJson({
-            operation: "generateBranchName",
-            cwd: readString3(input["cwd"]) || ".",
-            prompt,
-            outputSchema,
-            modelSelection: input["modelSelection"],
-            ...signal === void 0 ? {} : { signal }
-          }),
-          "generateBranchName"
-        );
-        return { branch: sanitizeBranchFragment(readString3(generated["branch"])) };
-      } catch (error) {
-        throw normalizeCliError("claude", error, "Failed to generate branch name");
       }
-    },
-    generateThreadTitle: async (raw, signal) => {
+    }
+    const pruned = pruneScanCache(runtime.fileCache, {
+      livePaths,
+      walkedRoots: [transcriptRoot],
+      windowStartMs,
+      retentionCutoffMs: startedAtMs - CACHE_RETENTION_MS
+    });
+    if (pruned > 0) runtime.dirty = true;
+    if (runtime.dirty && cache !== void 0) {
       try {
-        const input = asRecord(raw, "generateThreadTitle");
-        const { prompt, outputSchema } = buildThreadTitlePrompt({
-          message: readString3(input["message"]),
-          ...typeof input["linkedContext"] === "string" && input["linkedContext"].length > 0 ? { linkedContext: input["linkedContext"] } : {},
-          ...typeof input["previousTitle"] === "string" ? { previousTitle: input["previousTitle"] } : {},
-          ...Array.isArray(input["attachments"]) ? { attachments: input["attachments"] } : {},
-          ...isRecord5(input["policy"]) ? { policy: input["policy"] } : {}
-        });
-        const generated = asRecord(
-          await runClaudeJson({
-            operation: "generateThreadTitle",
-            cwd: readString3(input["cwd"]) || ".",
-            prompt,
-            outputSchema,
-            modelSelection: input["modelSelection"],
-            ...signal === void 0 ? {} : { signal }
-          }),
-          "generateThreadTitle"
+        await cache.setJson(
+          `${SCAN_CACHE_KEY_PREFIX}${transcriptRoot}`,
+          encodeScanCache(runtime.fileCache)
         );
-        return {
-          title: sanitizeThreadTitle(readString3(generated["title"])),
-          ...generated["needsRefinement"] === true ? { needsRefinement: true } : {}
-        };
-      } catch (error) {
-        throw normalizeCliError("claude", error, "Failed to generate thread title");
+        runtime.dirty = false;
+      } catch {
       }
-    },
-    summarizeHandover: async (raw, signal) => {
-      try {
-        const input = asRecord(raw, "summarizeHandover");
-        const { prompt, outputSchema } = buildHandoverSummaryPrompt({
-          transcript: readString3(input["transcript"])
-        });
-        const generated = asRecord(
-          await runClaudeJson({
-            operation: "summarizeHandover",
-            cwd: readString3(input["cwd"]) || ".",
-            prompt,
-            outputSchema,
-            modelSelection: input["modelSelection"],
-            ...signal === void 0 ? {} : { signal }
-          }),
-          "summarizeHandover"
-        );
-        return { summary: readString3(generated["summary"]).trim() };
-      } catch (error) {
-        throw normalizeCliError("claude", error, "Failed to summarize handover");
+    }
+    return {
+      records,
+      source: {
+        homePath: configDir,
+        volumeId: root.volumeId,
+        status: failedFiles > 0 ? "partial" : "ok",
+        scannedFiles,
+        skippedFiles,
+        ...failedFiles > 0 ? { message: `${String(failedFiles)} session record file(s) could not be read.` } : {}
       }
+    };
+  };
+  return {
+    readTokenUsage: (input) => {
+      const runtime = runtimeFor(transcriptRoot);
+      const run = runtime.queue.then(() => scan(input));
+      runtime.queue = run.catch(() => void 0);
+      return run;
     }
   };
+};
+
+// src/usageRead/index.ts
+var createClaudeUsage = (input) => {
+  const { recipe, host } = input;
+  const configDir = resolveClaudeConfigDirPath(recipe.homePath, {
+    ...process.env,
+    ...recipe.environment
+  });
+  const tokens = createClaudeTokenReader({
+    configDir,
+    transcriptRoot: NodePath12.join(configDir, "projects"),
+    cache: input.cache
+  });
+  return {
+    readQuota: ({ signal }) => readClaudeQuota({ recipe, fetch: host.fetch, signal }),
+    readTokenUsage: tokens.readTokenUsage
+  };
+};
+
+// src/claudeSkillDispatch.ts
+var SKILL_MENTION_PATTERN = /(^|\s)\$([a-zA-Z][a-zA-Z0-9:_-]*)(?=\s|$)/g;
+function planClaudeSkillDispatch(prompt, skillNames) {
+  const mentions = [...prompt.matchAll(SKILL_MENTION_PATTERN)].flatMap((match) => {
+    const name = match[2] ?? "";
+    if (!skillNames.has(name)) return [];
+    const start = (match.index ?? 0) + (match[1]?.length ?? 0);
+    return [{ name, start, end: start + name.length + 1 }];
+  });
+  const last = mentions.at(-1);
+  if (last === void 0) return void 0;
+  const leading = prompt.slice(0, last.start);
+  const trailing = prompt.slice(last.end);
+  const leadingWithInlineSlashes = mentions.slice(0, -1).reduceRight(
+    (text, mention) => `${text.slice(0, mention.start)}/${text.slice(mention.start + 1)}`,
+    leading
+  ).trimEnd();
+  return {
+    leadingText: leadingWithInlineSlashes.length > 0 ? leadingWithInlineSlashes : void 0,
+    commandText: `/${last.name}${trailing}`.trimEnd(),
+    skillName: last.name
+  };
 }
 
 // src/imageMime.ts
@@ -23183,9 +24309,9 @@ var PromptQueue = class {
     const queued = this.#queued.shift();
     if (queued !== void 0) return Promise.resolve(queued);
     if (this.#closed) return Promise.resolve(void 0);
-    return new Promise((resolve3) => {
+    return new Promise((resolve4) => {
       this.#waiters.push((result) => {
-        resolve3(result.done ? void 0 : result.value);
+        resolve4(result.done ? void 0 : result.value);
       });
     });
   }
@@ -23266,6 +24392,10 @@ function nativeProviderRefs(_context, options) {
 }
 async function buildUserMessageFromTurn(input) {
   const sdkContent = [];
+  const dispatch = input.skillNames === void 0 ? void 0 : planClaudeSkillDispatch(input.text, input.skillNames);
+  if (dispatch?.leadingText !== void 0) {
+    sdkContent.push({ type: "text", text: dispatch.leadingText });
+  }
   for (const attachment of input.attachments ?? []) {
     if (!attachment || typeof attachment !== "object" || Array.isArray(attachment)) continue;
     const rec = attachment;
@@ -23284,7 +24414,9 @@ async function buildUserMessageFromTurn(input) {
     const bytes = await input.attachmentsApi.read(id2);
     sdkContent.push(buildClaudeImageContentBlock({ mimeType, bytes }));
   }
-  if (input.text.length > 0) {
+  if (dispatch !== void 0) {
+    sdkContent.push({ type: "text", text: dispatch.commandText });
+  } else if (input.text.length > 0) {
     sdkContent.push({ type: "text", text: input.text });
   }
   return buildUserMessage({ sdkContent });
@@ -23304,10 +24436,10 @@ async function persistProducedImage(input) {
 }
 
 // src/claudeInstance.ts
-function compactEnv(env) {
+function compactEnv(env2) {
   const out = {};
-  if (!env) return out;
-  for (const [key, value] of Object.entries(env)) {
+  if (!env2) return out;
+  for (const [key, value] of Object.entries(env2)) {
     if (value !== void 0) out[key] = value;
   }
   return out;
@@ -23329,7 +24461,6 @@ function toClaudeMcpServers(entries) {
   }
   return servers;
 }
-var CLAUDE_PROGRAM_NOT_CONFIGURED = "Claude program path is not configured";
 function createClaudeAdapter(recipe, host, options) {
   const boundInstanceId = options?.instanceId ?? host.instanceId ?? "claudeAgent";
   const claudeHomeEnvironment = makeClaudeEnvironment(recipe, options?.environment);
@@ -23345,7 +24476,7 @@ function createClaudeAdapter(recipe, host, options) {
     if (recipe.binaryPath.length === 0) throw new Error(CLAUDE_PROGRAM_NOT_CONFIGURED);
     return sdkCreateQuery(input);
   };
-  const buildLaunchEnvironment = () => mergeLaunchEnv2({
+  const buildLaunchEnvironment = () => mergeLaunchEnv3({
     inherited: { ...process.env, ...options?.environment },
     instanceTable: recipe.environment,
     handOverrides: claudeHomeVariables(resolveClaudeHomeLayout(recipe))
@@ -23738,7 +24869,10 @@ function createClaudeAdapter(recipe, host, options) {
       compactedSinceLatestAssistantUsage: false,
       retrying: false,
       authenticationFailed: false,
-      nextSyntheticAssistantBlockIndex: -1
+      nextSyntheticAssistantBlockIndex: -1,
+      rejectedRateLimits: /* @__PURE__ */ new Map(),
+      announcedUsageLimits: /* @__PURE__ */ new Set(),
+      latestAssistantRateLimited: false
     };
     context.session = {
       ...context.session,
@@ -24325,6 +25459,10 @@ function createClaudeAdapter(recipe, host, options) {
     if (message.type !== "assistant") {
       return;
     }
+    const rateLimitParent = message.parent_tool_use_id;
+    if (context.turnState && (rateLimitParent === null || rateLimitParent === void 0)) {
+      context.turnState.latestAssistantRateLimited = message.error === "rate_limit";
+    }
     if (isClaudeSyntheticApiErrorMessage(message)) {
       if (context.turnState && message.error === "authentication_failed") {
         context.turnState.authenticationFailed = true;
@@ -24396,14 +25534,22 @@ function createClaudeAdapter(recipe, host, options) {
       return;
     }
     context.compactionInProgress = false;
-    const { status, errorMessage } = resultOutcome(
+    const outcome = resultOutcome(
       message,
       claudeFailureHint({
         authenticationFailed: context.turnState?.authenticationFailed === true,
         environment: buildLaunchEnvironment(),
-        cwd: NodePath8.resolve(context.session.cwd ?? ".")
+        cwd: NodePath13.resolve(context.session.cwd ?? "."),
+        ...context.turnState === void 0 ? {} : {
+          usageLimit: {
+            rejected: context.turnState.rejectedRateLimits,
+            latestAssistantRateLimited: context.turnState.latestAssistantRateLimited,
+            nowMs: Date.now()
+          }
+        }
       })
     );
+    const { status, errorMessage } = outcome;
     if (status === "failed") {
       await emitRuntimeError(context, errorMessage ?? "Claude turn failed.");
     }
@@ -24510,7 +25656,7 @@ function createClaudeAdapter(recipe, host, options) {
       }
     }
     switch (message.subtype) {
-      case "init":
+      case "init": {
         offerRuntimeEvent(context, {
           ...base,
           type: "session.configured",
@@ -24518,6 +25664,27 @@ function createClaudeAdapter(recipe, host, options) {
             config: message
           }
         });
+        const threadId = context.session.threadId;
+        const names = claudeSlashCommandsFromNames(message.slash_commands);
+        if (names.length > 0) host.reportSessionInventory?.({ threadId, slashCommands: names });
+        void context.query.supportedCommands?.().then(
+          (commands) => {
+            const detailed = claudeSlashCommandsFromSdk(commands);
+            if (detailed.length > 0) {
+              host.reportSessionInventory?.({ threadId, slashCommands: detailed });
+            }
+          },
+          () => void 0
+        );
+        return;
+      }
+      case "commands_changed":
+        if (Array.isArray(message.commands)) {
+          host.reportSessionInventory?.({
+            threadId: context.session.threadId,
+            slashCommands: claudeSlashCommandsFromSdk(message.commands)
+          });
+        }
         return;
       case "status": {
         const compacting = message.status === "compacting";
@@ -24825,7 +25992,6 @@ function createClaudeAdapter(recipe, host, options) {
       // deliberately so they don't masquerade as unknown-subtype warnings.
       case "local_command_output":
       case "plugin_install":
-      case "commands_changed":
       case "memory_recall":
       case "elicitation_complete":
         return;
@@ -24925,6 +26091,25 @@ function createClaudeAdapter(recipe, host, options) {
           rateLimits: message
         }
       });
+      const info = message.rate_limit_info;
+      const turn = context.turnState;
+      if (info && turn) {
+        const type4 = info.rateLimitType ?? "unknown";
+        if (isBlockingRateLimit(info)) {
+          turn.rejectedRateLimits.set(type4, info.resetsAt);
+          const key = rateLimitKey(info);
+          if (!turn.announcedUsageLimits.has(key)) {
+            turn.announcedUsageLimits.add(key);
+            await emitRuntimeWarning(
+              context,
+              describeUsageLimitPause(info, Date.parse(stamp.createdAt)),
+              info
+            );
+          }
+        } else if (isClearingRateLimit(info)) {
+          turn.rejectedRateLimits.delete(type4);
+        }
+      }
       return;
     }
   };
@@ -25071,7 +26256,7 @@ function createClaudeAdapter(recipe, host, options) {
       if (streamFiber) {
         await Promise.race([
           streamFiber.catch(() => void 0),
-          new Promise((resolve3) => setTimeout(resolve3, 1e3))
+          new Promise((resolve4) => setTimeout(resolve4, 1e3))
         ]);
       }
       const updatedAt = nowIso();
@@ -25282,7 +26467,7 @@ function createClaudeAdapter(recipe, host, options) {
         return await Promise.race([
           contextDeferred.promise,
           new Promise(
-            (resolve3) => setTimeout(() => resolve3(void 0), CLAUDE_SESSION_CONTEXT_WAIT_MS)
+            (resolve4) => setTimeout(() => resolve4(void 0), CLAUDE_SESSION_CONTEXT_WAIT_MS)
           )
         ]);
       } catch {
@@ -25817,7 +27002,10 @@ function createClaudeAdapter(recipe, host, options) {
         compactedSinceLatestAssistantUsage: false,
         retrying: false,
         authenticationFailed: false,
-        nextSyntheticAssistantBlockIndex: -1
+        nextSyntheticAssistantBlockIndex: -1,
+        rejectedRateLimits: /* @__PURE__ */ new Map(),
+        announcedUsageLimits: /* @__PURE__ */ new Set(),
+        latestAssistantRateLimited: false
       };
       const updatedAt = nowIso();
       context.turnState = turnState;
@@ -25839,10 +27027,18 @@ function createClaudeAdapter(recipe, host, options) {
         providerRefs: {}
       });
     }
+    const cliEnvironment = { ...process.env, ...recipe.environment };
+    const skills = await discoverClaudeSkills(
+      resolveClaudeConfigDirPath(recipe.homePath, cliEnvironment, context.session.cwd),
+      { environment: cliEnvironment, ...context.session.cwd ? { cwd: context.session.cwd } : {} }
+    );
     const message = await buildUserMessageFromTurn({
       text: buildPromptText(turnCapsForPrompt, input, boundInstanceId),
       attachments: input.attachments,
-      attachmentsApi: options?.attachments
+      attachmentsApi: options?.attachments,
+      skillNames: new Set(
+        skills.filter((skill) => skill.enabled && skill.userInvocable !== false).map((skill) => skill.name)
+      )
     });
     validateSteeringTarget();
     context.promptQueue.push({
@@ -25870,7 +27066,7 @@ function createClaudeAdapter(recipe, host, options) {
         context.query.interrupt().then(() => settled.promise).then(() => {
           acknowledged = true;
         }),
-        new Promise((resolve3) => setTimeout(resolve3, CLAUDE_INTERRUPT_GRACE_MS))
+        new Promise((resolve4) => setTimeout(resolve4, CLAUDE_INTERRUPT_GRACE_MS))
       ]);
     } catch (cause) {
       throw toRequestError(threadId, "turn/interrupt", cause);
@@ -26000,7 +27196,7 @@ function createClaudeAdapter(recipe, host, options) {
 function claudeAdapterBaseEnvironment(recipe) {
   return { ...process.env, ...recipe.environment };
 }
-function createClaudeInstance(config, host, attachments, overrides) {
+function createClaudeInstance(config, host, attachments, overrides, usageCache) {
   const recipe = parseClaudeInstanceConfig(config);
   const adapter = createClaudeAdapter(recipe, host, {
     instanceId: host.instanceId,
@@ -26009,118 +27205,7 @@ function createClaudeInstance(config, host, attachments, overrides) {
     environment: claudeAdapterBaseEnvironment(recipe),
     log: host.log
   });
-  const collectProcessText = async (stream) => {
-    const chunks = [];
-    for await (const chunk of stream) {
-      chunks.push(Buffer.from(chunk));
-    }
-    return Buffer.concat(chunks).toString("utf8");
-  };
-  const probeAuth = () => {
-    const hasEnvToken = (recipe.environment.ANTHROPIC_AUTH_TOKEN ?? "").trim().length > 0;
-    const hasEnvApiKey = (recipe.environment.ANTHROPIC_API_KEY ?? "").trim().length > 0;
-    if (hasEnvToken || hasEnvApiKey) {
-      return {
-        status: "authenticated",
-        type: hasEnvToken ? "env-token" : "api-key",
-        label: hasEnvToken ? "ANTHROPIC_AUTH_TOKEN" : "ANTHROPIC_API_KEY"
-      };
-    }
-    const account = readClaudeAccount(resolveClaudeCredentialsDirPath(recipe.credentialsPath));
-    switch (account.state) {
-      case "signed-in":
-      case "expired":
-        return { status: "authenticated" };
-      case "signed-out":
-        return { status: "unauthenticated" };
-      case "unreadable":
-        return { status: "unknown" };
-    }
-  };
-  let lastProbedVersion;
-  const probe = async (signal) => {
-    if (recipe.binaryPath.length === 0) {
-      return {
-        installed: false,
-        version: null,
-        readiness: "not-installed",
-        auth: { status: "unknown" },
-        detail: CLAUDE_PROGRAM_NOT_CONFIGURED
-      };
-    }
-    if (signal?.aborted) {
-      throw new Error("aborted");
-    }
-    let handle;
-    try {
-      handle = await host.process.spawn({
-        program: recipe.binaryPath,
-        args: ["--version"],
-        owner: { bindingId: host.bindingId }
-      });
-    } catch (error) {
-      if (error instanceof ExecutorSpawnRefusedError) throw error;
-      const failure = describeExecutorSpawnFailure(error);
-      return {
-        installed: false,
-        version: null,
-        readiness: failure.readiness,
-        auth: { status: "unknown" },
-        detail: failure.detail
-      };
-    }
-    const [stdout, stderr, exitCode] = await Promise.all([
-      collectProcessText(handle.stdout),
-      collectProcessText(handle.stderr),
-      handle.exited
-    ]);
-    const version = parseGenericCliVersion(`${stdout}
-${stderr}`);
-    if (version !== null || exitCode === 0) {
-      await adapter.modelCatalog.refresh({ signal, force: version !== lastProbedVersion });
-      lastProbedVersion = version;
-    }
-    const models = claudeProbeModels({
-      catalog: adapter.modelCatalog.current(),
-      customModels: recipe.customModels
-    });
-    const auth = probeAuth();
-    const skills = await discoverClaudeSkills(
-      resolveClaudeConfigDirPath(recipe.homePath, { ...process.env, ...recipe.environment })
-    );
-    if (exitCode !== 0 && version === null) {
-      const detail = (stderr || stdout || "claude --version failed").trim();
-      return {
-        installed: false,
-        version: null,
-        readiness: "error",
-        auth,
-        ...detail.length > 0 ? { detail } : {}
-      };
-    }
-    if (auth.status === "unauthenticated") {
-      return {
-        installed: true,
-        version,
-        readiness: "error",
-        auth,
-        models,
-        skills,
-        detail: "Claude is signed out",
-        // 退出登录了档位照样是那五档。不报就退回宿主四档，而那份映射少了 `plan`。
-        ...CLAUDE_NATIVE_MODE_REPORT
-      };
-    }
-    return {
-      installed: true,
-      version,
-      readiness: "ready",
-      auth,
-      models,
-      skills,
-      ...CLAUDE_NATIVE_MODE_REPORT
-    };
-  };
+  const probe = createClaudeProbe({ recipe, host, modelCatalog: adapter.modelCatalog });
   const resolveTranscriptRoots = (directory) => {
     const configDir = resolveClaudeConfigDirPath(
       recipe.homePath,
@@ -26129,7 +27214,7 @@ ${stderr}`);
     );
     return {
       configDir,
-      transcriptDir: NodePath8.join(configDir, "projects")
+      transcriptDir: NodePath13.join(configDir, "projects")
     };
   };
   return {
@@ -26146,8 +27231,18 @@ ${stderr}`);
     readThread: adapter.readThread,
     events: adapter.events,
     dispose: adapter.dispose,
+    // 项目里的命令与技能：探测没有工作区，只能报用户配置目录那份；这里按目录扫。
+    workspaceInventory: ({ cwd }) => {
+      const cliEnvironment = { ...process.env, ...recipe.environment };
+      return discoverClaudeWorkspaceInventory({
+        configDirPath: resolveClaudeConfigDirPath(recipe.homePath, cliEnvironment, cwd),
+        cwd,
+        environment: cliEnvironment
+      });
+    },
     textGeneration: createClaudeTextGeneration(recipe, host, adapter.modelCatalog.current),
     continuationKey: claudeContinuationKey(recipe.homePath),
+    usage: createClaudeUsage({ recipe, host, cache: usageCache }),
     sessions: {
       scan: async (input) => {
         const roots = resolveTranscriptRoots(input.directory);
@@ -26188,12 +27283,13 @@ ${stderr}`);
 
 // src/index.ts
 var capturedAttachments;
+var capturedCache;
 var executors = [
   {
     card: CLAUDE_CARD,
     createInstance: async (config, host) => {
       host.log.info("createInstance");
-      return createClaudeInstance(config, host, capturedAttachments);
+      return createClaudeInstance(config, host, capturedAttachments, void 0, capturedCache);
     }
   }
 ];
@@ -26203,6 +27299,7 @@ var index_default = definePlugin({
   executors,
   activate(ctx) {
     capturedAttachments = ctx.attachments;
+    capturedCache = ctx.cache;
     ctx.log.info("claude executor ready");
   }
 });