@matheuskrumenauer/tanya 0.17.0 → 0.17.6

package/dist/{chunk-5PSV2Y3X.js → chunk-3NV2QP7J.js}

@@ -1276,8 +1276,15 @@ import { join as join5 } from "path";
 var ROUTES_SCHEMA_VERSION = 1;
 var BUILT_IN_ROUTE_DEFAULTS = {
   provider: "openai",
-  model: "gpt-4.1-mini"
+  model: "gpt-4.1-mini",
+  maxInputTokens: 128e3
 };
+var BUILT_IN_ROUTE_CASCADE = [
+  { provider: "deepseek", model: "deepseek-chat", maxInputTokens: 128e3 },
+  { provider: "openai", model: "gpt-5-codex", maxInputTokens: 2e5 },
+  { provider: "claude", model: "claude-sonnet-4-6", maxInputTokens: 1e6 },
+  { provider: "gemini", model: "gemini-1.5-pro", maxInputTokens: 2e6 }
+];
 function builtInRouteTable(defaults = BUILT_IN_ROUTE_DEFAULTS) {
   return {
     version: ROUTES_SCHEMA_VERSION,
@@ -1317,7 +1324,8 @@ function builtInRouteTable(defaults = BUILT_IN_ROUTE_DEFAULTS) {
         reasoningCap: { maxTokens: 8e3 }
       }
     ],
-    defaults
+    defaults,
+    cascade: BUILT_IN_ROUTE_CASCADE
   };
 }
 
@@ -1343,12 +1351,21 @@ function loadRouteTable(options) {
     ...sourceRoutes(user.value?.routes ?? [], "user"),
     ...sourceRoutes(builtIn.routes, "built-in")
   ];
+  const defaultSource = project.value?.defaults ? "project" : user.value?.defaults ? "user" : "runtime-default";
+  const defaults = project.value?.defaults ?? user.value?.defaults ?? builtIn.defaults;
+  const cascadeSource = project.value ? "project" : user.value ? "user" : "built-in";
+  const cascade = sourceCascade(
+    project.value ? cascadeOrLegacyDefault(project.value) : user.value ? cascadeOrLegacyDefault(user.value) : builtIn.cascade ?? cascadeOrLegacyDefault(builtIn),
+    cascadeSource
+  );
   return {
     table: {
       version: ROUTES_SCHEMA_VERSION,
       routes,
-      defaults: project.value?.defaults ?? user.value?.defaults ?? builtIn.defaults,
-      defaultSource: project.value?.defaults ? "project" : user.value?.defaults ? "user" : "runtime-default",
+      defaults,
+      defaultSource,
+      cascade,
+      cascadeSource,
       sources
     },
     issues
@@ -1371,14 +1388,16 @@ function validateRouteTable(input) {
     issues.push({ path: "$.version", message: `Expected schema version ${ROUTES_SCHEMA_VERSION}.` });
   }
   const routes = validateRoutes(input.routes, issues);
-  const defaults = validateTarget(input.defaults, "$.defaults", issues);
+  const defaults = input.defaults === void 0 ? validateLegacyDefaultTarget(input, issues) : validateTarget(input.defaults, "$.defaults", issues);
+  const cascade = input.cascade === void 0 ? void 0 : validateCascade(input.cascade, issues);
   if (issues.length > 0) return { ok: false, issues };
   return {
     ok: true,
     value: {
       version: ROUTES_SCHEMA_VERSION,
       routes,
-      defaults
+      defaults,
+      ...cascade ? { cascade } : {}
     },
     issues: []
   };
@@ -1427,7 +1446,21 @@ function readRouteFile(file, _source) {
 function sourceRoutes(routes, source) {
   return routes.map((route) => ({ ...route, source }));
 }
+function sourceCascade(cascade, source) {
+  return cascade.map((route) => ({ ...route, source }));
+}
+function cascadeOrLegacyDefault(table) {
+  return table.cascade?.length ? table.cascade : [targetToCascade(table.defaults)];
+}
+function targetToCascade(target) {
+  return {
+    provider: target.provider,
+    model: target.model,
+    maxInputTokens: target.maxInputTokens ?? contextWindowForProvider(target.provider)
+  };
+}
 function validateRoutes(input, issues) {
+  if (input === void 0) return [];
   if (!Array.isArray(input)) {
     issues.push({ path: "$.routes", message: "Expected an array." });
     return [];
@@ -1450,12 +1483,31 @@ function validateRoutes(input, issues) {
       match,
       provider: target.provider,
       model: target.model,
+      ...target.maxInputTokens ? { maxInputTokens: target.maxInputTokens } : {},
       ...fallback ? { fallback } : {},
       ...item.escalate !== void 0 ? { escalate: Boolean(item.escalate) } : {},
       ...reasoningCap ? { reasoningCap } : {}
     }];
   });
 }
+function validateCascade(input, issues) {
+  if (!Array.isArray(input)) {
+    issues.push({ path: "$.cascade", message: "Expected an array when present." });
+    return [];
+  }
+  return input.flatMap((item, index) => {
+    const path = `$.cascade[${index}]`;
+    const target = validateTarget(item, path, issues);
+    const stepTypes = validateStepTypes(isRecord2(item) ? item.stepTypes ?? item.step_types : void 0, `${path}.stepTypes`, issues);
+    if (!target || !target.maxInputTokens) return [];
+    return [{
+      provider: target.provider,
+      model: target.model,
+      maxInputTokens: target.maxInputTokens,
+      ...stepTypes ? { stepTypes } : {}
+    }];
+  });
+}
 function validateReasoningCap(input, path, issues) {
   if (input === void 0) return null;
   if (!isRecord2(input)) {
@@ -1468,6 +1520,22 @@ function validateReasoningCap(input, path, issues) {
   }
   return { maxTokens: Math.floor(input.maxTokens) };
 }
+function validateStepTypes(input, path, issues) {
+  if (input === void 0) return null;
+  if (!Array.isArray(input)) {
+    issues.push({ path, message: "Expected an array of step types when present." });
+    return null;
+  }
+  const out = [];
+  input.forEach((item, index) => {
+    if (typeof item !== "string" || !STEP_TYPES.has(item)) {
+      issues.push({ path: `${path}[${index}]`, message: "Expected a known step type." });
+      return;
+    }
+    out.push(item);
+  });
+  return out.length ? out : null;
+}
 function validateMatch(input, path, issues) {
   if (typeof input === "string") {
     if (!STEP_TYPES.has(input)) {
@@ -1498,26 +1566,76 @@ function validateTarget(input, path, issues) {
     issues.push({ path, message: "Expected an object." });
     return { provider: "", model: "" };
   }
-  if (typeof input.provider !== "string" || input.provider.trim() === "") {
+  const provider = typeof input.provider === "string" && input.provider.trim() ? input.provider.trim() : typeof input.cli === "string" && input.cli.trim() ? input.cli.trim() : "";
+  const model = typeof input.model === "string" && input.model.trim() ? input.model.trim() : "";
+  const maxInputTokens = numericField(input.maxInputTokens ?? input.max_input_tokens);
+  if (!provider) {
     issues.push({ path: `${path}.provider`, message: "Expected a non-empty provider string." });
   }
-  if (typeof input.model !== "string" || input.model.trim() === "") {
+  if (!model) {
     issues.push({ path: `${path}.model`, message: "Expected a non-empty model string." });
   }
+  if ((input.maxInputTokens !== void 0 || input.max_input_tokens !== void 0) && !maxInputTokens) {
+    issues.push({ path: `${path}.maxInputTokens`, message: "Expected a positive number." });
+  }
   return {
-    provider: typeof input.provider === "string" ? input.provider : "",
-    model: typeof input.model === "string" ? input.model : ""
+    provider,
+    model,
+    ...maxInputTokens ? { maxInputTokens } : {}
+  };
+}
+function validateLegacyDefaultTarget(input, issues) {
+  const defaultModel = typeof input.default_model === "string" && input.default_model.trim() ? input.default_model.trim() : typeof input.defaultModel === "string" && input.defaultModel.trim() ? input.defaultModel.trim() : "";
+  const defaultProvider = typeof input.default_cli === "string" && input.default_cli.trim() ? input.default_cli.trim() : typeof input.default_provider === "string" && input.default_provider.trim() ? input.default_provider.trim() : typeof input.defaultProvider === "string" && input.defaultProvider.trim() ? input.defaultProvider.trim() : "";
+  if (!defaultModel) {
+    issues.push({ path: "$.defaults", message: "Expected defaults or legacy default_model." });
+  }
+  const provider = defaultProvider || inferProviderForModel(defaultModel);
+  if (!provider) {
+    issues.push({ path: "$.default_cli", message: "Expected default_cli/default_provider for this default_model." });
+  }
+  const maxInputTokens = numericField(input.maxInputTokens ?? input.max_input_tokens);
+  return {
+    provider,
+    model: defaultModel,
+    ...maxInputTokens ? { maxInputTokens } : {}
   };
 }
 function routeMatches(match, stepType, text2) {
   if (typeof match === "string") return match === stepType;
   return new RegExp(match.regex).test(text2);
 }
+function numericField(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return void 0;
+  return Math.floor(value);
+}
+function inferProviderForModel(model) {
+  if (/^deepseek-/i.test(model)) return "deepseek";
+  if (/^(?:gpt-|o\d|o\d-|chatgpt)/i.test(model)) return "openai";
+  if (/^claude-/i.test(model)) return "claude";
+  if (/^gemini-/i.test(model)) return "gemini";
+  if (/^qwen/i.test(model)) return "qwen";
+  return "";
+}
+function contextWindowForProvider(provider) {
+  switch (provider) {
+    case "claude":
+      return 1e6;
+    case "gemini":
+      return 2e6;
+    case "openai":
+      return 2e5;
+    default:
+      return 128e3;
+  }
+}
 function isRecord2(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
 // src/router/classify.ts
+import { existsSync as existsSync6 } from "fs";
+import { join as join6 } from "path";
 function classifyStep(state) {
   const lastAssistant = state.lastAssistantMessage ?? lastMessageWithRole(state.messages ?? [], "assistant");
   const pendingToolCalls = state.pendingToolCalls ?? lastAssistant?.tool_calls ?? [];
@@ -1530,8 +1648,38 @@ function classifyStep(state) {
   if (content.trim() !== "" && pendingToolCalls.length === 0 && toolResultsSinceUser.length >= 2) {
     return "synthesis";
   }
+  if (looksLikeCodeEditingTask(state)) return "tool_call";
   return "unknown";
 }
+function looksLikeCodeEditingTask(state) {
+  const runContext = state.runContext;
+  if (runContext?.task?.kind === "coding") return true;
+  if (runContext?.expected_report && Object.keys(runContext.expected_report).length > 0) return true;
+  if (runContext?.verification?.commands?.length) return true;
+  const taskText2 = [
+    runContext?.task?.title,
+    runContext?.task?.summary,
+    runContext?.stack,
+    ...runContext?.languages ?? [],
+    ...runContext?.frameworks ?? [],
+    state.prompt,
+    ...userMessageContent(state.messages ?? [])
+  ].filter(Boolean).join("\n");
+  if (/\bgo-backend-[a-z0-9_-]+\b/i.test(taskText2)) return true;
+  if (/template\s*(?:id|ID)?\s*[:=]?\s*["'`]?go-backend-[a-z0-9_-]+/i.test(taskText2)) return true;
+  if (/EXISTING CODE DETECTED/i.test(taskText2) && /\bEXECUTE\s+mode\b/i.test(taskText2)) return true;
+  return Boolean(state.cwd && isCodeWorkspace(state.cwd) && taskText2.length > 1200);
+}
+function isCodeWorkspace(cwd) {
+  return [
+    "go.mod",
+    "package.json",
+    "Cargo.toml",
+    "pyproject.toml",
+    "requirements.txt",
+    "Package.swift"
+  ].some((marker) => existsSync6(join6(cwd, marker)));
+}
 function hasVerificationTool(toolCalls) {
   return toolCalls.some((tool) => {
     if (isPreferredVerification(tool)) return true;
@@ -1570,6 +1718,9 @@ function messagesSinceLastUser(messages) {
   }
   return messages;
 }
+function userMessageContent(messages) {
+  return messages.filter((message) => message.role === "user" && typeof message.content === "string").map((message) => message.content ?? "");
+}
 
 // src/providers/adapters/deepseek.ts
 var deepSeekAdapter = {
@@ -1745,13 +1896,13 @@ function normalizeProviderId(provider) {
 
 // src/memory/runArchive.ts
 import { appendFile, mkdir as mkdir3, readFile as readFile2 } from "fs/promises";
-import { existsSync as existsSync6 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync7 } from "fs";
+import { join as join7 } from "path";
 var appendQueues = /* @__PURE__ */ new Map();
 async function appendArchive(runId, messages, options = {}) {
   if (messages.length === 0) return;
   const path = archivePath(options.workspace ?? process.cwd(), runId);
-  await mkdir3(join6(options.workspace ?? process.cwd(), ".tanya", "runs", runId), { recursive: true });
+  await mkdir3(join7(options.workspace ?? process.cwd(), ".tanya", "runs", runId), { recursive: true });
   const payload = messages.map((message) => JSON.stringify(message)).join("\n") + "\n";
   const previous = appendQueues.get(path) ?? Promise.resolve();
   const next = previous.then(() => appendFile(path, payload, "utf8"));
@@ -1761,7 +1912,7 @@ async function appendArchive(runId, messages, options = {}) {
 }
 async function readArchive(runId, options = {}) {
   const path = archivePath(options.workspace ?? process.cwd(), runId);
-  if (!existsSync6(path)) return [];
+  if (!existsSync7(path)) return [];
   const raw = await readFile2(path, "utf8");
   return raw.split(/\r?\n/).filter(Boolean).flatMap((line) => {
     try {
@@ -1813,7 +1964,7 @@ function fileTouchPathsFromArchive(entries) {
   return [...paths].sort();
 }
 function archivePath(workspace, runId) {
-  return join6(workspace, ".tanya", "runs", runId, "archive.jsonl");
+  return join7(workspace, ".tanya", "runs", runId, "archive.jsonl");
 }
 function fileTouchPathsFromArchivedContent(content) {
   const paths = /* @__PURE__ */ new Set();
@@ -2140,41 +2291,61 @@ var EscalationExhaustedError = class extends Error {
   }
 };
 function resolveRouteWithContextGuard(params) {
-  const primary = resolveRoute(params.stepType, params.table, params.routeText);
   const estimate = estimateCompactTokens(params.messages);
+  const safetyFactor = routeSafetyFactor();
+  if (params.forcedRoute) {
+    return resolveForcedRoute(params.forcedRoute, params.stepType, estimate, safetyFactor);
+  }
+  const primary = resolveRoute(params.stepType, params.table, params.routeText);
+  const guardedPrimary = codeEditingDeepSeekChatGuard(primary, params);
   const candidates = [
-    primary,
-    ...primary.fallback ? [routeFromTarget(primary.fallback, primary, "fallback")] : [],
-    {
-      provider: params.table.defaults.provider,
-      model: params.table.defaults.model,
-      match: "defaults",
-      escalate: true,
-      source: params.table.defaultSource,
-      reason: "matched route defaults"
-    }
+    guardedPrimary,
+    ...guardedPrimary.fallback ? [routeFromTarget(guardedPrimary.fallback, guardedPrimary, "fallback")] : [],
+    ...cascadeRoutesForStep(params.table, params.stepType)
   ];
   const seen = /* @__PURE__ */ new Set();
+  const attempts = [];
   for (const candidate of candidates) {
     const key = `${candidate.provider}/${candidate.model}`;
     if (seen.has(key)) continue;
     seen.add(key);
-    const window = contextWindowForTarget(candidate);
-    if (estimate <= window) {
-      return candidate === primary ? candidate : { ...candidate, reason: `${candidate.reason}; declined earlier route due to context-window guard` };
+    const attempt = routeAttempt(candidate, estimate, safetyFactor);
+    attempts.push(attempt);
+    if (estimate <= attempt.safetyLimit) {
+      if (attempts.length === 1 && candidate === primary) return candidate;
+      const reason = attempts.length > 1 ? `${candidate.reason}; cascade-fit; declined earlier route due to context-window guard` : candidate.reason;
+      return {
+        ...candidate,
+        reason,
+        cascade: {
+          reason: "cascade-fit",
+          estimatedTokens: estimate,
+          safetyFactor,
+          attemptedRoutes: attempts,
+          selectedRoute: attempt,
+          selectedIndex: attempts.length - 1
+        }
+      };
     }
   }
+  const highest = highestAttempt(attempts);
+  if (highest) {
+    throw new RouteContextOverflowError(
+      `Estimated ${estimate.toLocaleString("en-US")} tokens exceeds the largest configured route ${highest.provider}/${highest.model} (${highest.maxInputTokens.toLocaleString("en-US")} tokens \xD7 ${safetyFactor} safety = ${highest.safetyLimit.toLocaleString("en-US")}). Reduce prompt or add a higher-context route.`
+    );
+  }
   throw new RouteContextOverflowError(
     `No route can fit estimated ${estimate} tokens for step ${params.stepType}.`
   );
 }
 function contextWindowForTarget(target) {
-  return resolveProviderAdapter({ provider: target.provider }).capabilities.contextWindow;
+  return target.maxInputTokens ?? modelContextWindow(target) ?? resolveProviderAdapter({ provider: target.provider }).capabilities.contextWindow;
 }
 function routeFromTarget(target, primary, label) {
   return {
     provider: target.provider,
     model: target.model,
+    ...target.maxInputTokens ? { maxInputTokens: target.maxInputTokens } : {},
     match: primary.match,
     escalate: primary.escalate,
     ...primary.reasoningCap ? { reasoningCap: primary.reasoningCap } : {},
@@ -2182,11 +2353,96 @@ function routeFromTarget(target, primary, label) {
     reason: `matched ${label} for ${primary.provider}/${primary.model}`
   };
 }
+function cascadeRoutesForStep(table, stepType) {
+  return table.cascade.filter((entry) => !entry.stepTypes || entry.stepTypes.includes(stepType)).map((entry) => ({
+    provider: entry.provider,
+    model: entry.model,
+    maxInputTokens: entry.maxInputTokens,
+    match: "defaults",
+    escalate: true,
+    source: entry.source,
+    reason: `matched route cascade ${entry.provider}/${entry.model}`
+  }));
+}
+function resolveForcedRoute(target, stepType, estimate, safetyFactor) {
+  const candidate = {
+    provider: target.provider,
+    model: target.model,
+    ...target.maxInputTokens ? { maxInputTokens: target.maxInputTokens } : {},
+    match: stepType,
+    escalate: false,
+    source: "session",
+    reason: `forced route ${target.provider}/${target.model}`
+  };
+  const attempt = routeAttempt(candidate, estimate, safetyFactor);
+  if (estimate <= attempt.safetyLimit) return candidate;
+  throw new RouteContextOverflowError(
+    `Forced route ${target.provider}/${target.model} cannot fit estimated ${estimate.toLocaleString("en-US")} tokens (${attempt.maxInputTokens.toLocaleString("en-US")} tokens \xD7 ${safetyFactor} safety = ${attempt.safetyLimit.toLocaleString("en-US")}). Reduce prompt or choose a higher-context forced route.`
+  );
+}
+function routeAttempt(route, _estimate, safetyFactor) {
+  const maxInputTokens = contextWindowForTarget(route);
+  return {
+    provider: route.provider,
+    model: route.model,
+    maxInputTokens,
+    safetyLimit: Math.floor(maxInputTokens * safetyFactor),
+    source: route.source,
+    reason: route.reason
+  };
+}
+function highestAttempt(attempts) {
+  return attempts.reduce((highest, attempt) => {
+    if (!highest || attempt.maxInputTokens > highest.maxInputTokens) return attempt;
+    return highest;
+  }, null);
+}
+function routeSafetyFactor(env = process.env) {
+  const raw = Number(envValue(env, "TANYA_ROUTE_SAFETY_FACTOR"));
+  if (!Number.isFinite(raw) || raw <= 0 || raw > 1) return 0.85;
+  return raw;
+}
+function modelContextWindow(target) {
+  const model = target.model.toLowerCase();
+  if (target.provider === "claude" || model.startsWith("claude-")) return 1e6;
+  if (target.provider === "gemini" || model.startsWith("gemini-")) return 2e6;
+  if (model.includes("gpt-5-codex") || model.includes("o3-codex")) return 2e5;
+  return null;
+}
+function codeEditingDeepSeekChatGuard(primary, params) {
+  if (params.stepType !== "unknown") return primary;
+  if (!isDeepSeekChat(primary)) return primary;
+  const codeTaskState = {
+    messages: params.messages,
+    ...params.prompt ? { prompt: params.prompt } : {},
+    ...params.cwd ? { cwd: params.cwd } : {},
+    ...params.runContext ? { runContext: params.runContext } : {}
+  };
+  if (!looksLikeCodeEditingTask(codeTaskState)) {
+    return primary;
+  }
+  const target = firstNonDeepSeekChatTarget([
+    primary.fallback,
+    params.table.defaults,
+    { provider: "deepseek", model: "deepseek-reasoner" }
+  ]);
+  if (!target) return primary;
+  return {
+    ...routeFromTarget(target, primary, "fallback"),
+    reason: `${primary.reason}; declined deepseek-chat for code-editing task`
+  };
+}
+function firstNonDeepSeekChatTarget(targets) {
+  return targets.find((target) => Boolean(target && !isDeepSeekChat(target))) ?? null;
+}
+function isDeepSeekChat(target) {
+  return target.provider === "deepseek" && target.model === "deepseek-chat";
+}
 
 // src/context/loader.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync7, readdirSync as readdirSync2, readFileSync as readFileSync5 } from "fs";
-import { join as join7, relative as relative3 } from "path";
+import { existsSync as existsSync8, readdirSync as readdirSync2, readFileSync as readFileSync5 } from "fs";
+import { join as join8, relative as relative3 } from "path";
 var ignoredNames = /* @__PURE__ */ new Set([".git", "node_modules", ".next", "dist", "build", ".turbo", ".cache"]);
 var artifactIgnoredNames = /* @__PURE__ */ new Set([".DS_Store", ".git", "node_modules", "dist", "build"]);
 var instructionFiles = ["TANYA.md", "TANIA.md", "AGENTS.md", "CLAUDE.md", "README.md", ".tania/INSTRUCTIONS.md"];
@@ -2200,7 +2456,7 @@ var projectMarkers = [
 ];
 function readIfExists(filePath, maxChars = 4e3) {
   try {
-    if (!existsSync7(filePath)) return null;
+    if (!existsSync8(filePath)) return null;
     const content = readFileSync5(filePath, "utf8");
     return content.length > maxChars ? `${content.slice(0, maxChars)}
 [truncated]` : content;
@@ -2210,7 +2466,7 @@ function readIfExists(filePath, maxChars = 4e3) {
 }
 function readFullIfExists(filePath) {
   try {
-    if (!existsSync7(filePath)) return null;
+    if (!existsSync8(filePath)) return null;
     return readFileSync5(filePath, "utf8");
   } catch {
     return null;
@@ -2250,14 +2506,14 @@ function scoreArtifactDirectory(name, taskHint) {
 }
 function artifactDirectoryPreview(artifactsRoot, directory, maxEntries = 10) {
   try {
-    return readdirSync2(join7(artifactsRoot, directory), { withFileTypes: true }).filter((entry) => !artifactIgnoredNames.has(entry.name)).sort((a, b) => Number(a.isDirectory()) - Number(b.isDirectory()) || a.name.localeCompare(b.name)).slice(0, maxEntries).map((entry) => entry.isDirectory() ? `${directory}/${entry.name}/` : `${directory}/${entry.name}`);
+    return readdirSync2(join8(artifactsRoot, directory), { withFileTypes: true }).filter((entry) => !artifactIgnoredNames.has(entry.name)).sort((a, b) => Number(a.isDirectory()) - Number(b.isDirectory()) || a.name.localeCompare(b.name)).slice(0, maxEntries).map((entry) => entry.isDirectory() ? `${directory}/${entry.name}/` : `${directory}/${entry.name}`);
   } catch {
     return [];
   }
 }
 function buildArtifactIndexBlock(workspace, taskHint = "") {
-  const artifactsRoot = join7(workspace, "artifacts");
-  if (!existsSync7(artifactsRoot)) return "";
+  const artifactsRoot = join8(workspace, "artifacts");
+  if (!existsSync8(artifactsRoot)) return "";
   let entries;
   try {
     entries = readdirSync2(artifactsRoot, { withFileTypes: true });
@@ -2270,13 +2526,13 @@ function buildArtifactIndexBlock(workspace, taskHint = "") {
     preview: artifactDirectoryPreview(artifactsRoot, entry.name)
   })).sort((a, b) => b.score - a.score || a.name.localeCompare(b.name));
   const rulesCandidates = [
-    { path: "artifacts/prompts/RULES.md", absolutePath: join7(artifactsRoot, "prompts", "RULES.md") },
-    { path: "artifacts/RULES.md", absolutePath: join7(artifactsRoot, "RULES.md") }
+    { path: "artifacts/prompts/RULES.md", absolutePath: join8(artifactsRoot, "prompts", "RULES.md") },
+    { path: "artifacts/RULES.md", absolutePath: join8(artifactsRoot, "RULES.md") }
   ];
   const rulesRead = rulesCandidates.map((candidate) => ({ path: candidate.path, content: readFullIfExists(candidate.absolutePath) })).find((candidate) => candidate.content !== null && candidate.content.trim().length > 0);
   const indexReads = [
-    { path: "artifacts/description.md", content: readIfExists(join7(artifactsRoot, "description.md"), 12e3) },
-    { path: "artifacts/README.md", content: readIfExists(join7(artifactsRoot, "README.md"), 12e3) }
+    { path: "artifacts/description.md", content: readIfExists(join8(artifactsRoot, "description.md"), 12e3) },
+    { path: "artifacts/README.md", content: readIfExists(join8(artifactsRoot, "README.md"), 12e3) }
   ].filter((entry) => entry.content !== null && entry.content.trim().length > 0);
   if (!rulesRead && indexReads.length === 0 && directories.length === 0) return "";
   const lines = [
@@ -2306,7 +2562,7 @@ function buildArtifactIndexBlock(workspace, taskHint = "") {
   const maxArtifactFiles = 4;
   const scoredFiles = [];
   for (const directory of directories) {
-    const subdirPath = join7(artifactsRoot, directory.name);
+    const subdirPath = join8(artifactsRoot, directory.name);
     let mdFiles = [];
     try {
       mdFiles = readdirSync2(subdirPath, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".md")).map((entry) => entry.name);
@@ -2318,7 +2574,7 @@ function buildArtifactIndexBlock(workspace, taskHint = "") {
       if (fileScore > 0) {
         scoredFiles.push({
           path: `artifacts/${directory.name}/${mdFile}`,
-          fullPath: join7(subdirPath, mdFile),
+          fullPath: join8(subdirPath, mdFile),
           score: fileScore
         });
       }
@@ -2366,7 +2622,7 @@ function collectTree(workspace, maxEntries = 120, maxDepth = 2) {
     for (const entry of dirents) {
       if (entries.length >= maxEntries) return;
       if (ignoredNames.has(entry.name)) continue;
-      const fullPath = join7(dir, entry.name);
+      const fullPath = join8(dir, entry.name);
       const rel = relative3(workspace, fullPath).replace(/\\/g, "/");
       entries.push(entry.isDirectory() ? `${rel}/` : rel);
       if (entry.isDirectory()) walk(fullPath, depth + 1);
@@ -2378,9 +2634,9 @@ function collectTree(workspace, maxEntries = 120, maxDepth = 2) {
 function detectProjectTypes(workspace) {
   const types = /* @__PURE__ */ new Set();
   for (const marker of projectMarkers) {
-    if (existsSync7(join7(workspace, marker.file))) types.add(marker.type);
+    if (existsSync8(join8(workspace, marker.file))) types.add(marker.type);
   }
-  if (existsSync7(join7(workspace, "gradlew")) || existsSync7(join7(workspace, "settings.gradle")) || existsSync7(join7(workspace, "settings.gradle.kts"))) {
+  if (existsSync8(join8(workspace, "gradlew")) || existsSync8(join8(workspace, "settings.gradle")) || existsSync8(join8(workspace, "settings.gradle.kts"))) {
     types.add("android");
   }
   try {
@@ -2401,7 +2657,7 @@ function collectTypeScriptFiles(workspace) {
     }
     for (const entry of dirents) {
       if (ignoredNames.has(entry.name)) continue;
-      const fullPath = join7(dir, entry.name);
+      const fullPath = join8(dir, entry.name);
       if (entry.isDirectory()) {
         walk(fullPath);
         continue;
@@ -2425,7 +2681,7 @@ function formatExportName(entry) {
   return entry.isDefault ? `${entry.name} (default)` : entry.name;
 }
 function parseFileExports(workspace, file) {
-  const content = readIfExists(join7(workspace, file), 2e5);
+  const content = readIfExists(join8(workspace, file), 2e5);
   if (!content) return null;
   const exports = [];
   const seen = /* @__PURE__ */ new Set();
@@ -2487,7 +2743,7 @@ function buildExportMap(workspace) {
 function detectVerificationSuggestions(workspace, projectTypes, packageScripts) {
   const suggestions = /* @__PURE__ */ new Set();
   if (projectTypes.includes("android")) {
-    const gradle = existsSync7(join7(workspace, "gradlew")) ? "./gradlew" : "gradle";
+    const gradle = existsSync8(join8(workspace, "gradlew")) ? "./gradlew" : "gradle";
     suggestions.add(`${gradle} test`);
     suggestions.add(`${gradle} assembleDebug`);
   }
@@ -2505,7 +2761,7 @@ function detectVerificationSuggestions(workspace, projectTypes, packageScripts)
   return [...suggestions].slice(0, 8);
 }
 function readPackageScripts(workspace) {
-  const content = readIfExists(join7(workspace, "package.json"), 8e4);
+  const content = readIfExists(join8(workspace, "package.json"), 8e4);
   if (!content) return {};
   try {
     const parsed = JSON.parse(content);
@@ -2525,7 +2781,7 @@ function loadWorkspaceSummary(workspace) {
   const gitStatus = isGitRepo ? runGit(workspace, ["status", "--short"]) ?? "" : null;
   const instructionReads = [];
   for (const fileName of instructionFiles) {
-    const filePath = join7(workspace, fileName);
+    const filePath = join8(workspace, fileName);
     const content = readIfExists(filePath, fileName === "README.md" ? 6e3 : 4e3);
     if (content !== null) {
       instructionReads.push({ path: fileName, content });
@@ -2582,20 +2838,20 @@ function buildContextBlock(workspace) {
 }
 
 // src/skills/load.ts
-import { existsSync as existsSync9, readdirSync as readdirSync4, readFileSync as readFileSync6, statSync as statSync3 } from "fs";
-import { dirname as dirname5, join as join9, relative as relative4 } from "path";
+import { existsSync as existsSync10, readdirSync as readdirSync4, readFileSync as readFileSync6, statSync as statSync3 } from "fs";
+import { dirname as dirname5, join as join10, relative as relative4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { load as parseYaml } from "js-yaml";
 
 // src/integrations/discovery.ts
-import { existsSync as existsSync8, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
-import { basename, dirname as dirname4, join as join8 } from "path";
+import { existsSync as existsSync9, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
+import { basename, dirname as dirname4, join as join9 } from "path";
 import { fileURLToPath } from "url";
 var moduleRoot = dirname4(fileURLToPath(import.meta.url));
 var defaultIntegrationsRoot = null;
 function safeIsDirectory(path) {
   try {
-    return existsSync8(path) && statSync2(path).isDirectory();
+    return existsSync9(path) && statSync2(path).isDirectory();
   } catch {
     return false;
   }
@@ -2610,7 +2866,7 @@ function safeReadDirectory(path) {
 function hasMarkdownFile(root) {
   const entries = safeReadDirectory(root);
   for (const entry of entries) {
-    const path = join8(root, entry.name);
+    const path = join9(root, entry.name);
     if (entry.isFile() && entry.name.endsWith(".md")) return true;
     if (entry.isDirectory() && hasMarkdownFile(path)) return true;
   }
@@ -2619,14 +2875,14 @@ function hasMarkdownFile(root) {
 function resolveDefaultSkillsRoot() {
   const candidates = [
     moduleRoot,
-    join8(moduleRoot, "skills"),
-    join8(moduleRoot, "..", "src", "skills"),
-    join8(moduleRoot, "..", "skills")
+    join9(moduleRoot, "skills"),
+    join9(moduleRoot, "..", "src", "skills"),
+    join9(moduleRoot, "..", "skills")
   ];
   for (const candidate of candidates) {
     if (safeIsDirectory(candidate) && hasMarkdownFile(candidate)) return candidate;
   }
-  return join8(moduleRoot, "..", "skills");
+  return join9(moduleRoot, "..", "skills");
 }
 function packageRootFromSkillsRoot(skillsRoot) {
   const parent = dirname4(skillsRoot);
@@ -2637,7 +2893,7 @@ function packageRootFromSkillsRoot(skillsRoot) {
 function integrationsRoot(env = process.env) {
   const override = envValue(env, "TANYA_INTEGRATIONS_DIR").trim();
   if (override) return override;
-  defaultIntegrationsRoot ??= join8(packageRootFromSkillsRoot(resolveDefaultSkillsRoot()), "integrations");
+  defaultIntegrationsRoot ??= join9(packageRootFromSkillsRoot(resolveDefaultSkillsRoot()), "integrations");
   return defaultIntegrationsRoot;
 }
 function discoverIntegrationEntries(kind, opts = {}) {
@@ -2646,14 +2902,14 @@ function discoverIntegrationEntries(kind, opts = {}) {
   const entries = [];
   const integrations = safeReadDirectory(root).filter((entry) => entry.isDirectory()).sort((a, b) => a.name.localeCompare(b.name));
   for (const integration of integrations) {
-    const kindRoot = join8(root, integration.name, kind);
+    const kindRoot = join9(root, integration.name, kind);
     if (!safeIsDirectory(kindRoot)) continue;
     const discovered = safeReadDirectory(kindRoot).filter((entry) => entry.isDirectory() || entry.isFile()).sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of discovered) {
       entries.push({
         integration: integration.name,
         kind,
-        path: join8(kindRoot, entry.name)
+        path: join9(kindRoot, entry.name)
       });
     }
   }
@@ -2685,7 +2941,7 @@ function estimateTokens(text2) {
 }
 function safeExists(path) {
   try {
-    return existsSync9(path);
+    return existsSync10(path);
   } catch {
     return false;
   }
@@ -2693,13 +2949,13 @@ function safeExists(path) {
 function resolveDefaultSkillsRoot2() {
   const candidates = [
     moduleRoot2,
-    join9(moduleRoot2, "skills"),
-    join9(moduleRoot2, "..", "src", "skills"),
-    join9(moduleRoot2, "..", "skills")
+    join10(moduleRoot2, "skills"),
+    join10(moduleRoot2, "..", "src", "skills"),
+    join10(moduleRoot2, "..", "skills")
   ];
   for (const candidate of candidates) {
     try {
-      if (existsSync9(candidate) && statSync3(candidate).isDirectory() && collectSkillFiles(candidate).length > 0) return candidate;
+      if (existsSync10(candidate) && statSync3(candidate).isDirectory() && collectSkillFiles(candidate).length > 0) return candidate;
     } catch {
     }
   }
@@ -2737,7 +2993,7 @@ function walkWorkspace(workspace, maxEntries = 8e3) {
     for (const entry of entries) {
       if (files.length + dirs.length >= maxEntries) return;
       if (ignoredDirectories.has(entry.name)) continue;
-      const fullPath = join9(current, entry.name);
+      const fullPath = join10(current, entry.name);
       const relPath = relative4(workspace, fullPath).replace(/\\/g, "/");
       if (entry.isDirectory()) {
         dirs.push(relPath);
@@ -2761,7 +3017,7 @@ function collectSkillFiles(skillsRoot) {
     }
     for (const entry of entries) {
       if (entry.name.startsWith(".")) continue;
-      const fullPath = join9(current, entry.name);
+      const fullPath = join10(current, entry.name);
       if (entry.isDirectory()) {
         walk(fullPath);
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -2857,7 +3113,7 @@ function pathMatchesGlob(path, glob) {
   return new RegExp(`^${escaped}$`).test(path);
 }
 function packageJsonHasDependency(workspace, dep) {
-  const parsed = readJson(join9(workspace, "package.json"));
+  const parsed = readJson(join10(workspace, "package.json"));
   if (!parsed) return false;
   for (const key of ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]) {
     const deps = parsed[key];
@@ -2879,7 +3135,7 @@ function selectContentFiles(files) {
 }
 function anyContentContains(workspace, files, needle) {
   return files.some((file) => {
-    const content = safeRead(join9(workspace, file), 12e4);
+    const content = safeRead(join10(workspace, file), 12e4);
     return typeof needle === "string" ? content.includes(needle) : needle.test(content);
   });
 }
@@ -2890,20 +3146,20 @@ function detectWorkspaceSignals(ctx) {
   const go = hasRootFile(files, "go.mod");
   const pkgMigrations = files.some((file) => /^pkg\/[^/]+\/migrations\//.test(file));
   const goHouse = go && pkgMigrations && anyContentContains(workspace, contentFiles, "Module.Attach");
-  const goHuma = go && (safeRead(join9(workspace, "go.sum")).includes("github.com/danielgtaylor/huma") || dirs.includes("internal/store/gen") || normalize(ctx.hints.stack ?? "") === "backend-go-huma" || /artifacts\/backend-go|backend-go-huma/i.test(ctx.taskHint ?? ""));
+  const goHuma = go && (safeRead(join10(workspace, "go.sum")).includes("github.com/danielgtaylor/huma") || dirs.includes("internal/store/gen") || normalize(ctx.hints.stack ?? "") === "backend-go-huma" || /artifacts\/backend-go|backend-go-huma/i.test(ctx.taskHint ?? ""));
   const ios = hasRootFile(files, "Package.swift") || hasRootDir(dirs, /(?:^|\/)[^/]+\.xcodeproj$/);
   const swiftData = ios && anyContentContains(workspace, contentFiles, "@Model");
   const revenueCatIos = ios && (anyContentContains(workspace, contentFiles, "import RevenueCat") || anyContentContains(workspace, contentFiles, /RevenueCat/i));
   const gradleFiles = files.filter((file) => /(?:^|\/)build\.gradle(?:\.kts)?$/.test(file));
-  const android = hasRootFile(files, "build.gradle.kts") || gradleFiles.some((file) => file.endsWith("build.gradle.kts") || /kotlin/i.test(safeRead(join9(workspace, file), 8e4)));
-  const libsVersions = safeRead(join9(workspace, "gradle/libs.versions.toml"), 12e4);
+  const android = hasRootFile(files, "build.gradle.kts") || gradleFiles.some((file) => file.endsWith("build.gradle.kts") || /kotlin/i.test(safeRead(join10(workspace, file), 8e4)));
+  const libsVersions = safeRead(join10(workspace, "gradle/libs.versions.toml"), 12e4);
   const room = android && /room/i.test(libsVersions);
   const retrofit = android && anyContentContains(workspace, contentFiles, /import\s+retrofit2\b/);
   const revenueCatAndroid = android && anyContentContains(workspace, contentFiles, "com.revenuecat.purchases");
-  const packageJson = safeRead(join9(workspace, "package.json"), 12e4);
+  const packageJson = safeRead(join10(workspace, "package.json"), 12e4);
   const next = (hasRootFile(files, "next.config.js") || hasRootFile(files, "next.config.ts") || hasRootFile(files, "next.config.mjs")) && /"next"\s*:/.test(packageJson);
   const tailwindV4 = anyContentContains(workspace, files.filter((file) => file.endsWith(".css")), '@import "tailwindcss"') || packageJsonHasDependency(workspace, "@tailwindcss/postcss");
-  const shadcn = hasRootFile(files, "components.json") || safeExists(join9(workspace, "components/ui")) || safeExists(join9(workspace, "src/components/ui")) || dirs.includes("components/ui") || dirs.includes("src/components/ui");
+  const shadcn = hasRootFile(files, "components.json") || safeExists(join10(workspace, "components/ui")) || safeExists(join10(workspace, "src/components/ui")) || dirs.includes("components/ui") || dirs.includes("src/components/ui");
   const fastlane = hasRootFile(files, "fastlane/Fastfile");
   return {
     files,
@@ -2933,7 +3189,7 @@ function frontmatterConditionReason(condition, ctx, signals) {
     case "always":
       return "always";
     case "workspace.has":
-      return safeExists(join9(ctx.workspace, condition.path)) ? "workspace" : null;
+      return safeExists(join10(ctx.workspace, condition.path)) ? "workspace" : null;
     case "workspace.hasGlob":
       return [...signals.files, ...signals.dirs].some((path) => pathMatchesGlob(path, condition.glob)) ? "workspace" : null;
     case "workspace.packageJson":
@@ -3141,7 +3397,7 @@ function loadSkillPacksFromFiles(ctx, skillsRoot, files) {
   return enforceBudget(matched).map((pack) => ({
     slug: pack.frontmatter.slug,
     title: pack.title,
-    sourcePath: join9(skillsRoot, `${pack.relativePath}.md`),
+    sourcePath: join10(skillsRoot, `${pack.relativePath}.md`),
     content: pack.body,
     tokens: pack.tokens,
     reason: pack.reason
@@ -3201,11 +3457,11 @@ function formatSkillPackSummary(packs) {
 }
 
 // src/agent/systemPrompt.ts
-import { existsSync as existsSync10, readFileSync as readFileSync7 } from "fs";
-import { basename as basename2, join as join10 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync7 } from "fs";
+import { basename as basename2, join as join11 } from "path";
 function readProjectInstructions(workspace) {
-  const path = join10(workspace, ".tania", "INSTRUCTIONS.md");
-  if (!existsSync10(path)) return "";
+  const path = join11(workspace, ".tania", "INSTRUCTIONS.md");
+  if (!existsSync11(path)) return "";
   try {
     const content = readFileSync7(path, "utf8").trim();
     return content ? `
@@ -3860,9 +4116,9 @@ function withoutParent(ctx) {
 }
 
 // src/safety/permissions/rules.ts
-import { existsSync as existsSync11, readFileSync as readFileSync8 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync8 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 
 // src/safety/permissions/schema.ts
 var PERMISSIONS_SCHEMA_VERSION = 1;
@@ -4045,15 +4301,15 @@ function positiveNumber(value) {
 function loadPermissionRules(options) {
   const home = options.home ?? homedir2();
   const candidates = [
-    join11(home, ".tania", "permissions.json"),
-    join11(home, ".tanya", "permissions.json"),
-    join11(options.cwd, ".tania", "permissions.json")
+    join12(home, ".tania", "permissions.json"),
+    join12(home, ".tanya", "permissions.json"),
+    join12(options.cwd, ".tania", "permissions.json")
   ];
   let rules = cloneRules(DEFAULT_PERMISSION_RULES);
   const sources = [];
   const issues = [];
   for (const file of candidates) {
-    if (!existsSync11(file)) continue;
+    if (!existsSync12(file)) continue;
     const parsed = parsePermissionsJson(readFileSync8(file, "utf8"));
     if (!parsed.ok) {
       issues.push(...parsed.issues.map((issue2) => ({ ...issue2, file })));
@@ -4187,9 +4443,9 @@ function globPrefix(glob) {
 }
 
 // src/tools/fsTools.ts
-import { existsSync as existsSync16, readdirSync as readdirSync6 } from "fs";
+import { existsSync as existsSync17, readdirSync as readdirSync6 } from "fs";
 import { cp, mkdir as mkdir7, readFile as readFile8, realpath, unlink, writeFile as writeFile7 } from "fs/promises";
-import { basename as basename4, dirname as dirname9, isAbsolute, join as join15, relative as relative8, resolve as resolve7 } from "path";
+import { basename as basename4, dirname as dirname9, isAbsolute, join as join16, relative as relative8, resolve as resolve7 } from "path";
 import { spawn as spawn2 } from "child_process";
 import sharp2 from "sharp";
 
@@ -4663,8 +4919,8 @@ var validateAndroidLauncherIconSetTool = {
 
 // src/tools/projectContextTools.ts
 import { readdir as readdir2, readFile as readFile4, stat } from "fs/promises";
-import { existsSync as existsSync12 } from "fs";
-import { basename as basename3, extname, join as join12, relative as relative5, resolve as resolve4 } from "path";
+import { existsSync as existsSync13 } from "fs";
+import { basename as basename3, extname, join as join13, relative as relative5, resolve as resolve4 } from "path";
 var ignoredNames2 = /* @__PURE__ */ new Set([
   ".git",
   "node_modules",
@@ -4803,7 +5059,7 @@ async function collectFiles(root, maxFiles, current = root, out = []) {
   for (const entry of entries) {
     if (out.length >= maxFiles) break;
     if (ignoredNames2.has(entry.name)) continue;
-    const fullPath = join12(current, entry.name);
+    const fullPath = join13(current, entry.name);
     const rel = normalizePath(relative5(root, fullPath));
     if (entry.isDirectory()) {
       if (entry.name === ".tania") {
@@ -4823,13 +5079,13 @@ async function collectFiles(root, maxFiles, current = root, out = []) {
 async function collectTanyaFiles(root, taniaDir, maxFiles, out) {
   for (const rel of ["INSTRUCTIONS.md", "artifacts/manifest.json"]) {
     if (out.length >= maxFiles) return;
-    const abs = join12(taniaDir, rel);
+    const abs = join13(taniaDir, rel);
     try {
       if ((await stat(abs)).isFile()) out.push(normalizePath(relative5(root, abs)));
     } catch {
     }
   }
-  const contextDir = join12(taniaDir, "context");
+  const contextDir = join13(taniaDir, "context");
   try {
     if ((await stat(contextDir)).isDirectory()) {
       out.push(normalizePath(relative5(root, contextDir)) + "/");
@@ -4848,7 +5104,7 @@ async function readExcerpt(path, maxChars) {
   }
 }
 async function readPackageScripts2(root) {
-  const path = join12(root, "package.json");
+  const path = join13(root, "package.json");
   try {
     const parsed = JSON.parse(await readFile4(path, "utf8"));
     return Object.fromEntries(
@@ -5287,7 +5543,7 @@ var inspectProjectContextTool = {
       const candidates = ["artifacts/description.md", ".tania/artifacts/description.md"];
       for (const rel of candidates) {
         const abs = resolve4(root, rel);
-        if (existsSync12(abs)) {
+        if (existsSync13(abs)) {
           const head = (await readFile4(abs, "utf8")).split("\n").slice(0, 24).join("\n");
           artifactsCatalog = { hint: `Read ${rel} (full file) for the complete artifact catalog before writing code from scratch.`, head };
           break;
@@ -5394,9 +5650,9 @@ var buildTaskBriefTool = {
 };
 
 // src/obsidian/search.ts
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 import { mkdir as mkdir5, readdir as readdir3, readFile as readFile5, stat as stat2, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname7, join as join13, relative as relative6, resolve as resolve5 } from "path";
+import { dirname as dirname7, join as join14, relative as relative6, resolve as resolve5 } from "path";
 var ignoredNames3 = /* @__PURE__ */ new Set([".obsidian", ".trash", ".git", "node_modules", ".tania"]);
 var stopwords = /* @__PURE__ */ new Set([
   "a",
@@ -5438,7 +5694,7 @@ async function collectMarkdownFiles(root, maxFiles, current = root, out = []) {
   for (const entry of entries) {
     if (out.length >= maxFiles) break;
     if (ignoredNames3.has(entry.name)) continue;
-    const fullPath = join13(current, entry.name);
+    const fullPath = join14(current, entry.name);
     if (entry.isDirectory()) {
       await collectMarkdownFiles(root, maxFiles, fullPath, out);
     } else if (entry.isFile() && /\.md$/i.test(entry.name)) {
@@ -5497,7 +5753,7 @@ function safeMaterializedPath(relPath) {
 }
 async function searchObsidianNotes(input) {
   const vault = resolve5(input.vaultPath);
-  if (!existsSync13(vault)) return [];
+  if (!existsSync14(vault)) return [];
   const queryTerms = terms(input.query);
   const maxResults = Math.min(input.maxResults ?? 5, 20);
   const maxFiles = Math.min(input.maxFiles ?? 1e3, 5e3);
@@ -5649,18 +5905,18 @@ var searchObsidianNotesTool = {
 };
 
 // src/memory/resultCache.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync2, readdirSync as readdirSync5, rmSync, statSync as statSync4, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync2, readdirSync as readdirSync5, rmSync, statSync as statSync4, writeFileSync as writeFileSync2 } from "fs";
 import { readFile as readFile6 } from "fs/promises";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 var RESULT_CACHE_MAX_BYTES = 100 * 1024 * 1024;
 function safeSegment(value) {
   return value.replace(/[^A-Za-z0-9_.-]+/g, "_").slice(0, 160) || "result";
 }
 function resultCacheDir(workspace, runId) {
-  return join14(workspace, ".tania", "cache", "results", safeSegment(runId));
+  return join15(workspace, ".tania", "cache", "results", safeSegment(runId));
 }
 function resultCachePath(workspace, runId, toolCallId) {
-  return join14(resultCacheDir(workspace, runId), `${safeSegment(toolCallId)}.txt`);
+  return join15(resultCacheDir(workspace, runId), `${safeSegment(toolCallId)}.txt`);
 }
 function writeCachedToolResult(workspace, runId, toolCallId, content) {
   const dir = resultCacheDir(workspace, runId);
@@ -5672,7 +5928,7 @@ function writeCachedToolResult(workspace, runId, toolCallId, content) {
 }
 async function readCachedToolResult(workspace, runId, toolCallId, range) {
   const path = resultCachePath(workspace, runId, toolCallId);
-  if (!existsSync14(path)) return null;
+  if (!existsSync15(path)) return null;
   const buffer = await readFile6(path);
   if (!range) return buffer.toString("utf8");
   const start = Math.max(0, Math.floor(range.startByte));
@@ -5702,7 +5958,7 @@ function evictRunCache(dir) {
 function cacheEntries(dir) {
   try {
     return readdirSync5(dir).filter((file) => file.endsWith(".txt")).flatMap((file) => {
-      const path = join14(dir, file);
+      const path = join15(dir, file);
       try {
         const stat8 = statSync4(path);
         return stat8.isFile() ? [{ path, size: stat8.size, mtimeMs: stat8.mtimeMs }] : [];
@@ -5788,7 +6044,7 @@ var expandResultTool = {
 };
 
 // src/agent/subAgentContext.ts
-import { existsSync as existsSync15, realpathSync as realpathSync2 } from "fs";
+import { existsSync as existsSync16, realpathSync as realpathSync2 } from "fs";
 import { randomUUID } from "crypto";
 import { relative as relative7, resolve as resolve6 } from "path";
 function createRootRunId(now = /* @__PURE__ */ new Date()) {
@@ -5806,7 +6062,7 @@ function resolveSubAgentWorkspace(parentWorkspace, requestedWorkspace) {
   if (lexicalRel.startsWith("..") || lexicalRel === "..") {
     throw new Error(`Sub-agent workspace escapes parent workspace: ${requestedWorkspace ?? target}`);
   }
-  if (!existsSync15(target)) return target;
+  if (!existsSync16(target)) return target;
   const realParent = realpathSync2(parentWorkspace);
   const realTarget = realpathSync2(target);
   const realRel = relative7(realParent, realTarget);
@@ -6495,7 +6751,11 @@ var recordMetricsDashboardHandoffTool = {
 
 // src/tools/fsTools.ts
 var ignoredNames4 = /* @__PURE__ */ new Set([".git", "node_modules", ".next", "dist", "build", ".turbo", ".cache"]);
-var PROGRESS_THROTTLE_MS = 2e3;
+function getProgressThrottleMs() {
+  const raw = Number(process.env.TANYA_PROGRESS_THROTTLE_MS);
+  return Number.isFinite(raw) && raw >= 0 ? raw : 2e3;
+}
+var PROGRESS_THROTTLE_MS = getProgressThrottleMs();
 function isProtectedLocalConfigPath(filePath) {
   return basename4(filePath.trim().replace(/\\/g, "/")) === "local.properties";
 }
@@ -6537,13 +6797,13 @@ function asOptionalBoolean3(input, key, fallback) {
   return fallback;
 }
 async function pathExists(path) {
-  return existsSync16(path);
+  return existsSync17(path);
 }
 function collectFiles2(root, maxFiles, current = root, out = []) {
   if (out.length >= maxFiles) return out;
   for (const entry of readdirSync6(current, { withFileTypes: true })) {
     if (ignoredNames4.has(entry.name)) continue;
-    const fullPath = join15(current, entry.name);
+    const fullPath = join16(current, entry.name);
     if (entry.isDirectory()) {
       collectFiles2(root, maxFiles, fullPath, out);
     } else if (entry.isFile()) {
@@ -6637,7 +6897,7 @@ function runShell(script, context, timeoutMs, cwd = context.workspace) {
       if (!context.onProgress || !chunk) return;
       progressBuffers[stream] += chunk;
       if (progressTimers[stream]) return;
-      progressTimers[stream] = setTimeout(() => flushProgress(stream), PROGRESS_THROTTLE_MS);
+      progressTimers[stream] = setTimeout(() => flushProgress(stream), getProgressThrottleMs());
       progressTimers[stream]?.unref?.();
     };
     const outputSoFar = () => `${stdout2}${stderr ? `
@@ -7421,16 +7681,16 @@ var validateAppleProjectFilesTool = {
     let pbxprojText = "";
     if (xcodeprojPath) {
       const projectDir = resolveInsideWorkspace(context.workspace, ensureRelativePath3(xcodeprojPath));
-      if (!existsSync16(projectDir)) {
+      if (!existsSync17(projectDir)) {
         problems.push(`Missing ${xcodeprojPath}.`);
       } else {
         const pbxprojPath = resolveInsideWorkspace(context.workspace, `${xcodeprojPath.replace(/\/+$/, "")}/project.pbxproj`);
-        if (existsSync16(pbxprojPath)) pbxprojText = await readFile8(pbxprojPath, "utf8");
+        if (existsSync17(pbxprojPath)) pbxprojText = await readFile8(pbxprojPath, "utf8");
       }
     }
     for (const requiredPath of requiredPaths) {
       const relPath = ensureRelativePath3(requiredPath);
-      if (!existsSync16(resolveInsideWorkspace(context.workspace, relPath))) {
+      if (!existsSync17(resolveInsideWorkspace(context.workspace, relPath))) {
         problems.push(`Missing ${relPath}.`);
       }
       if (requireProjectReferences && pbxprojText) {
@@ -7478,7 +7738,7 @@ var validateFastlaneConfigTool = {
     let fastfile = "";
     const fastfileRel = ensureRelativePath3(fastfilePath);
     const fastfileAbs = resolveInsideWorkspace(context.workspace, fastfileRel);
-    if (!existsSync16(fastfileAbs)) {
+    if (!existsSync17(fastfileAbs)) {
       problems.push(`Missing ${fastfileRel}.`);
     } else {
       fastfile = await readFile8(fastfileAbs, "utf8");
@@ -7516,11 +7776,11 @@ var validateFastlaneConfigTool = {
     }
     for (const file of requiredFiles) {
       const relPath = ensureRelativePath3(file);
-      if (!existsSync16(resolveInsideWorkspace(context.workspace, relPath))) problems.push(`Missing ${relPath}.`);
+      if (!existsSync17(resolveInsideWorkspace(context.workspace, relPath))) problems.push(`Missing ${relPath}.`);
     }
     for (const file of forbiddenFiles) {
       const relPath = ensureRelativePath3(file);
-      if (existsSync16(resolveInsideWorkspace(context.workspace, relPath))) problems.push(`Forbidden file exists: ${relPath}.`);
+      if (existsSync17(resolveInsideWorkspace(context.workspace, relPath))) problems.push(`Forbidden file exists: ${relPath}.`);
     }
     return {
       ok: problems.length === 0,
@@ -7623,7 +7883,7 @@ async function findLargestAppIconPng(context, viewPath) {
   const viewDir = dirname9(viewPath).replace(/\\/g, "/");
   const appIconDir = `${viewDir}/Assets.xcassets/AppIcon.appiconset`;
   const appIconAbs = resolveInsideWorkspace(context.workspace, appIconDir);
-  if (!existsSync16(appIconAbs)) return null;
+  if (!existsSync17(appIconAbs)) return null;
   const pngs = readdirSync6(appIconAbs, { withFileTypes: true }).filter((entry) => entry.isFile() && /\.png$/i.test(entry.name)).map((entry) => `${appIconDir}/${entry.name}`);
   if (pngs.length === 0) return null;
   const score = (path) => {
@@ -7736,7 +7996,7 @@ var createIosSplashTool = {
     ]) ?? await findLargestAppIconPng(context, viewPath);
     if (resolvedSourceIcon) {
       const sourceAbs = isAbsolute(resolvedSourceIcon) ? resolvedSourceIcon : resolveInsideWorkspace(context.workspace, ensureRelativePath3(resolvedSourceIcon));
-      if (!existsSync16(sourceAbs)) {
+      if (!existsSync17(sourceAbs)) {
         return { ok: false, summary: "Source splash icon not found.", error: `Missing source icon: ${resolvedSourceIcon}` };
       }
       await mkdir7(dirname9(resolveInsideWorkspace(context.workspace, iconPath)), { recursive: true });
@@ -7880,7 +8140,7 @@ function addDependencyLine(gradle, line) {
 async function maybePatchAndroidGradle(context, rootGradlePath, moduleGradlePath) {
   const files = [];
   const rootAbs = resolveInsideWorkspace(context.workspace, rootGradlePath);
-  if (existsSync16(rootAbs)) {
+  if (existsSync17(rootAbs)) {
     const rootGradle = await readFile8(rootAbs, "utf8");
     const nextRootGradle = addLineBeforeClosingPluginsBlock(rootGradle, 'id("com.google.devtools.ksp") version "1.9.24-1.0.20" apply false');
     if (nextRootGradle !== rootGradle) {
@@ -7889,7 +8149,7 @@ async function maybePatchAndroidGradle(context, rootGradlePath, moduleGradlePath
     }
   }
   const moduleAbs = resolveInsideWorkspace(context.workspace, moduleGradlePath);
-  if (existsSync16(moduleAbs)) {
+  if (existsSync17(moduleAbs)) {
     let moduleGradle = await readFile8(moduleAbs, "utf8");
     const before = moduleGradle;
     moduleGradle = addLineBeforeClosingPluginsBlock(moduleGradle, 'id("com.google.devtools.ksp")');
@@ -7960,7 +8220,7 @@ var createAndroidFoundationTool = {
     ];
     for (const [path, content] of outputs) {
       const target = resolveInsideWorkspace(context.workspace, path);
-      if (preserveExisting && existsSync16(target)) continue;
+      if (preserveExisting && existsSync17(target)) continue;
       await mkdir7(dirname9(target), { recursive: true });
       await writeFile7(target, content, "utf8");
       files.push(path);
@@ -8277,8 +8537,8 @@ var commitPlatformChangesTool = {
       const cleanPath = normalizeRelativePathForGit(path);
       const workspaceCandidate = resolveInsideWorkspace(realWorkspace, cleanPath);
       const repoCandidate = resolveInsideWorkspace(realRepoRoot, cleanPath);
-      if (existsSync16(repoCandidate)) return relative8(realRepoRoot, await realpath(repoCandidate)).replace(/\\/g, "/");
-      if (existsSync16(workspaceCandidate)) return relative8(realRepoRoot, await realpath(workspaceCandidate)).replace(/\\/g, "/");
+      if (existsSync17(repoCandidate)) return relative8(realRepoRoot, await realpath(repoCandidate)).replace(/\\/g, "/");
+      if (existsSync17(workspaceCandidate)) return relative8(realRepoRoot, await realpath(workspaceCandidate)).replace(/\\/g, "/");
       const workspacePrefix = normalizeRelativePathForGit(relative8(realRepoRoot, realWorkspace));
       if (workspacePrefix && workspacePrefix !== "." && (cleanPath === workspacePrefix || cleanPath.startsWith(`${workspacePrefix}/`))) return cleanPath;
       const workspaceRelative = normalizeRelativePathForGit(relative8(realRepoRoot, workspaceCandidate));
@@ -8400,7 +8660,7 @@ function defaultTools() {
     runCommandTool,
     runShellTool
   ].map((tool) => /^validate_/.test(tool.name) || tool.name === "scan_secrets" ? { ...tool, preferredModel: verificationPreferredModel } : tool);
-  return tools.filter((tool) => tool.name !== "search" || existsSync16("/usr/bin/rg") || existsSync16("/opt/homebrew/bin/rg") || existsSync16("/usr/local/bin/rg"));
+  return tools.filter((tool) => tool.name !== "search" || existsSync17("/usr/bin/rg") || existsSync17("/opt/homebrew/bin/rg") || existsSync17("/usr/local/bin/rg"));
 }
 
 // src/tools/registry.ts
@@ -8429,7 +8689,7 @@ var ToolRegistry = class {
 // src/memory/goldenTasks.ts
 import { appendFile as appendFile2, mkdir as mkdir8, readFile as readFile9, stat as stat3, writeFile as writeFile8, rename } from "fs/promises";
 import { createHash as createHash2 } from "crypto";
-import { dirname as dirname10, join as join16 } from "path";
+import { dirname as dirname10, join as join17 } from "path";
 var GOLDEN_TASK_MAX_BYTES = 10 * 1024 * 1024;
 var GOLDEN_TASK_KEEP_LATEST = 200;
 async function rotateGoldenTaskFileIfTooLarge(memoryPath) {
@@ -8468,7 +8728,7 @@ function taskSignature(runContext, manifest) {
 }
 async function recordGoldenTaskMemory(workspace, manifest, runContext) {
   if (!enabled(runContext)) return;
-  const memoryPath = join16(workspace, ".tania", "memory", "golden-tasks.jsonl");
+  const memoryPath = join17(workspace, ".tania", "memory", "golden-tasks.jsonl");
   const validationErrors = manifest.validation?.issues.filter((issue2) => issue2.severity === "error") ?? [];
   const record = {
     schemaVersion: 1,
@@ -8492,7 +8752,7 @@ async function recordGoldenTaskMemory(workspace, manifest, runContext) {
   await rotateGoldenTaskFileIfTooLarge(memoryPath);
 }
 async function readGoldenTaskMemory(workspace) {
-  const memoryPath = join16(workspace, ".tania", "memory", "golden-tasks.jsonl");
+  const memoryPath = join17(workspace, ".tania", "memory", "golden-tasks.jsonl");
   let raw = "";
   try {
     raw = await readFile9(memoryPath, "utf8");
@@ -8552,9 +8812,9 @@ function validateGoldenTaskSummary(summary) {
 import { appendFile as appendFile3, mkdir as mkdir9, readFile as readFile10 } from "fs/promises";
 import { createHash as createHash3 } from "crypto";
 import { homedir as homedir3 } from "os";
-import { dirname as dirname11, join as join17 } from "path";
+import { dirname as dirname11, join as join18 } from "path";
 function memoryRoot() {
-  return envValue({}, "TANYA_MEMORY_HOME").trim() || join17(homedir3(), ".tania", "memory");
+  return envValue({}, "TANYA_MEMORY_HOME").trim() || join18(homedir3(), ".tania", "memory");
 }
 function taskSignature2(runContext, attempts) {
   const source = JSON.stringify({
@@ -8578,7 +8838,7 @@ async function recordRepairRunMemory(runContext, attempts, manifest) {
     finalIssueIds: finalErrors,
     finalBlockers: manifest.blockers
   };
-  const path = join17(memoryRoot(), "repair-runs.jsonl");
+  const path = join18(memoryRoot(), "repair-runs.jsonl");
   await mkdir9(dirname11(path), { recursive: true });
   await appendFile3(path, `${JSON.stringify(record)}
 `, "utf8");
@@ -8586,7 +8846,7 @@ async function recordRepairRunMemory(runContext, attempts, manifest) {
 
 // src/obsidian/vaultAppender.ts
 import { appendFile as appendFile4, mkdir as mkdir10, writeFile as writeFile9 } from "fs/promises";
-import { dirname as dirname12, join as join18 } from "path";
+import { dirname as dirname12, join as join19 } from "path";
 function dailyNoteName(date = /* @__PURE__ */ new Date()) {
   const year = date.getFullYear();
   const month = String(date.getMonth() + 1).padStart(2, "0");
@@ -8620,7 +8880,7 @@ function buildTaskSection(manifest, runContext) {
   ].join("\n");
 }
 async function appendTaskToVault(vaultPath, manifest, runContext) {
-  const notePath = join18(vaultPath, dailyNoteName());
+  const notePath = join19(vaultPath, dailyNoteName());
   await mkdir10(dirname12(notePath), { recursive: true });
   try {
     await writeFile9(notePath, "", { flag: "wx" });
@@ -8630,21 +8890,21 @@ async function appendTaskToVault(vaultPath, manifest, runContext) {
 }
 
 // src/memory/auditLog.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync3, readFileSync as readFileSync9, statSync as statSync5, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync18, mkdirSync as mkdirSync3, readFileSync as readFileSync9, statSync as statSync5, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
 import { gzipSync } from "zlib";
-import { basename as basename5, join as join19 } from "path";
+import { basename as basename5, join as join20 } from "path";
 var DEFAULT_AUDIT_MAX_BYTES = 50 * 1024 * 1024;
 var DEFAULT_AUDIT_MAX_AGE_MS = 90 * 24 * 60 * 60 * 1e3;
 function appendAuditDecision(workspace, entry, options = {}) {
   const path = auditPath(workspace);
-  mkdirSync3(join19(workspace, ".tania"), { recursive: true });
+  mkdirSync3(join20(workspace, ".tania"), { recursive: true });
   rotateAuditIfNeeded(workspace, options);
   writeFileSync3(path, `${JSON.stringify(entry)}
 `, { encoding: "utf8", flag: "a" });
 }
 function readAuditDecisions(workspace, filters = {}) {
   const path = auditPath(workspace);
-  if (!existsSync17(path)) return [];
+  if (!existsSync18(path)) return [];
   const sinceTs = filters.sinceMs === void 0 ? null : Date.now() - filters.sinceMs;
   const entries = readFileSync9(path, "utf8").split("\n").filter(Boolean).flatMap((line) => {
     try {
@@ -8657,20 +8917,20 @@ function readAuditDecisions(workspace, filters = {}) {
   return entries.slice(Math.max(0, entries.length - limit));
 }
 function auditPath(workspace) {
-  return join19(workspace, ".tania", "audit.jsonl");
+  return join20(workspace, ".tania", "audit.jsonl");
 }
 function rotateAuditIfNeeded(workspace, options) {
   const path = auditPath(workspace);
-  if (!existsSync17(path)) return;
+  if (!existsSync18(path)) return;
   const stats = statSync5(path);
   const maxBytes = options.maxBytes ?? DEFAULT_AUDIT_MAX_BYTES;
   const maxAgeMs = options.maxAgeMs ?? DEFAULT_AUDIT_MAX_AGE_MS;
   const now = options.now ?? /* @__PURE__ */ new Date();
   if (stats.size < maxBytes && now.getTime() - stats.mtimeMs < maxAgeMs) return;
-  const archiveDir = join19(workspace, ".tania", "audit", "archive");
+  const archiveDir = join20(workspace, ".tania", "audit", "archive");
   mkdirSync3(archiveDir, { recursive: true });
   const stamp = now.toISOString().replace(/[:.]/g, "-");
-  const archivePath2 = join19(archiveDir, `audit-${stamp}-${basename5(path)}.gz`);
+  const archivePath2 = join20(archiveDir, `audit-${stamp}-${basename5(path)}.gz`);
   writeFileSync3(archivePath2, gzipSync(readFileSync9(path)));
   unlinkSync(path);
 }
@@ -8740,9 +9000,9 @@ var FileReadDedupCache = class {
 };
 
 // src/memory/reasoningArchive.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync4, readFileSync as readFileSync10, renameSync, statSync as statSync6, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync4, readFileSync as readFileSync10, renameSync, statSync as statSync6, writeFileSync as writeFileSync4 } from "fs";
 import { appendFile as appendFile5 } from "fs/promises";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 async function appendReasoningChunk(params) {
   if (!params.content) return;
   const dir = reasoningRunDir(params.workspace, params.runId);
@@ -8761,7 +9021,7 @@ async function appendReasoningChunk(params) {
 }
 function readReasoningArchive(workspace, runId) {
   const file = reasoningArchivePath(workspace, runId);
-  if (!existsSync18(file)) return [];
+  if (!existsSync19(file)) return [];
   return readFileSync10(file, "utf8").split(/\n+/).filter(Boolean).flatMap((line) => {
     try {
       const parsed = JSON.parse(line);
@@ -8783,7 +9043,7 @@ function readReasoningArchive(workspace, runId) {
 }
 function evictReasoningFromArchive(workspace, runId, thresholdBytes) {
   const file = reasoningArchivePath(workspace, runId);
-  if (!existsSync18(file)) return 0;
+  if (!existsSync19(file)) return 0;
   const before = statSync6(file).size;
   if (before <= thresholdBytes) return 0;
   const entries = readReasoningArchive(workspace, runId);
@@ -8803,40 +9063,40 @@ function evictReasoningFromArchive(workspace, runId, thresholdBytes) {
   return Math.max(0, before - statSync6(file).size);
 }
 function reasoningArchivePath(workspace, runId) {
-  return join20(reasoningRunDir(workspace, runId), "reasoning.jsonl");
+  return join21(reasoningRunDir(workspace, runId), "reasoning.jsonl");
 }
 function reasoningRunDir(workspace, runId) {
-  return join20(workspace, ".tania", "runs", runId);
+  return join21(workspace, ".tania", "runs", runId);
 }
 
 // src/mcp/client.ts
-import { createWriteStream, existsSync as existsSync20, mkdirSync as mkdirSync5, renameSync as renameSync2, statSync as statSync7, unlinkSync as unlinkSync2 } from "fs";
-import { join as join22 } from "path";
+import { createWriteStream, existsSync as existsSync21, mkdirSync as mkdirSync5, renameSync as renameSync2, statSync as statSync7, unlinkSync as unlinkSync2 } from "fs";
+import { join as join23 } from "path";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 
 // src/mcp/config.ts
-import { existsSync as existsSync19, readFileSync as readFileSync11 } from "fs";
+import { existsSync as existsSync20, readFileSync as readFileSync11 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 var EMPTY_CONFIG = { version: 1, servers: [] };
 var TRANSPORTS = /* @__PURE__ */ new Set(["stdio", "sse", "http"]);
 function loadMcpConfig(options) {
   const home = options.home ?? homedir4();
-  const userCurrent = join21(home, ".tanya", "mcp.json");
-  const userLegacy = join21(home, ".tania", "mcp.json");
-  const userFile = existsSync19(userCurrent) ? userCurrent : existsSync19(userLegacy) ? userLegacy : null;
+  const userCurrent = join22(home, ".tanya", "mcp.json");
+  const userLegacy = join22(home, ".tania", "mcp.json");
+  const userFile = existsSync20(userCurrent) ? userCurrent : existsSync20(userLegacy) ? userLegacy : null;
   const candidates = [
     ...userFile ? [userFile] : [],
-    join21(options.cwd, ".tania", "mcp.json")
+    join22(options.cwd, ".tania", "mcp.json")
   ];
   let config = cloneConfig(EMPTY_CONFIG);
   const sources = [];
   const issues = [];
   for (const file of candidates) {
-    if (!existsSync19(file)) continue;
+    if (!existsSync20(file)) continue;
     const parsed = parseMcpConfig(readFileSync11(file, "utf8"), file);
     if (!parsed.ok) {
       issues.push(...parsed.issues);
@@ -9077,7 +9337,7 @@ var McpClientManager = class {
   createTransport(config) {
     if (config.transport === "stdio") {
       const logPath = mcpLogPath(this.workspace, config.name);
-      mkdirSync5(join22(this.workspace, ".tania", "mcp", "logs"), { recursive: true });
+      mkdirSync5(join23(this.workspace, ".tania", "mcp", "logs"), { recursive: true });
       rotateMcpLogIfNeeded(logPath);
       const transport = new StdioClientTransport({
         command: config.command ?? "",
@@ -9225,15 +9485,15 @@ function mcpCallTimeoutMs() {
   return Math.max(1e3, numberEnvValue(process.env, "TANYA_MCP_CALL_TIMEOUT_MS", 3e4));
 }
 function mcpLogPath(workspace, serverName) {
-  return join22(workspace, ".tania", "mcp", "logs", `${serverName}.log`);
+  return join23(workspace, ".tania", "mcp", "logs", `${serverName}.log`);
 }
 function rotateMcpLogIfNeeded(path) {
-  if (!existsSync20(path)) return;
+  if (!existsSync21(path)) return;
   try {
     if (statSync7(path).size < 10 * 1024 * 1024) return;
     const rotated = `${path}.1`;
     try {
-      if (existsSync20(rotated)) unlinkSync2(rotated);
+      if (existsSync21(rotated)) unlinkSync2(rotated);
     } catch {
     }
     renameSync2(path, rotated);
@@ -9248,7 +9508,7 @@ function sleep2(ms) {
 }
 
 // src/agent/verifier/index.ts
-import { existsSync as existsSync22, readFileSync as readFileSync12 } from "fs";
+import { existsSync as existsSync23, readFileSync as readFileSync12 } from "fs";
 
 // src/agent/verifier/shell.ts
 import { execFile as execFile2 } from "child_process";
@@ -9285,8 +9545,8 @@ var realShell = async (cwd, command, args, options) => {
 };
 
 // src/agent/verifier/verifiers/goBackend.ts
-import { existsSync as existsSync21, readdirSync as readdirSync7, statSync as statSync8 } from "fs";
-import { dirname as dirname13, join as join23, relative as relative9, resolve as resolve8 } from "path";
+import { existsSync as existsSync22, readdirSync as readdirSync7, statSync as statSync8 } from "fs";
+import { dirname as dirname13, join as join24, relative as relative9, resolve as resolve8 } from "path";
 import { load as loadYaml } from "js-yaml";
 
 // src/agent/verifier/types.ts
@@ -9331,9 +9591,9 @@ function listDir(path) {
   }
 }
 function dirContainsGoFile(path) {
-  if (!existsSync21(path)) return false;
+  if (!existsSync22(path)) return false;
   for (const entry of listDir(path)) {
-    const full = join23(path, entry);
+    const full = join24(path, entry);
     try {
       const st = statSync8(full);
       if (st.isFile() && entry.endsWith(".go")) return true;
@@ -9354,7 +9614,7 @@ function scanGoFiles(workspace) {
     visited += 1;
     for (const entry of listDir(dir)) {
       if (entry === "node_modules" || entry === ".git" || entry === "dist" || entry === "build") continue;
-      const full = join23(dir, entry);
+      const full = join24(dir, entry);
       try {
         const st = statSync8(full);
         if (st.isFile() && entry.endsWith(".go")) {
@@ -9429,7 +9689,7 @@ function sqlFilesUnder(path) {
     if (!dir) break;
     visited += 1;
     for (const entry of listDir(dir)) {
-      const full = join23(dir, entry);
+      const full = join24(dir, entry);
       try {
         const st = statSync8(full);
         if (st.isFile() && entry.endsWith(".sql")) out.push(full);
@@ -9467,7 +9727,7 @@ function referencedSqlQueryFiles(workspace, queryPath) {
   const cleanQueryPath = queryPath.trim();
   if (!cleanQueryPath) return [];
   if (!/[*?]/.test(cleanQueryPath)) {
-    return sqlFilesUnder(join23(workspace, cleanQueryPath));
+    return sqlFilesUnder(join24(workspace, cleanQueryPath));
   }
   const firstGlob = cleanQueryPath.search(/[*?]/);
   const prefix = cleanQueryPath.slice(0, firstGlob);
@@ -9487,13 +9747,13 @@ var goBackendVerifier = {
   id: "go-backend",
   platform: "go-backend",
   appliesTo(ctx) {
-    if (ctx.fileExists(join23(ctx.workspace, "go.mod"))) return true;
+    if (ctx.fileExists(join24(ctx.workspace, "go.mod"))) return true;
     const text2 = combinedTaskText(ctx.runContext, ctx.prompt);
     return /\bgo\.mod\b/.test(text2) || /\bgolang\b/.test(text2);
   },
   async run(ctx) {
     const checks = [];
-    const goModPath = join23(ctx.workspace, "go.mod");
+    const goModPath = join24(ctx.workspace, "go.mod");
     const goModText = ctx.readText(goModPath);
     const text2 = combinedTaskText(ctx.runContext, ctx.prompt);
     checks.push(makeCheck({
@@ -9518,7 +9778,7 @@ var goBackendVerifier = {
     requireDep(/github\.com\/go-chi\/chi\/v5/, "chi/v5", mentionsAny(text2, CHI_PATTERNS));
     requireDep(/github\.com\/jackc\/pgx\/v5/, "pgx/v5", mentionsAny(text2, PGX_PATTERNS));
     if (mentionsAny(text2, REST_SERVER_PATTERNS)) {
-      const mainPath = join23(ctx.workspace, "cmd", "server", "main.go");
+      const mainPath = join24(ctx.workspace, "cmd", "server", "main.go");
       const present = ctx.fileExists(mainPath);
       checks.push(makeCheck({
         id: "cmd-server-main",
@@ -9528,7 +9788,7 @@ var goBackendVerifier = {
         error: present ? void 0 : "expected entrypoint at cmd/server/main.go"
       }));
     }
-    const internalPath = join23(ctx.workspace, "internal");
+    const internalPath = join24(ctx.workspace, "internal");
     if (mentionsAny(text2, INTERNAL_PKG_PATTERNS)) {
       const hasInternalGo = dirContainsGoFile(internalPath);
       checks.push(makeCheck({
@@ -9539,7 +9799,7 @@ var goBackendVerifier = {
         error: hasInternalGo ? void 0 : "expected at least one Go package under internal/"
       }));
     }
-    const sqlcPath = join23(ctx.workspace, "sqlc.yaml");
+    const sqlcPath = join24(ctx.workspace, "sqlc.yaml");
     const sqlcText = ctx.readText(sqlcPath);
     if (sqlcText && mentionsAny(text2, SQLC_PATTERNS)) {
       for (const entry of parseSqlcConfig(sqlcText)) {
@@ -9556,7 +9816,7 @@ var goBackendVerifier = {
             }));
             continue;
           }
-          const target = join23(ctx.workspace, dir);
+          const target = join24(ctx.workspace, dir);
           const present = ctx.fileExists(target) && dirContainsGoFile(target);
           checks.push(makeCheck({
             id: `sqlc-out-${dir}`,
@@ -9630,10 +9890,10 @@ var goBackendVerifier = {
 };
 
 // src/agent/verifier/verifiers/nodeBackend.ts
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 var BACKEND_DEP_HINTS = ["express", "fastify", "@nestjs/core", "hono", "koa", "@fastify/", "@hono/"];
 function readPackageJson(ctx) {
-  const text2 = ctx.readText(join24(ctx.workspace, "package.json"));
+  const text2 = ctx.readText(join25(ctx.workspace, "package.json"));
   if (!text2) return null;
   try {
     return JSON.parse(text2);
@@ -9694,10 +9954,10 @@ var nodeBackendVerifier = {
 };
 
 // src/agent/verifier/verifiers/frontend.ts
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 var FRONTEND_DEP_HINTS = ["next", "react", "vite", "@vitejs/", "@tanstack/router", "remix", "@remix-run/"];
 function readPackageJson2(ctx) {
-  const text2 = ctx.readText(join25(ctx.workspace, "package.json"));
+  const text2 = ctx.readText(join26(ctx.workspace, "package.json"));
   if (!text2) return null;
   try {
     return JSON.parse(text2);
@@ -9758,16 +10018,16 @@ var frontendVerifier = {
 };
 
 // src/agent/verifier/verifiers/mobile.ts
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 var iosVerifier = {
   id: "ios",
   platform: "ios",
   appliesTo(ctx) {
-    return ctx.fileExists(join26(ctx.workspace, "Package.swift"));
+    return ctx.fileExists(join27(ctx.workspace, "Package.swift"));
   },
   async run(ctx) {
     const checks = [];
-    const text2 = ctx.readText(join26(ctx.workspace, "Package.swift"));
+    const text2 = ctx.readText(join27(ctx.workspace, "Package.swift"));
     checks.push(makeCheck({
       id: "package-swift-present",
       description: "Package.swift exists",
@@ -9782,12 +10042,12 @@ var androidVerifier = {
   id: "android",
   platform: "android",
   appliesTo(ctx) {
-    return ctx.fileExists(join26(ctx.workspace, "build.gradle.kts")) || ctx.fileExists(join26(ctx.workspace, "settings.gradle.kts"));
+    return ctx.fileExists(join27(ctx.workspace, "build.gradle.kts")) || ctx.fileExists(join27(ctx.workspace, "settings.gradle.kts"));
   },
   async run(ctx) {
     const checks = [];
-    const buildGradle = ctx.readText(join26(ctx.workspace, "build.gradle.kts"));
-    const settingsGradle = ctx.readText(join26(ctx.workspace, "settings.gradle.kts"));
+    const buildGradle = ctx.readText(join27(ctx.workspace, "build.gradle.kts"));
+    const settingsGradle = ctx.readText(join27(ctx.workspace, "settings.gradle.kts"));
     const passed = buildGradle !== null || settingsGradle !== null;
     checks.push(makeCheck({
       id: "gradle-config-present",
@@ -9822,7 +10082,7 @@ function buildContext(options) {
     runContext: options.runContext,
     prompt: options.prompt ?? "",
     shell: options.shell ?? defaultShell(),
-    fileExists: (path) => existsSync22(path),
+    fileExists: (path) => existsSync23(path),
     readText: (path) => {
       try {
         return readFileSync12(path, "utf8");
@@ -9876,8 +10136,8 @@ async function verifyFinalState(options) {
 
 // src/agent/forbiddenPatterns.ts
 import { readFile as readFile11, writeFile as writeFile10, mkdir as mkdir11 } from "fs/promises";
-import { existsSync as existsSync23 } from "fs";
-import { join as join27 } from "path";
+import { existsSync as existsSync24 } from "fs";
+import { join as join28 } from "path";
 var TEST_DIR_EXCLUSIONS = /(?:^|\/)(?:test|tests|__tests__|spec|specs|androidTest)(?:\/|$)/;
 var DEFAULT_FORBIDDEN_PATTERNS = [
   {
@@ -10095,8 +10355,8 @@ var DEFAULT_FORBIDDEN_PATTERNS = [
   }
 ];
 async function loadProjectForbiddenPatterns(workspace) {
-  const candidate = join27(workspace, ".tania", "forbidden-patterns.json");
-  if (!existsSync23(candidate)) return [];
+  const candidate = join28(workspace, ".tania", "forbidden-patterns.json");
+  if (!existsSync24(candidate)) return [];
   try {
     const raw = await readFile11(candidate, "utf8");
     const parsed = JSON.parse(raw);
@@ -10122,7 +10382,7 @@ async function scanForbiddenPatterns(workspace, changedFiles, patterns2) {
     if (matchingPatterns.length === 0) continue;
     let content;
     try {
-      content = await readFile11(join27(workspace, file), "utf8");
+      content = await readFile11(join28(workspace, file), "utf8");
     } catch {
       continue;
     }
@@ -10146,10 +10406,10 @@ async function scanForbiddenPatterns(workspace, changedFiles, patterns2) {
 }
 async function recordFireMetrics(workspace, fireCounts) {
   try {
-    const metricsDir = join27(workspace, ".tania", "memory");
-    const metricsPath = join27(metricsDir, "forbidden-patterns-metrics.json");
+    const metricsDir = join28(workspace, ".tania", "memory");
+    const metricsPath = join28(metricsDir, "forbidden-patterns-metrics.json");
     let existing = { totals: {}, lastFiredAt: {} };
-    if (existsSync23(metricsPath)) {
+    if (existsSync24(metricsPath)) {
       try {
         const raw = await readFile11(metricsPath, "utf8");
         const parsed = JSON.parse(raw);
@@ -10177,11 +10437,11 @@ async function recordFireMetrics(workspace, fireCounts) {
 
 // src/agent/validators/core.ts
 import { readdir as readdir4, readFile as readFile12 } from "fs/promises";
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 
 // src/agent/validators/rules/load.ts
 import { readdirSync as readdirSync8, readFileSync as readFileSync13, statSync as statSync9 } from "fs";
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 
 // src/agent/validators/rules/index.ts
 var builtInValidatorRuleFiles = [];
@@ -10305,7 +10565,7 @@ function jsonFiles(path) {
   if (stat8.isFile()) return path.endsWith(".json") ? [path] : [];
   if (!stat8.isDirectory()) return [];
   try {
-    return readdirSync8(path, { withFileTypes: true }).flatMap((entry) => jsonFiles(join28(path, entry.name))).sort((a, b) => a.localeCompare(b));
+    return readdirSync8(path, { withFileTypes: true }).flatMap((entry) => jsonFiles(join29(path, entry.name))).sort((a, b) => a.localeCompare(b));
   } catch {
     return [];
   }
@@ -10462,7 +10722,7 @@ function featureCoveredByText(feature, implementationText) {
 }
 async function readWorkspaceFile(workspace, filePath) {
   try {
-    return await readFile12(join29(workspace, filePath), "utf8");
+    return await readFile12(join30(workspace, filePath), "utf8");
   } catch {
     return null;
   }
@@ -10479,7 +10739,7 @@ async function findWorkspaceFiles(workspace, predicate, options = {}) {
     if (results.length >= limit) return;
     let entries;
     try {
-      entries = await readdir4(join29(workspace, relativeDir), { withFileTypes: true });
+      entries = await readdir4(join30(workspace, relativeDir), { withFileTypes: true });
     } catch {
       return;
     }
@@ -12259,7 +12519,7 @@ function commitStillRequired(manifest, beforeGitSnapshot, runContext) {
 
 // src/agent/report.ts
 import { execFile as execFile4 } from "child_process";
-import { existsSync as existsSync24 } from "fs";
+import { existsSync as existsSync25 } from "fs";
 import { readdir as readdir6, rm, stat as stat6 } from "fs/promises";
 import { resolve as resolve10 } from "path";
 import { promisify as promisify4 } from "util";
@@ -12293,7 +12553,7 @@ async function cleanupGeneratedNoise(workspace) {
   }
   for (const relPath of generatedFastlanePaths) {
     const absPath = resolve10(workspace, relPath);
-    if (!existsSync24(absPath)) continue;
+    if (!existsSync25(absPath)) continue;
     if (await pathIsGitTracked(workspace, relPath)) continue;
     try {
       await rm(absPath, { recursive: true, force: true });
@@ -13060,9 +13320,9 @@ function levenshtein(a, b) {
 }
 
 // src/agent/runner.ts
-import { existsSync as existsSync25, mkdirSync as mkdirSync6, readdirSync as readdirSync9, unlinkSync as unlinkSync3, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync26, mkdirSync as mkdirSync6, readdirSync as readdirSync9, unlinkSync as unlinkSync3, writeFileSync as writeFileSync5 } from "fs";
 import { cp as cp2, mkdir as mkdir12, rm as rm2, stat as stat7 } from "fs/promises";
-import { dirname as dirname14, isAbsolute as isAbsolute2, join as join30, relative as relative11, resolve as resolve11 } from "path";
+import { dirname as dirname14, isAbsolute as isAbsolute2, join as join31, relative as relative11, resolve as resolve11 } from "path";
 var CONTEXT_TOKEN_LIMIT = 48e3;
 var permissionModes = /* @__PURE__ */ new Set(["default", "ask", "bypass", "plan"]);
 var sessionSpendTokens = 0;
@@ -13103,7 +13363,7 @@ function materializedContextCleanupEnabled(manifest, runContext) {
 async function cleanupMaterializedContext(workspace, manifest, runContext) {
   if (!materializedContextCleanupEnabled(manifest, runContext)) return;
   const taniaDir = resolve11(workspace, ".tania");
-  if (!existsSync25(taniaDir)) return;
+  if (!existsSync26(taniaDir)) return;
   if (await hasTrackedPathUnder(workspace, ".tania")) return;
   try {
     await rm2(taniaDir, { recursive: true, force: true });
@@ -13139,7 +13399,7 @@ function rotateRunSummaryFiles(runsDir) {
     if (excess <= 0) return;
     for (const stale of entries.slice(0, excess)) {
       try {
-        unlinkSync3(join30(runsDir, stale));
+        unlinkSync3(join31(runsDir, stale));
       } catch {
       }
     }
@@ -13148,11 +13408,11 @@ function rotateRunSummaryFiles(runsDir) {
 }
 function logRunSummarySilently(params) {
   try {
-    const runsDir = join30(params.workspace, ".tania", "runs");
-    const outputDir = params.parentRunId ? join30(runsDir, params.parentRunId) : runsDir;
+    const runsDir = join31(params.workspace, ".tania", "runs");
+    const outputDir = params.parentRunId ? join31(runsDir, params.parentRunId) : runsDir;
     mkdirSync6(outputDir, { recursive: true });
     const ts = (/* @__PURE__ */ new Date()).toISOString();
-    const logPath = join30(outputDir, params.parentRunId ? `${params.runId}.json` : `${params.runId}.json`);
+    const logPath = join31(outputDir, params.parentRunId ? `${params.runId}.json` : `${params.runId}.json`);
     writeFileSync5(
       logPath,
       JSON.stringify(
@@ -13297,7 +13557,7 @@ function pruneStaleRepairReminders(messages) {
   return messages.filter((msg, idx) => idx === lastIndex || !isRepairReminder(msg));
 }
 function isTypeScriptProject(workspace) {
-  return existsSync25(join30(workspace, "tsconfig.json"));
+  return existsSync26(join31(workspace, "tsconfig.json"));
 }
 function repairAttemptBudget(options) {
   const configured = typeof options.runContext?.metadata?.repairAttempts === "number" ? options.runContext.metadata.repairAttempts : typeof options.runContext?.metadata?.repairAttempts === "string" ? Number(options.runContext.metadata.repairAttempts) : options.repairAttempts;
@@ -13480,6 +13740,32 @@ function auditModelRouted(workspace, context, event) {
     reason: event.reason
   });
 }
+function forcedRouteFromRunContext(runContext) {
+  const metadata = runContext?.metadata;
+  if (!metadata) return null;
+  const forcedModel = stringMetadata(metadata, "forced_model") ?? stringMetadata(metadata, "forcedModel");
+  const forcedProvider = stringMetadata(metadata, "forced_cli") ?? stringMetadata(metadata, "forcedCli") ?? stringMetadata(metadata, "forced_provider") ?? stringMetadata(metadata, "forcedProvider");
+  if (!forcedModel && !forcedProvider) return null;
+  if (forcedModel?.includes("/") && !forcedProvider) {
+    const [provider2, model] = forcedModel.split("/", 2);
+    if (provider2?.trim() && model?.trim()) return { provider: provider2.trim(), model: model.trim() };
+  }
+  const provider = forcedProvider ?? inferForcedProvider(forcedModel ?? "");
+  if (!provider || !forcedModel) return null;
+  return { provider, model: forcedModel };
+}
+function stringMetadata(metadata, key) {
+  const value = metadata[key];
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function inferForcedProvider(model) {
+  if (/^deepseek-/i.test(model)) return "deepseek";
+  if (/^(?:gpt-|o\d|o\d-|chatgpt)/i.test(model)) return "openai";
+  if (/^claude-/i.test(model)) return "claude";
+  if (/^gemini-/i.test(model)) return "gemini";
+  if (/^qwen/i.test(model)) return "qwen";
+  return null;
+}
 function auditEscalation(workspace, context, event) {
   appendAuditDecision(workspace, {
     ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -13742,10 +14028,12 @@ async function runAgent(options) {
   let lastProviderKey = providerKey(activeProvider);
   if (options.routing?.enabled) {
     try {
+      const forcedRoute = forcedRouteFromRunContext(options.runContext);
       const initialRoute = resolveRouteWithContextGuard({
         stepType: "planning",
         table: options.routing.table,
-        messages: [...options.history ?? [], { role: "user", content: options.prompt }]
+        messages: [...options.history ?? [], { role: "user", content: options.prompt }],
+        ...forcedRoute ? { forcedRoute } : {}
       });
       activeProvider = options.routing.providerFactory(initialRoute);
       lastProviderKey = providerKey(activeProvider);
@@ -13961,7 +14249,7 @@ async function runAgent(options) {
     const outputRootValue = options.runContext?.metadata?.artifactOutputRoot;
     if (typeof outputRootValue !== "string" || !outputRootValue.trim()) return [];
     const localOutputRoot = resolve11(workspace, ".tania", "artifact-output");
-    if (!existsSync25(localOutputRoot)) return [];
+    if (!existsSync26(localOutputRoot)) return [];
     const localFiles = await listFilesRecursive(localOutputRoot);
     if (localFiles.length === 0) return [];
     const outputRoot = resolve11(outputRootValue);
@@ -13988,6 +14276,7 @@ async function runAgent(options) {
       promptTokens: totalPromptTokens,
       completionTokens: totalCompletionTokens,
       reasoningTokens: totalReasoningTokens,
+      costUsd: runSpendUsd,
       systemPromptTokens,
       repoMapTokens,
       toolResultTokens: totalToolResultTokens
@@ -14065,11 +14354,31 @@ async function runAgent(options) {
       auditModelRouted(workspace, permissionContext, event2);
       return { provider: provider2, stepType: forced.stepType };
     }
-    const stepType = classifyStep({ messages, turnIndex: turn, pendingToolCalls: pendingToolCallsForRouting() });
-    const route = preferredRouteForStep(stepType) ?? resolveRouteWithContextGuard({
+    const classifierState = {
+      messages,
+      turnIndex: turn,
+      pendingToolCalls: pendingToolCallsForRouting(),
+      cwd: workspace,
+      ...options.prompt ? { prompt: options.prompt } : {},
+      ...options.runContext ? { runContext: options.runContext } : {}
+    };
+    const stepType = classifyStep(classifierState);
+    const forcedRoute = forcedRouteFromRunContext(options.runContext);
+    const route = forcedRoute ? resolveRouteWithContextGuard({
       stepType,
       table: options.routing.table,
-      messages
+      messages,
+      prompt: options.prompt,
+      cwd: workspace,
+      ...options.runContext ? { runContext: options.runContext } : {},
+      forcedRoute
+    }) : preferredRouteForStep(stepType) ?? resolveRouteWithContextGuard({
+      stepType,
+      table: options.routing.table,
+      messages,
+      prompt: options.prompt,
+      cwd: workspace,
+      ...options.runContext ? { runContext: options.runContext } : {}
     });
     const provider = options.routing.providerFactory(route);
     const key = providerKey(provider);
@@ -14085,6 +14394,24 @@ async function runAgent(options) {
       cacheImpact
     };
     await options.sink(event);
+    if (route.cascade && route.cascade.selectedIndex > 0) {
+      await options.sink({
+        type: "provider.raw",
+        provider: provider.id,
+        model: provider.model,
+        event: {
+          type: "model_routed",
+          reason: "cascade-fit",
+          stepType,
+          provider: provider.id,
+          model: provider.model,
+          attempted_routes: route.cascade.attemptedRoutes,
+          estimated_tokens: route.cascade.estimatedTokens,
+          safety_factor: route.cascade.safetyFactor,
+          selected_route: route.cascade.selectedRoute
+        }
+      });
+    }
     auditModelRouted(workspace, permissionContext, event);
     return { provider, stepType, route };
   }
@@ -14947,7 +15274,7 @@ import { stdout } from "process";
 // src/sessions/storage.ts
 import { randomBytes } from "crypto";
 import {
-  existsSync as existsSync26,
+  existsSync as existsSync27,
   mkdirSync as mkdirSync7,
   readFileSync as readFileSync14,
   readdirSync as readdirSync10,
@@ -14957,7 +15284,7 @@ import {
   appendFileSync
 } from "fs";
 import { homedir as homedir5 } from "os";
-import { basename as basename6, dirname as dirname15, join as join31, parse, relative as relative12, resolve as resolve12 } from "path";
+import { basename as basename6, dirname as dirname15, join as join32, parse, relative as relative12, resolve as resolve12 } from "path";
 var activeSessionPaths = /* @__PURE__ */ new Map();
 function defaultCwd(cwd) {
   return resolve12(cwd ?? process.cwd());
@@ -14966,13 +15293,13 @@ function defaultHome(homeDir) {
   return resolve12(homeDir ?? homedir5());
 }
 function globalSessionsDir(homeDir) {
-  return join31(defaultHome(homeDir), ".tania", "sessions", "global");
+  return join32(defaultHome(homeDir), ".tania", "sessions", "global");
 }
 function findProjectTaniaDir(cwd) {
   let current = resolve12(cwd);
   while (true) {
-    const candidate = join31(current, ".tania");
-    if (existsSync26(candidate) && statSync10(candidate).isDirectory()) return candidate;
+    const candidate = join32(current, ".tania");
+    if (existsSync27(candidate) && statSync10(candidate).isDirectory()) return candidate;
     const parent = dirname15(current);
     if (parent === current) return null;
     current = parent;
@@ -14980,14 +15307,14 @@ function findProjectTaniaDir(cwd) {
 }
 function resolveSessionsDir(options = {}) {
   const projectTania = findProjectTaniaDir(defaultCwd(options.cwd));
-  if (projectTania) return { dir: join31(projectTania, "sessions"), scope: "project" };
+  if (projectTania) return { dir: join32(projectTania, "sessions"), scope: "project" };
   return { dir: globalSessionsDir(options.homeDir), scope: "global" };
 }
 function ensureSessionsDir(dir, scope) {
   mkdirSync7(dir, { recursive: true });
   if (scope === "project") {
-    const ignorePath = join31(dir, ".gitignore");
-    if (!existsSync26(ignorePath)) writeFileSync6(ignorePath, "*\n", "utf8");
+    const ignorePath = join32(dir, ".gitignore");
+    if (!existsSync27(ignorePath)) writeFileSync6(ignorePath, "*\n", "utf8");
   }
 }
 function shortLabel(content) {
@@ -15130,7 +15457,7 @@ function sanitizeTurn(turn) {
   return sanitized;
 }
 function sessionPath(dir, id) {
-  return join31(dir, `${id}.json`);
+  return join32(dir, `${id}.json`);
 }
 function jsonlPathFor(path) {
   return path.replace(/\.json$/, ".jsonl");
@@ -15153,7 +15480,7 @@ function readBaseSession(path) {
   };
 }
 function readTurnsFromJsonl(path, fallbackJsonPath) {
-  if (!existsSync26(path)) return { turns: readBaseSession(fallbackJsonPath).turns, warnings: [] };
+  if (!existsSync27(path)) return { turns: readBaseSession(fallbackJsonPath).turns, warnings: [] };
   const raw = readFileSync14(path, "utf8");
   const turns = [];
   const warnings = [];
@@ -15224,7 +15551,7 @@ function latestUpdatedAt(base, turns) {
 }
 function resolveSessionJsonPath(sessionId, options = {}) {
   const active = activeSessionPaths.get(sessionId);
-  if (active && existsSync26(active)) return active;
+  if (active && existsSync27(active)) return active;
   const matches = findSessionPathMatches(sessionId, options);
   if (matches.length === 1) return matches[0].path;
   if (matches.length > 1) throw new Error(`Session id "${sessionId}" is ambiguous: ${matches.map((match) => match.id).join(", ")}`);
@@ -15271,15 +15598,15 @@ function readSessionSummaries(dir, scope) {
   });
 }
 function sessionJsonFiles(dir) {
-  if (!existsSync26(dir)) return [];
-  return readdirSync10(dir).filter((file) => file.endsWith(".json")).sort().map((file) => join31(dir, file));
+  if (!existsSync27(dir)) return [];
+  return readdirSync10(dir).filter((file) => file.endsWith(".json")).sort().map((file) => join32(dir, file));
 }
 function sessionDirsForListing(options) {
   if (options.global) return [{ dir: globalSessionsDir(options.homeDir), scope: "global" }];
   const dirs = [];
   const cwd = defaultCwd(options.cwd);
   const projectTania = findProjectTaniaDir(cwd);
-  if (projectTania) dirs.push({ dir: join31(projectTania, "sessions"), scope: "project" });
+  if (projectTania) dirs.push({ dir: join32(projectTania, "sessions"), scope: "project" });
   dirs.push({ dir: globalSessionsDir(options.homeDir), scope: "global" });
   return dirs;
 }
@@ -15569,10 +15896,10 @@ function parseDuration(raw) {
 registerCommand(auditCommand);
 
 // src/safety/permissions/config.ts
-import { existsSync as existsSync27, mkdirSync as mkdirSync8, readFileSync as readFileSync15, renameSync as renameSync3, writeFileSync as writeFileSync7 } from "fs";
-import { dirname as dirname16, join as join32 } from "path";
+import { existsSync as existsSync28, mkdirSync as mkdirSync8, readFileSync as readFileSync15, renameSync as renameSync3, writeFileSync as writeFileSync7 } from "fs";
+import { dirname as dirname16, join as join33 } from "path";
 function writeProjectPermissionMode(cwd, mode) {
-  const path = join32(cwd, ".tania", "permissions.json");
+  const path = join33(cwd, ".tania", "permissions.json");
   const current = readProjectPermissions(path);
   const next = {
     ...current,
@@ -15586,7 +15913,7 @@ function writeProjectPermissionMode(cwd, mode) {
   return path;
 }
 function appendProjectSpendRule(cwd, rule) {
-  const path = join32(cwd, ".tania", "permissions.json");
+  const path = join33(cwd, ".tania", "permissions.json");
   const current = readProjectPermissions(path);
   const next = {
     ...current,
@@ -15596,7 +15923,7 @@ function appendProjectSpendRule(cwd, rule) {
   return path;
 }
 function readProjectPermissions(path) {
-  if (!existsSync27(path)) return { ...DEFAULT_PERMISSION_RULES };
+  if (!existsSync28(path)) return { ...DEFAULT_PERMISSION_RULES };
   const parsed = parsePermissionsJson(readFileSync15(path, "utf8"));
   return parsed.ok ? parsed.value : { ...DEFAULT_PERMISSION_RULES };
 }
@@ -15892,7 +16219,7 @@ registerCommand(helpCommand);
 
 // src/commands/builtin/memory.ts
 import { readdir as readdir7, readFile as readFile13 } from "fs/promises";
-import { join as join33 } from "path";
+import { join as join34 } from "path";
 var DEFAULT_LIMIT2 = 10;
 var memoryCommand = {
   name: "memory",
@@ -15973,7 +16300,7 @@ function indent(text2) {
 }
 registerCommand(memoryCommand);
 async function readChildRunSummary(workspace, runId) {
-  const runsRoot = join33(workspace, ".tania", "runs");
+  const runsRoot = join34(workspace, ".tania", "runs");
   const path = await findRunSummaryPath(runsRoot, `${runId}.json`);
   if (!path) return null;
   try {
@@ -15995,7 +16322,7 @@ async function findRunSummaryPath(dir, filename) {
     return null;
   }
   for (const entry of entries) {
-    const path = join33(dir, entry.name);
+    const path = join34(dir, entry.name);
     if (entry.isFile() && entry.name === filename) return path;
     if (entry.isDirectory()) {
       const nested = await findRunSummaryPath(path, filename);
@@ -16280,8 +16607,8 @@ registerCommand(resumeCommand);
 registerCommand(saveCommand);
 
 // src/commands/project.ts
-import { existsSync as existsSync28, readdirSync as readdirSync11 } from "fs";
-import { basename as basename7, extname as extname2, join as join34, relative as relative13 } from "path";
+import { existsSync as existsSync29, readdirSync as readdirSync11 } from "fs";
+import { basename as basename7, extname as extname2, join as join35, relative as relative13 } from "path";
 import { pathToFileURL } from "url";
 import { tsImport } from "tsx/esm/api";
 var supportedExtensions = /* @__PURE__ */ new Set([".js", ".ts", ".sh"]);
@@ -16291,8 +16618,8 @@ async function loadProjectCommands(workspace) {
   if (loadedWorkspace === workspace) return;
   loadedWorkspace = workspace;
   removeCommandsByCategory("project");
-  const commandsDir = join34(workspace, ".tania", "commands");
-  if (!existsSync28(commandsDir)) return;
+  const commandsDir = join35(workspace, ".tania", "commands");
+  if (!existsSync29(commandsDir)) return;
   let files = [];
   try {
     files = readdirSync11(commandsDir).filter((file) => supportedExtensions.has(extname2(file))).sort();
@@ -16301,7 +16628,7 @@ async function loadProjectCommands(workspace) {
     return;
   }
   for (const file of files) {
-    const path = join34(commandsDir, file);
+    const path = join35(commandsDir, file);
     try {
       const extension2 = extname2(file);
       if (extension2 === ".sh") {
@@ -16501,15 +16828,15 @@ function splitCommandArgs(input) {
 }
 
 // src/safety/permissions/learning.ts
-import { existsSync as existsSync29, mkdirSync as mkdirSync9, readFileSync as readFileSync16, renameSync as renameSync4, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync30, mkdirSync as mkdirSync9, readFileSync as readFileSync16, renameSync as renameSync4, writeFileSync as writeFileSync8 } from "fs";
 import { homedir as homedir6 } from "os";
-import { dirname as dirname17, join as join35 } from "path";
+import { dirname as dirname17, join as join36 } from "path";
 function permissionPatternForInput(tool, input) {
   return `${tool}:${escapeRegex2(inputShape(input))}`;
 }
 function appendLearnedPermissionRule(options) {
   const home = options.home ?? homedir6();
-  const path = join35(home, ".tanya", "permissions.json");
+  const path = join36(home, ".tanya", "permissions.json");
   const pattern2 = permissionPatternForInput(options.tool, options.input);
   const current = readUserPermissions(path);
   const next = {
@@ -16525,7 +16852,7 @@ function appendLearnedPermissionRule(options) {
   return pattern2;
 }
 function readUserPermissions(path) {
-  if (!existsSync29(path)) return { ...DEFAULT_PERMISSION_RULES };
+  if (!existsSync30(path)) return { ...DEFAULT_PERMISSION_RULES };
   const parsed = parsePermissionsJson(readFileSync16(path, "utf8"));
   if (!parsed.ok) return { ...DEFAULT_PERMISSION_RULES };
   return parsed.value;
@@ -16876,4 +17203,4 @@ export {
   dispatchInteractiveCommand,
   startInteractiveChat
 };
-//# sourceMappingURL=chunk-5PSV2Y3X.js.map
+//# sourceMappingURL=chunk-3NV2QP7J.js.map